今天进修CountDownLatch这个类，感化感受和join很像，然后就百度了一下，看了他们之间的区别。所以在此记录一下。
首先来看一下join，在当前方程中，若是挪用某个thread的join方式，那么当前方程就会被壅塞，直到thread线程执行完毕，当前方程才能持续执行。join的道理是，络续的搜检thread是否存活，若是存活，那么让当前方程一向wait，直到thread线程完结，线程的this.notifyAll 就会被挪用。
我们来看一下这个应用场景：假设如今公司有三个员工A,B,C，他们要开会。然则A需要等B,C预备好之后再才能起头，B,C需要同时预备。我们先用join模拟上面的场景。
Employee.java:public class Employee extends Thread{
private String employeeName;
private long time;
public Employee(String employeeName,long time){
this.employeeName = employeeName;
this.time = time;
}
@Override
public void run() {
try {
System.out.println(employeeName+ "起头预备");
Thread.sleep(time);
System.out.println(employeeName+" 预备完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
JoinTest.java:public class JoinTest {
public static void main(String[] args) throws InterruptedException {
Employee a = new Employee("A", 3000);
Employee b = new Employee("B", 3000);
Employee c = new Employee("C", 4000);
b.start();
c.start();
b.join();
c.join();
System.out.println("B,C预备完成");
a.start();
}
}
最后输出究竟如下:C起头预备
B起头预备
B 预备完成
C 预备完成
B,C预备完成
A起头预备
A 预备完成
能够看到,A老是在B,C预备完成之后才起头执行的。
CountDownLatch中我们首要用到两个方式一个是await()方式，挪用这个方式的线程会被壅塞，此外一个是countDown()方式，挪用这个方式会使计数器减一，当计数器的值为0时，因挪用await()方式被壅塞的线程会被叫醒，持续执行。
接下来，我们用CountDownLatch来模拟一下。
Employee.java:public class Employee extends Thread{
private String employeeName;
private long time;
private CountDownLatch countDownLatch;
public Employee(String employeeName,long time, CountDownLatch countDownLatch){
this.employeeName = employeeName;
this.time = time;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
try {
System.out.println(employeeName+ "起头预备");
Thread.sleep(time);
System.out.println(employeeName+" 预备完成");
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
}
CountDownLatchTest.java:public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(2);
Employee a = new Employee("A", 3000,countDownLatch);
Employee b = new Employee("B", 3000,countDownLatch);
Employee c = new Employee("C", 4000,countDownLatch);
b.start();
c.start();
countDownLatch.await();
System.out.println("B,C预备完成");
a.start();
}
}
输出究竟如下:B起头预备
C起头预备
B 预备完成
C 预备完成
B,C预备完成
A起头预备
A 预备完成
上面能够看到，CountDownLatch与join都可以模拟上述的场景，那么他们有什么分歧呢?这时候我们试想此外一个场景就能看到他们的区别了。
假设A，B，C的工作都分为两个阶段，A只需要守候B，C各自完成他们工作的第一个阶段就能够执行了。
我们来点窜一下Employee类：public class Employee extends Thread{
private String employeeName;
private long time;
private CountDownLatch countDownLatch;
public Employee(String employeeName,long time, CountDownLatch countDownLatch){
this.employeeName = employeeName;
this.time = time;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
try {
System.out.println(employeeName+ " 第一阶段起头预备");
Thread.sleep(time);
System.out.println(employeeName+" 第一阶段预备完成");
countDownLatch.countDown();
System.out.println(employeeName+ " 第二阶段起头预备");
Thread.sleep(time);
System.out.println(employeeName+" 第二阶段预备完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
CountDownLatchTest类不需要做点窜，输出究竟入下：B 第一阶段起头预备
C 第一阶段起头预备
B 第一阶段预备完成
B 第二阶段起头预备
C 第一阶段预备完成
C 第二阶段起头预备
B,C第一阶段预备完成
A 第一阶段起头预备
B 第二阶段预备完成
A 第一阶段预备完成
A 第二阶段起头预备
C 第二阶段预备完成
A 第二阶段预备完成
从究竟能够看出，A在B，C第一阶段预备完成的时候就起头执行了，不需要比及第二阶段预备完成。这种场景下，用join是没法实现的。
总结：挪用join方式需要守候thread执行完毕才能持续向下执行,而CountDownLatch只需要搜检计数器的值为零就能够持续向下执行，比拟之下，CountDownLatch加倍天真一些，能够实现一些加倍复杂的买卖场景。
