Java 多线程技能

概念

区分线程和进程

进程——>.exe程序，进程是受系统操作管理的基本单元

线程：可以理解成是在进程中独立运行的子任务。

 

使用多线程的优点：可以最大限度地利用CPU的空闲时间来处理其他任务

使用多线程也就是在使用异步。

 

使用多线程

实现方式

1.继承Thread类

public class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("run方法的打印："+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            MyThread myThread = new MyThread();

            myThread.start();
        }
    }
}

 

 

MyThread类中的run 方法比较晚，这就是说明使用多线程技术时，代码的运行结果与代码执行顺序或调用顺序无关

线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法.

a.myThread.start(),方法是通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。

b.myThread.run()就不是异步执行了，而是同步，那么此此线程对象并不是交给“线程规划器”处理，而是由main主线程来调用run()方法，也就是必须等run()方法中的代码执行后才可以执行后面的代码。

 

 

2.实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("运行中！");
    }


    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        System.out.println("运行结束！");
    }
}

其中Thread类实现了Runnable接口，Java语言的特点就是单继承，所以为了支持多继承，完全可以实现Runnable接口的方法

 

Thead.java类也实现了Runnalbe接口

那也就意味着构造函数Thead(Runnable targer) 不光可以传入Runnable接口的对象，还可以传入一个Thread 类的对象，这样做完全可以将一个Thread对象中的run方法交由其他线程调用

 

 

3.isAlive()

方法是判断当前的线程是否处于活动状态

什么是活动状态，就是线程已经启动且尚未终止。线程处于正在运行或者准备开始运行的状态，就认为线程是“存活”的。

 

4.sleep()

 

方法sleep()的作用就是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停这个线程）。

这个正在执行的线程是指this.currentThread()返回的线程。

Thread.sleep(2000);

 

5.停止线程

在Java 中有三种方法可以终止正在运行的线程

• 1.使用推出标致，是线程正常退出，也就是当run方法完成后线程终止。
• 2.使用stop方法强行终止线程，但是不推荐这个方法，因为stop和suspend及resume一样，都是作废的方法，使用他们可能产生不可预料的结果。
• 3.使用interrupt

 

1.this.interrupted();测试当前线程是否已经是中断状态，执行后具有将状态标志置清除为false的功能。

2.this.isInterrupted():测试线程Thread对象是否已经是中断状态，但不清除标志。

能停止的线程——异常法

 

public class ExceptionThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 5000000; i++) {
                if (this.interrupted()) {
                    System.out.println("已经是停止状态了！我要退出了！");
                    throw new InterruptedException();
                }
                System.out.println("i=" + (i + 1));
            }
            System.out.println("我再for下面！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }


}

 

public class Run {
    public static void main(String[] args) {
        ExceptionThread exceptionThread = new ExceptionThread();
        exceptionThread.start();

        try {
            Thread.sleep(1000);
            exceptionThread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下

 

在沉睡中停止

 

a.先睡后停止

public class SleepThread extends Thread {
    @Override
    public void run() {
        super.run();

        System.out.println("run begin");

        try {
            Thread.sleep(2000);
            System.out.println("run end");
        } catch (InterruptedException e) {
            System.out.println("在沉睡中被停止！进入catch"+this.isInterrupted());
            e.printStackTrace();
        }

    }
}

public class SleepRun {
    public static void main(String[] args) {
        SleepThread sleepThread = new SleepThread();
        sleepThread.start();
        try {
            Thread.sleep(200);
            sleepThread.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end!");


    }
}

运行结果

 

b.先停止后睡

public class LastSleepThread extends Thread {
    @Override
    public void run() {
        super.run();
        try {
            for (int i = 0; i < 10000; i++) {
                System.out.println("i=" + (i + 1));
            }
            System.out.println("run begin");
            Thread.sleep(200000);
            System.out.println("run end");
        } catch (InterruptedException e) {
            System.out.println("先停止，在遇到了sleep! 进入catch!");
            e.printStackTrace();
        }
    }
}

public class LastSleepRun {
    public static void main(String[] args) {
        try {
            LastSleepThread lastSleepThread = new LastSleepThread();
            lastSleepThread.start();
            lastSleepThread.interrupt();
            System.out.println("end");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

能停止的线程——暴力停止

使用stop（）方法停止线程

stop()已经作废，因为如果强制让线程停止则有可能使一些请理性的工作得不到完成。另外一个情况就是对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现数据不一致的问题。

使用return停止线程

public class ReturnThread extends Thread {

    @Override
    public void run() {
        while (true){
            if(this.isInterrupted()){
                System.out.println("停止了！");
                return;
            }
            System.out.println("timer="+System.currentTimeMillis());
        }

    }
}

public class ReturnRun {

    public static void main(String[] args) {
        try {
            ReturnThread returnThread = new ReturnThread();
            returnThread.start();
            Thread.sleep(2000);
            returnThread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6.暂停线程

暂停线程意味着此线程还可以恢复运行。在java中使用suspend()方法暂停线程，使用resume(）方法恢复线程的执行。

suspend与resume方法的缺点——独占，极易造成公共的同步对象的独占，使得其他线程无法访问公共同步对象。

 

7.yield方法

yield（）方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间。当放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。

8.线程的优先级

使用线程的优先级使用setPriority()方法。

在Java中，线程的优先级分为1-10这10个等级。

线程优先级的继承特性。

线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的。

优先级具有随机性。

9.守护线程

java线程分为两种线程，一种是用户线程，另外一种是守护线程。

什么是守护线程？守护线程是一种特殊的线程，他的特性有陪伴的意义，当进程中不存在非守护线程了，则守护线程自动销毁。

典型的守护线程就是垃圾回收线程。