CountdownLacth CyclicBarrier Join

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线程释放,死循坏.

这3个都有阻塞线程的功能,但是有所区别

join:阻塞当前线程,只有等子线程完全执行完成之后才能继续执行,不是那么灵活.

CyclicBarrier:在多个线程中设置阻塞点,直到所有所有线程都执行到阻塞点,所有被阻塞的线程才同时进行执行。

countdownLacth:阻塞一个或多个线程,等待任务线程执行，任务线程到一定程度就可以调用countdown，然后不会阻塞任务线程,当计数器为0时主线程恢复执行.比join更加灵活一些，也可以实现CyclicBarrier的效果,就是麻烦一些。如果计数器为先设置为0,在进行await,那么对线程没有阻塞作用.