并发编程 — 4. 线程Thread

线程状态

java中线程的状态分为6种：

1. 初始化（New）：当线程完成对象创建后，即new Thread(...)，还没有调用start()方法之前，线程处于此状态。
2. 运行态（Runnable）:调用start方法，正在jvm中运行，但是可能正在等待操作系统的其他资源。（包含了操作系统的可运行和运行中状态）
3. 阻塞（Blocked）：受阻塞，并且正在等待监视器锁。
4. 等待（Waiting）：处于等待状态的线程，正在等待另一个线程执行特定的操作
5. 超时等待（Timed_Waiting）：该状态与等待（Waiting）的不同点在于，它可以在指定时间后自行返回。
6. 终止（Terminated）：线程执行完成或执行过程中出现异常时处于此状态。
    

操作系统中线程的状态分为5种：

1. 初始状态：线程刚被创建，还未被分配 CPU 
2. 可运行状态（Ready）：线程等待系统分配 CPU ，从而执行任务。
3. 运行中（Running)：操作系统将 CPU 分配给线程，线程执行任务。
4. 休眠状态：线程让出CPU使用权，进入休眠状态。休眠结束，线程状态将会先变成可运行状态。（包含了java中的阻塞、等待、超时等待状态）
5. 终止状态：线程执行结束或者执行过程发生异常将会使线程进入终止状态，这个状态下线程使命已经结束。

状态转换图

Wait/Notify通知机制

wait()方法可以让线程进入等待状态，而notify()可以使等待的状态唤醒。这样的同步机制十分适合生产者、消费者模式：消费者消费某个资源，而生产者生产该资源。当该资源缺失时，消费者调用wait()方法进行自我阻塞，等待生产者的生产；生产者生产完毕后调用notify/notifyAll()唤醒消费者进行消费。

//消费者线程
static class Consume implements Runnable {
    @Override
    public void run() {
        synchronized (obj) {
            System.out.println("消费者：进入线程");
            System.out.println("消费者：wait flag 1:" + flag);
			//判断条件是否满足，若不满足则等待
            while (!flag) {  
                try {
                    System.out.println("消费者：还没生产，进入等待");
                    obj.wait();
                    System.out.println("消费者：结束等待");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("消费者：wait flag 2:" + flag);
            System.out.println("消费者：开始消费");
            System.out.println("消费者：结束消费");
        }

    }
}


public static void main(String[] args) throws Exception {

    Thread consume = new Thread(new Consume(), "Consume");
    Thread produce = new Thread(new Produce(), "Produce");
	//让消费者先消费，再启动生产者
    consume.start();
    Thread.sleep(1000);
    produce.start();

    try {
        produce.join();
        consume.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

上述用例执行结果如下：

消费者：进入线程
消费者：wait flag 1:false
消费者：还没生产，进入等待
生产者：进入生产者线程
生产者：开始生产
生产者：结束生产
消费者：结束等待
消费者：wait flag 2:true
消费者：开始消费
消费者：结束消费

从结果的输出可以得到以下结论。

1. wait函数让消费者陷入等待阶段，然后生产者生产完成后调用notify发出通知，而消费者接到通知后并没有立刻进行消费，因为生产者在这里仍然持有锁，直到生产者完全退出代码块，消费者才开始消费。

2. 消费者被唤醒时线程并不是由等待阻塞直接到运行态，而是先转到同步阻塞，由等待队列转移到阻塞队列，等到拿到对象的锁才会执行（毕竟synchronized同步方法（块）同一时刻只允许一个线程在里面）。

3. 消费者执行时是继续执行而不是重新进入同步代码块。

Wait/Notify使用条件

那是不是不用synchronized，就可以达到消费者被唤醒后就立马消费呢？
将上述锁住代码块的synchronized代码删除再运行发现报错 java.lang.IllegalMonitorStateException，JDK对该异常的描述如下：线程试图等待对象的监视器或者试图通知其他正在等待对象监视器的线程，但本身没有对应的监视器的所有权。
这是因为调用wait方法并没有获取到对象的monitor所有权，而synchronized底层原理就是通过给对象添加monitorenter来完成锁功能。
因此Wait/Notify机制只能在synchronized代码块中使用。