多线程（4）线程生命周期

多线程有六个状态

1.New（新创建）: 已创建但是还没有启动的新线程， new Thread()还没执行start()

2.Runnable（可运行） :，包括start()后等待运行和拿到资源运行中

3.Blocked（被阻塞）: synchronized修饰的代码没有拿到锁(monitor)陷入的等待状态。注意必须是synchronized修饰，其他的锁不是

4.Waiting（等待）: Object.wait()， Thread.join(), LockSupport.park()这三个没有timeout参数的方法会让线程进入等待状态.

Object.notify()或者Object.notifyAll(), 等待join方法所运行的线程执行完毕， LockSupport.unpark() 会让等待的线程进入可运行状态

Lock.lock进入的是waiting状态而不是Blocked

waiting和blocked的区别根本原因是“是不是内置锁”。Lock不是Java语言支持的锁，是JDK包提供的，而synchronized是关键字级别是，它们不一样。

5.Timed Waiting（计时等待）: 等待的那三个方法带了时间参数，超时会自动唤醒也可以被notify等唤醒

6.Terminated(被终止)：run方法正常执行完，run被未捕获的异常终止

注意：状态的转换只能是箭头的方向不能跳跃。

/**
 * 常见的New Runnable Terminated状态
 * @author Administrator
 *
 */
public class NewRunnableTerminated implements Runnable {

    public static void main(String[] args) throws InterruptedException {
        NewRunnableTerminated n = new NewRunnableTerminated();
        Thread t = new Thread(n);
        System.out.println(t.getState()); // new
        t.start();
        System.out.println(t.getState());// 准备运行runnable
        Thread.sleep(2);
        System.out.println(t.getState()); // 运行中runnable
        t.join();
        System.out.println(t.getState()); // 结束了Terminated
    }

    @Override
    public void run() {
        for(int i=0; i<1000; i++) {
            System.out.println(i);
        }
    }
}


/**
 * Blocked Waiting Timedwaiting三种状态
 * @author Administrator
 *
 */
public class BlockedWaitingTimedwaiting implements Runnable {

    public static void main(String[] args) throws InterruptedException {
        BlockedWaitingTimedwaiting b = new BlockedWaitingTimedwaiting();
        Thread t1 = new Thread(b);
        Thread t2 = new Thread(b);
        t1.start();
        t2.start();
        Thread.sleep(10);
        // t1进入sleep会使timedwaiting状态
        System.out.println(t1.getState());
        Thread.sleep(100);
        // t2进入synchronized方法没有锁，blocked
        System.out.println(t2.getState());
        Thread.sleep(1500);
        // t1进入wait方法会使waiting状态
        System.out.println(t1.getState());
    }

    @Override
    public void run() {
        sync();
    }
    
    public synchronized void sync() {
        try {
            // sleep不会释放锁。后面的线程会阻塞状态
            Thread.sleep(1000); // 进入sleep中是timedwaiting状态
            this.wait(); //这时是waiting状态， wait会释放锁，t2可以进来
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

<JAVA并发编程实战》

来源：https://www.cnblogs.com/t96fxi/p/12618814.html

标签

线程

多线程

线程阻塞

synchronized