CountdownLacth CyclicBarrier Join
Join:main里面调用t1.join,阻塞main线程,直到t1线程结束,main线程继续执行.
countdownLacth:线程计数器,初始化时指定计数器数值,阻塞await线程,直到计数器为0,被阻塞的线程执行,调用countDown()不会阻塞当前线程.
CyclicBarrier:多个线程同时阻塞在await处,当所有线程都执行到await处时,所有await的线程同时往下执行.
Join示例代码
public class JoinTest {
public static void main(String[] args) {
System.out.println("进入主线程");
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("t1线程开始执行");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1线程执行完毕");
}
});
t1.start();
try {
System.out.println("主线程开始等待");
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程继续执行");
}
}
log信息
进入主线程
主线程开始等待
t1线程开始执行
t1线程执行完毕
主线程继续执行
countdownLacth示例
public class UseCountDownLatch {
public static void main(String[] args) {
//初始化countdownLatch时设置计数器数字,如果这个案例改成3,那么t1永远在await
final CountDownLatch countDown = new CountDownLatch(2);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("进入线程t1" + "等待其他线程处理完成...");
countDown.await();
System.out.println("t1线程继续执行...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("t2线程初始化完毕，2s后计数器减一...");
Thread.sleep(2000);
countDown.countDown();
System.out.println("t2继续执行,");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("t3线程进行初始化操作，4s后计数器减一");
Thread.sleep(4000);
System.out.println("t3线程初始化完毕，计数器减一...");
countDown.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t2.start();
t3.start();
}
}
log信息
t2线程初始化完毕，2s后计数器减一...
t3线程进行初始化操作，4s后计数器减一
进入线程t1等待其他线程处理完成...
t2继续执行,
t3线程初始化完毕，计数器减一...
t1线程继续执行...
CyclicBarrier代码示例
public class CyclicBarrierTest {
static final CyclicBarrier barrier=new CyclicBarrier(3);
static class test implements Runnable{
@Override
public void run() {
try {
System.out.println("进入线程"+Thread.currentThread().getId()+"开始执行任务");
Thread.sleep(3000);
System.out.println("线程"+Thread.currentThread().getId()+"进入等待");
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println("线程"+Thread.currentThread().getId()+"开始执行");
}
}
public static void main(String[] args) {
ExecutorService executor= Executors.newFixedThreadPool(3);
executor.submit(new test());
executor.submit(new test());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
executor.submit(new test());
}
}
log信息
进入线程12开始执行任务
进入线程11开始执行任务
线程11进入等待
线程12进入等待
进入线程13开始执行任务
线程13进入等待
线程13开始执行
线程11开始执行
线程12开始执行
写这个示例的时候犯蠢了,线程池初始的时候写了2“newFixedThreadPool(2)”, CyclicBarrier(3)计数器是3，开始执行时卡住了 log信息如下
进入线程11开始执行任务
进入线程12开始执行任务
线程11进入等待
线程12进入等待
然后就不动了,仔细一想,线程池一共2条线程,全被await阻塞着,导致没有线程执行第三个任务了,形成了我等t3，t3等t1，t2线程释放,死循坏.
