java wait,notify,join ,countDownLatch 实现线程间通信合作

利用多线程交替打出1和2

• notify 和 wait适合操作同一共享资源

如A 做生产者，然后B做消费者，A生产好了通知B消费，然后，B消费完了可以通知A继续生产。

import lombok.SneakyThrows;

public class Test {
    boolean flag = false;

    public static void main(String[] args) {
        Test o = new Test();
        new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (o) {
                    while (true) {
                        if (!o.flag) {
                            System.out.println(1);
                            o.flag = true;
                            o.notify(); //不光要唤醒（notify） ，自己还要wait，只有自己wait了才能把锁交出去 
                            o.wait();
                        }
                    }
                }
            }
        }).start();
        new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (o) {
                    while (true) {
                        if (o.flag) {
                            System.out.println(2);
                            o.flag = false;
                            o.notify();
                            o.wait();
                        }
                    }
                }
            }
        }).start();
    }
}
 

执行多任务且任务之间有依赖也有并行的关系时可以用join

• join() 的作用：让主线程等待子线程结束之后才能继续运行
• 代码示例中，C 依赖于A，B，而A，B又可以并行执行，可以用join实现

import lombok.SneakyThrows;

public class Join {
    public static void main(String[] args) throws InterruptedException {
            //join() 的作用：让主线程等待子线程结束之后才能继续运行
        Thread A = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    System.out.println(i);
                    Thread.sleep(1000);
                }
            }
        });

        Thread B = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                for (int i = 50; i < 100; i++) {
                    System.out.println(i);
                    Thread.sleep(1000);
                }
            }
        });
        //C相当于主线程，他要等子线程A,B完了才能继续执行
        Thread C = new Thread(new Runnable() {
            @SneakyThrows
            @Override
            public void run() {
                A.start();
                B.start();
                B.join();
                A.join();
                for (int i = 100; i < 200; i++) {
                    System.out.println(i);
                }
            }
        });
        C.start();
    }
}

countDownLatch

关于countDownLatch之于join的意义有二:

1. 很多时候我们根本没法调用A.join，比如想要join的线程在线程池中执行，这时就只能使用CountdownLatch
2. CountdownLatch可以在线程A执行了一半后就调用countDown()方法，让想要执行的线程得到执行。join就做不到这一点，因为join只能等被join的线程完全执行完毕后，再执行想要执行的线程