Java 多线程— 线程的生命周期及方法

这篇博客介绍线程的生命周期。

线程是一个动态执行的过程，它也有从建立到死亡的过程。

线程的几种状态

在 Thread 类中，有一个枚举内部类：

上面的信息以图片表示以下：

第一张图：

第二张图：把等待、计时等待、阻塞当作阻塞一个状态了

一、新建状态（new）:使用 new 建立一个线程，仅仅只是在堆中分配了内存空间

新建状态下，线程尚未调用 start()方法启动，只是存在一个线程对象而已

Thread t = new Thread();//这就是t线程的新建状态

二、可运行状态（runnable）：新建状态调用 start() 方法，进入可运行状态。而这个又分红两种状态，ready 和 running，分别表示就绪状态和运行状态

就绪状态：线程对象调用了 start() 方法，等待 JVM 的调度，（此时该线程并无运行）

运行状态：线程对象得到 JVM 调度，若是存在多个 CPU，那么运行多个线程并行运行

注意：线程对象只能调用一次 start() 方法，不然报错：illegaThreadStateExecptiong

三、阻塞状态（blocked）:正在运行的线程由于某种缘由放弃 CPU，暂时中止运行，就会进入阻塞状态。此时 JVM 不会给线程分配 CPU，知道线程从新进入就绪状态，才有机会转到 运行状态。

注意：阻塞状态只能先进入就绪状态，不能直接进入运行状态

阻塞状态分为两种状况：

①、当线程 A 处于可运行状态中，试图获取同步锁时，却被 B 线程获取，此时 JVM 把当前 A 线程放入锁池中，A线程进入阻塞状态

②、当线程处于运行状态时，发出了 IO 请求，此时进入阻塞状态

四、等待状态（waiting）:等待状态只能被其余线程唤醒，此时使用的是无参数的 wait() 方法

①、当线程处于运行状态时，调用了 wait() 方法，此时 JVM 把该线程放入等待池中

五、计时等待（timed waiting）:调用了带参数的 wait（long time）或 sleep(long time) 方法

①、当线程处于运行状态时，调用了带参数 wait 方法，此时 JVM 把该线程放入等待池中

②、当前线程调用了 sleep(long time) 方法

六、终止状态（terminated）:一般称为死亡状态，表示线程终止

①、正常终止，执行完 run() 方法，正常结束

②、强制终止，如调用 stop() 方法或 destory() 方法

③、异常终止，执行过程当中发生异常

线程的方法

一、sleep(long millis)

线程休眠：让执行的线程暂停一段时间，进入计时等待状态。

static void sleep(long millis):调用此方法后，当前线程放弃 CPU 资源，在指定的时间内，sleep 所在的线程不会得到可运行的机会，此状态下的线程不会释放同步锁。

该方法更多的是用来模拟网络延迟，让多线程并发访问同一资源时的错误效果更加明显。

二、wait()

线程等待：一旦一个线程执行到wait(),就释放当前的锁。

注意：此方法必须在同步代码块或同步方法中

三、notify()/notifyAll()

唤醒：唤醒wait的一个或全部的线程

    注意：此方法需和wait()成对使用，必须在同步代码块或同步方法中

注意 sleep() 和 wait() 的区别，sleep指定时间内当前线程放弃 CPU 资源，线程不会释放同步锁，wait 会放弃 CPU 资源，同时也会放弃 同步锁

四、join()

联合线程：表示这个线程等待另外一个线程完成后（死亡）才执行，join 方法被调用以后，线程对象处于阻塞状态。写在哪一个线程中，哪一个线程阻塞

这种也称为联合线程，就是说把当前线程和当前线程所在的线程联合成一个线程

五、 yield()

礼让线程：表示当前线程对象提示调度器本身愿意让出 CPU 资源。

调用该方法后，线程对象进入就绪状态，因此彻底有可能：某个线程调用了 yield() 方法，可是线程调度器又把它调度出来从新执行。

sleep() 和 yield() 方法的区别：

①、都能使当前处于运行状态的线程放弃 CPU资源，把运行的机会给其余线程

②、sleep 方法会给其余线程运行的机会，可是不考虑其余线程优先级的问题；yield 方法会优先给更高优先级的线程运行机会

③、调用 sleep 方法后，线程进入计时等待状态，调用 yield 方法后，线程进入就绪状态。在此我向你们推荐一个架构学习交流群。交流学习群号：821169538  里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多。

join示例：

public class TestThread1 {
    public static void main(String [] args){
        SubThread1 subThread1=new SubThread1();
        subThread1.start();
        for (int i=0;i<=100;i++){ 
           System.out.println(Thread.currentThread().getName()+":"+i);
           if(i==20){
                try {
                    subThread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class SubThread1 extends Thread{
    @Override
    public void run(){
        for (int i=0;i<=100;i++){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

运行结果：

main:0
main:1
main:2
main:3
main:4
main:5
main:6
main:7
main:8
main:9
main:10
Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
.
.
.
Thread-0:99
Thread-0:100
main:11
main:12
main:13
main:14
main:15
.
.
main:98
main:99
main:100

运行结果分析：在main线程中调用线程A的join()方法，此时main线程中止执行，直至A线程执行完毕，main线程再接着join()以后的代码执行

 线程的通讯

/**
 * @author: ChenHao
 * @Description:使用两个线程打印1-100，线程1，线程2交替打印
 * 线程通讯：以下的三个关键字使用的话，都得在同步代码块或同步方法中。
 * wait():一旦一个线程执行到wait(),就释放当前的锁。
 * notify()/notifyAll():唤醒wait的一个或全部的线程
 * 若是不使用break，程序将不会中止
 * @Date: Created in 10:50 2018/10/29
 */
public class TestPrintNum {
    public static void main(String [] args){
        PrintNum printNum=new PrintNum();
        Thread thread1=new Thread(printNum);
        Thread thread2=new Thread(printNum);
        thread1.start();
        thread2.start();
    }
}

class PrintNum implements Runnable{
    int num=1;
    @Override
    public void run(){
        while (true){
            synchronized (this){
                notify();
                if(num<=100){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+num++);
                }else {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

Thread-0:1
Thread-1:2
Thread-0:3
Thread-1:4
Thread-0:5
Thread-1:6
Thread-0:7
Thread-1:8
Thread-0:9
Thread-1:10
.
.
.

运行结果分析：当第一个线程获取锁以后，打印后wait,释放锁；第二个线程获取锁，并唤醒第一个线程，打印后wait；交替打印