前言

前面我们讲了Java的线程模型和Thread，Runnable的基础相关，这一节我们来开下它们在具体场景下的应用。

join

有这样一种场景，比如线程A执行到一半，需要一个数据，这个数据需要线程B去执行修改，那该怎么实现这种业务呢，Thread.join()就登场了。

public class Main {
    int num;
    Thread threadA, threadB;
    public Main() {
        threadA = new Thread() {
          @Override
          public void run() {
              System.out.println("====> A开始执行");
              if (num == 0) {
                  try {
                      System.out.println("====> A需要B把num修改成5，A等待B执行完毕");
                      threadB.join();
                      System.out.println("====> B执行完毕，A重新开始执行，num = " + num);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
        };
        threadB = new Thread() {
            @Override
            public void run() {
                System.out.println("====> B开始执行");
                num = 5;
            }
        };
    }
    public static void main(String[] args) {
        Main main = new Main();
        main.threadA.start();
        main.threadB.start();
    }
}
//输出，不加join
====> A开始执行
====> A需要B把num修改成5，A等待B执行完毕
====> B开始执行
====> B执行完毕，A重新开始执行，num = 0
//输出，加join，B先执行完毕
====> A开始执行
====> B开始执行
====> A需要B把num修改成5，A等待B执行完毕
====> B执行完毕，A重新开始执行，num = 5

可见看见，通过调用threadB.join方法让B先执行完毕，所以A得到num结果为5，如果不加，为0。
另一个例子

Thread threadA = new Thread() {
    @Override
    public void run() {
        printNumber("threadA:" + Thread.currentThread().getName());
    }
};
Thread threadB = new Thread() {
    @Override
    public void run() {
        printNumber("threadB:" + Thread.currentThread().getName());
    }
};
threadA.start();
threadB.start();

private void printNumber(String threadName) {
    for (int i = 1; i <= 3; i++) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(threadName + "print:" + i);
    }
}
//输出，A，B交替显示
threadA:Thread-0print:1
threadB:Thread-1print:1
threadB:Thread-1print:2
threadA:Thread-0print:2
threadB:Thread-1print:3
threadA:Thread-0print:3

假如我们想A和B分开显示怎么办，即先执行完线程A，再执行线程B，join这时又登场了。我们就可以修改线程B的代码，在B的run里面调用A.join，让A执行完毕。

Thread threadB = new Thread() {
    @Override
    public void run() {
        System.out.println("threadB 开始等待 threadA");
        try {
            threadA.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("threadA执行完毕，可以执行threadB了");
        printNumber("threadB:" + Thread.currentThread().getName());
    }
};
//输出，A先执行完毕，B再执行
threadB 开始等待 threadA
threadA:Thread-0print:1
threadA:Thread-0print:2
threadA:Thread-0print:3
threadA执行完毕，可以执行threadB了
threadB:Thread-1print:1
threadB:Thread-1print:2
threadB:Thread-1print:3

wait,notify/notifyAll

还是上面的例子，假如我们想让A输出1后，转到B输出完毕，然后再回来输出A剩下的，该怎么办了，这就要用到锁机制。前一节我们讲了synchronized的相关用法。修改Thread代码：

Object object = new Object();
threadA = new Thread() {
    @Override
    public void run() {
        synchronized (object) {
            System.out.println("threadA 1");
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("threadA 2");
            System.out.println("threadA 3");
        }

    }
};
threadB = new Thread() {
    @Override
    public void run() {
        synchronized (object) {
            System.out.println("threadB 1");
            System.out.println("threadB 2");
            System.out.println("threadB 3");
            //一定要通知唤醒，否则线程A一直等待
            object.notifyAll();
        }
    }
};
//输出
threadA 1
threadB 1
threadB 2
threadB 3
threadA 2
threadA 3

  可以看见A先输出1，B输出1,2,3，A再输出2,3。当A输出1后，调用wait方法吧线程A放入object的等待队列，并释放object锁。这是线程B去获取到object锁，执行输出1,2,3。执行完毕后一定要调用notifyAll通知等待队列的线程，否则它们会一直等待。A被唤醒后重新获取object的锁，并执行wait后面的代码。
  再假如如果想让两个线程交替执行呢？假如A输出1个数，B再输出一个数，这样交替执行，该怎么办呢？这里我们可以借助一个flag来执行

volatile boolean flag;
threadA = new Thread() {
    @Override
    public void run() {
        for (int i = 0; i < 5; ) {
            synchronized (object) {
                if (flag) {
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    i++;
                    System.out.println("threadA:" + i);
                    flag = true;
                    object.notify();
                }
            }
        }
    }
};
threadB = new Thread() {
    @Override
    public void run() {
        synchronized (object) {
            for (int i = 0; i < 5; ) {
                if (!flag) {
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    i++;
                    System.out.println("threadB:" + i);
                    flag = false;
                    object.notify();
                }
            }
        }
    }
};
//输出
threadA:1
threadB:1
threadA:2
threadB:2
threadA:3
threadB:3
threadA:4
threadB:4
threadA:5
threadB:5

这里借助于一个flag，当flag为true时，A等待，否则A输出一个数，并把flag置为true，这样A输出一个数后A就会进入等待状态；同理，当flag为false，B等待，否则B输出一个数，把flag置为false，B进入等待状态。一直这样交替执行下去。

CountdownLatch

另一种情况，假如有A，B，C，D 4个线程，D要等A，B，C三个执行完毕后，D才执行，其中A，B，C三个是乱序执行，无先后顺序。那么D该如何知道A，B，C三个线程执行完呢？这就要用到CountdownLatch。
  CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

Thread threadD = new Thread() {
    @Override
    public void run() {
        System.out.println("D开始等待A，B，C执行完毕");
        try {
            countDownLatch.await();
            System.out.println("A,B,C执行完毕，D开始执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
};
threadD.start();
for (char name = 'A'; name <= 'C'; name++) {
    final String threadName = "thread" + name;
    new Thread() {
        @Override
        public void run() {
            System.out.println(threadName + "开始执行");
            try {
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(threadName + "执行完毕");
            countDownLatch.countDown();
        }
    }.start();
}
//输出
D开始等待A，B，C执行完毕
threadA开始执行
threadB开始执行
threadC开始执行
threadC执行完毕
threadA执行完毕
threadB执行完毕
A,B,C执行完毕，D开始执行

可以看到A，B，C各自执行完后，D才开始执行。用之前的wait，notify已经不能完成了。CountDownLatch应用场景：比如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

CyclicBarrier

再以上面CountDownLatch的例子，修改一下，假如A，B，C，D 4个线程互相等对方完成一些初始化操作后，再一起执行。即线程间互相等待，用CountDownLatch是无法完成的，这里就要用到CyclicBarrier。
  CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier cyclicBarrier = new CyclicBarrier(4);
for (char name = 'A'; name <= 'D'; name++) {
    final String threadName = "thread" + name;
    new Thread() {
        @Override
        public void run() {
            System.out.println(threadName + "开始初始化");
            try {
                Thread.sleep(new Random().nextInt(100));
                System.out.println(threadName + "初始化完毕完毕，等待其他线程");
                cyclicBarrier.await();
                System.out.println(threadName + "继续开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        } 
    }.start();
}
//输出
threadA开始初始化
threadC开始初始化
threadB开始初始化
threadD开始初始化
threadD初始化完毕完毕，等待其他线程
threadB初始化完毕完毕，等待其他线程
threadA初始化完毕完毕，等待其他线程
threadC初始化完毕完毕，等待其他线程
threadD继续开始执行
threadC继续开始执行
threadB继续开始执行
threadA继续开始执行