用于多线程计算数据，最后合并计算结果的应用场景
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）
它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。
CyclicBarrier和CountDownLatch的区别
- CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。
- CyclicBarrier强调的是n个线程，大家相互等待，只要有一个没完成，所有人都得等着
countdownlatch:
场景：
doJob();
countDownLatch.countDown(); //表示任务完成了
afterJob();// 一般后续没有代码，如果有则逻辑会比较乱，不建议使用countdownlatch。
cyclicBarrier:
场景：
doJob();
cyclicBarrier.await(); // 通知CyclicBarrier，我到达了同步点，线程挂起，暂停执行。
afterJob();// 这部分在其余线程都到达同步点后，继续执行。
import java.util.concurrent.CountDownLatch;
public class TestCountDownLantch {
// 等待三个任务线程通知执行完成
static CountDownLatch cdl = new CountDownLatch(3);
public static void main(String[] args) {
for(int i=0; i<3; i++){
new Thread(new worker(i, cdl)).start();
}
try {
System.out.println("wait for work threads...");
cdl.await();
System.out.println("OK! all threads done. I can do something...->>");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
static class worker implements Runnable{
private final int id;
private CountDownLatch cdl;
public worker(int id, CountDownLatch cdl){
this.id = id;
this.cdl = cdl;
}
@Override
public void run(){
try {
System.out.println(id+" working...");
Thread.sleep(id*2000+10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.err.println(id+" done.");
cdl.countDown();
System.out.println(id+" going on...");
}
}
}
wait for work threads... 0 working... 2 working... 1 working... 0 going on... 0 done. 1 done. 1 going on... 2 done. 2 going on... OK! all threads done. I can do something...->>
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class TestCyclicBarrier {
public static void main(String[] args) {
CyclicBarrier cBarrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println("OK! all threads done. let's go! ->>>");
}
});
for(int i=0; i<3; i++){
new Thread(new workThread(i, cBarrier)).start();
}
}
static class workThread implements Runnable{
private final int id;
private CyclicBarrier cBarrier;
public workThread(int id, CyclicBarrier barrier) {
this.id = id;
cBarrier = barrier;
}
@Override
public void run() {
try {
System.out.println("thread " + id + " working...");
Thread.sleep(id*1000+10);
System.out.println("thread " + id + " done.");
cBarrier.await();
System.out.println("thread " + id + " going on...");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
}
thread 0 working... thread 2 working... thread 1 working... thread 0 done. thread 1 done. thread 2 done. OK! all threads done. let's go! ->>> thread 0 going on... thread 1 going on... thread 2 going on...
Thread.join() 等待该线程终止信号
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，
但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，
这个时候就要用到join()方法了
public class TestJoin {
static Thread[] threads = new Thread[5];
public static void main(String[] args) {
System.out.println("waiting all thread work done...");
for(int i=0; i<5; i++){
Thread t = new Thread(new workerThread(i));
t.start();
threads[i] = t;
}
for(Thread t : threads){
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("main going on...");
}
static class workerThread implements Runnable{
final int id;
public workerThread(int id) {
this.id = id;
}
@Override
public void run() {
try {
System.out.println(id+" working...");
Thread.sleep(id*2000+10);
System.out.println(id+" done.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
waiting all thread work done...
1 working...
3 working...
0 working...
2 working...
4 working...
0 done.
1 done.
2 done.
3 done.
4 done.
main going on...