并发基础_4_并发_线程间通信

线程间通信

Volatile和synchronized关键字

Voliatile

Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝(本地内存中共享变量的副本)，
所以程序在执行过程中，一个线程看到的变量并不一定是最新的。

关键字volatile可以用来修饰字段(成员变量)，就是告知程序 任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回
共享内存，它能保证所有想成对变量访问的可见性。

举个栗子：
定义一个表示程序是否运行的成员变量 boolean on = true; 那么另一个线程可能对它执行关闭动作(on = false;)，
这里涉及多个线程对变量的访问，因此需要将其定义为volatile boolean on = true，这样其他线程对其进行改变时，可以让所有线程感知到变化，
因为所有对on变量的访问和修改都需要以共享内存为准。

但是，过多的使用volatile是不必要的，因为它会降低程序的执行效率。

synchronized

关键字synchronized可以修饰方法或以同步块的形式使用，它主要确保多个线程在同一时刻，只有一个线程处于该方法或同步块中，
它保证了线程对变量访问的可见性和排他性。

在第一篇中比较详细讲解了volatile和synchronized关键字：并发基础_1_并发_底层实现

等待/通知机制

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。
前者是生产者，后者是消费者，这种模式隔离了"做什么" 和 "怎么做"，在功能上实现了解耦，体系结构上具备了良好的伸缩性。

等待/通知的相关方法是任意Java对象都具备的。因为这些方法被定义在所有对象的超类Java.lang.Object上

方法名称               描述
notify()                   通知一个在对象上等待的线程，使其从wait()方法返回，而返回的前提是该线程获取到了对象的锁
notifyAll()              通知所有等待在该对象上的线程
wait()                     调用该方法的线程进入WAITING状态，只有等待另外线程的通知或被中断才会返回，需要注意，调用wait()方法后，会释放对象锁
wait(long)             超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n毫秒，如果没有通知就超时返回
wait(long , int)      对于超时时间更细粒度的控制，可以达到纳秒

等待/通知机制，是指一个线程A调用对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的notify()或notifyAll()方法，
线程A收到通知后从对象O的wait()方法返回，进而执行后续操作。

我们来看一个经典的例子：

public class WaitNotify {static boolean flag = true;static Object lock = new Object();public static void main(String[] args) throws Exception {Thread waitThread = new Thread(new Wait(), "WaitThread");waitThread.start();TimeUnit.SECONDS.sleep(1);Thread notifyThread = new Thread(new Notify(), "NotifyThread");notifyThread.start();}static class Wait implements Runnable {@Overridepublic void run() {// 加锁，拥有locksynchronized (lock) {// 当条件不满足时，继续wait，同时释放了lock的锁while (flag) {try {System.out.println(Thread.currentThread().getName() + " flag is true , 进入等待状态wait");lock.wait();} catch (Exception e) {e.printStackTrace();}}// 条件满足时，完成工作System.out.println(Thread.currentThread().getName() + " flag is false , 进入运行状态running");}}}static class Notify implements Runnable {@Overridepublic void run() {// 加锁，拥有locksynchronized (lock) {// 获取lock锁，然后进行通知，通知时不会释放lock锁。// 直到当前线程释放了lock后，WaitThread才能从wait方法中返回try {System.out.println(Thread.currentThread().getName() + " 获得 lock. 通知 其他线程 notify ");lock.notifyAll();flag = false;TimeUnit.SECONDS.sleep(5);} catch (Exception e) {}}// 再次加锁synchronized (lock) {try {System.out.println(Thread.currentThread().getName() + " hold lock again , sleep ");TimeUnit.SECONDS.sleep(5);} catch (Exception e) {}}}}}输出结果：WaitThread flag is true , 进入等待状态waitNotifyThread 获得 lock. 通知 其他线程 notify NotifyThread hold lock again , sleep WaitThread flag is false , 进入运行状态running

注意： 输出结果中的第三第四行可能会互换，这个不影响。

注意细节：
a. 使用wait()、notify()和notifyAll()需要先对调用对象加锁。
b. 调用wait()方法后，线程状态由Running变为Waiting状态，并将当前线程放置到对象的等待队列
c. notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，
    需要调用notify()或notifyAll()的线程释放锁之后，等待线程才有机会从wait()返回。
d. notify()方法将等待队列中的一个线程从等待队列中移到同步队列中，
    而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由Waiting状态变为Blocked状态。
e. 从wait()方法返回的前提是获得了调用对象的锁。

从上述细节中可以看出，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

从上图可以看到：
a. WaitThread首先获得了对象锁，然后调用对象的wait()方法，从而放弃了锁，并进入了对象的等待队列WaitQueue中，进入了等待状态。
b. 由于WaitThread释放了对象的锁，NotifyThread随后获取了对象锁，并调用了对象的notify()方法
c. 将WaitThread从WaitQueue移到SynchroizedQueue中，此时WaitThread的状态变为阻塞状态。
d. NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

这个图我看的...有些懵逼..╮(╯▽╰)╭

等待/通知机制经典范式
从上面的例子中，可以提炼出经典范式，分为等待方(消费者) 和 通知方(生产者)

等待方遵循原则：
a. 获取对象锁
b. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
c. 条件满足则执行对应的逻辑

synchronized (对象) {while(条件不满足){对象.wait();}对应处理逻辑}

通知方遵循原则：
a. 获得对象锁
b. 改变条件
c. 通知所有等待在对象上的线程

synchronized (对象) {改变条件对象.notifyAll();}

Thread.join()的使用

为什么要使用join()
在很多情况下，主线程生成并启动了子线程，如果子线程运行较慢，主线程往往在子线程之前运行结束，如果我们需要让主线程等待子线程运行结束，

再接着运行主线程，这时候，就需要join了

join()方法的用法
JDK中对join方法解释为：“等待该线程终止”；
换句话说就是：”当前线程等待子线程的终止“。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了当前线程才能执行。

原书解释：如果一个线程A执行了thread.join()，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。

简单点说：有两个线程 A 和 B，在线程B中调用了线程A的join()，那么直到线程A运行完毕，才能继续运行线程B主线程等待调用join方法的子线程执行结束后再继续执行

join()方法还提供了超时的特性，超时表示：如果线程thread在给定的超时时间里没有终止，那么就会从该方法中返回。

来个Demo

public class Join {public static void main(String[] args) throws Exception {Thread previous = Thread.currentThread();for (int i = 0; i < 10; i++) {Thread thread = new Thread(new Domino(previous), String.valueOf(i));thread.start();previous = thread;}TimeUnit.SECONDS.sleep(5);System.out.println(Thread.currentThread().getName() + " terminate");}}public class Domino implements Runnable {private Thread thread;public Domino(Thread thread) {this.thread = thread;}@Overridepublic void run() {try {thread.join();} catch (Exception e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " treminate");}}输出结果：main terminate0 treminate1 treminate2 treminate3 treminate4 treminate5 treminate6 treminate7 treminate8 treminate9 treminate

从输出结果可以看出，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，采用join()方法返回。

参考资料：

http://blog.csdn.net/dabing69221/article/details/17472901