多线程之间如何实现通信？保证多线程线程安全进行

参考笔记：https://blog.csdn.net/qq_21556263/article/details/82759138

多线程通信问题

常用四种方式：

- 休眠唤醒方式：
	- Object的 wait、notify、notifyAll
	- Condition的await、signal、signalAll
- CountDownLatch：用于某个线程A等待若干个其他线程执行完之后，它才执行
- CyclicBarrier：一组线程等待至某个状态之后再全部同时执行
- Semaphore：用于控制对某组资源的访问权限

案例：

1. 休眠唤醒方式

​ Object的wait、notify、notifyAll

/**
 * 描述：<br> 线程间通信方式一 --- {@link Object}
 *      情况：两个线程打印数字
 *			一个线程打印奇数、另一个打印偶数
 * </>
 * @author 周志通
 * @date 2020/7/19 23:08
 **/
public class WaitNotifyRunnable{
    private Object obj = new Object();
    private Integer i=0;
    public void odd() {
        while(i<10){
            synchronized (obj){
                if(i%2 == 1){
                    System.out.println("奇数："+i);
                    i++;
                    obj.notify();
                } else {
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public void even(){
        while(i<10){
            synchronized (obj){
                if(i%2 == 0){
                    System.out.println("偶数："+i);
                    i++;
                    obj.notify();
                } else {
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    public static void main(String[] args){
        final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "偶数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "奇数线程");

        t1.start();
        t2.start();
    }
}

Condition的await、signal、signalAll

/**
 * 描述：<br> 线程间通信方式一 --- {@link Condition}
 *      情况：两个线程打印数字
 *			一个线程打印奇数、另一个打印偶数
 * </>
 * @author 周志通
 * @date 2020/7/19 23:14
 **/
public class WaitNotifyRunnable{
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Integer i=0;
    public void odd() {
        while(i<10){
            lock.lock();
            try{
                if(i%2 == 1){
                    System.out.println("奇数："+i);
                    i++;
                    condition.signal();
                } else {
                    condition.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }

    public void even(){
        while(i<10){
            lock.lock();
            try{
                if(i%2 == 0){
                    System.out.println("偶数："+i);
                    i++;
                    condition.signal();
                } else {
                    condition.await();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }
    public static void main(String[] args){
        final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "偶数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "奇数线程");

        t1.start();
        t2.start();
    }
}

总结：

1. Object和Condition休眠唤醒区别

- object wait()必须在synchronized（同步锁）下使用， 
- object wait()必须要通过Nodify()方法进行唤醒 
- condition await() 必须和Lock（互斥锁/共享锁）配合使用
- condition await() 必须通过 signal() 方法进行唤醒

2. CountDownLatch方式

介绍：

• CountDownLatch是在java1.5被引入的，存在于java.util.concurrent包下。

• CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。

• CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。

案例：

import java.util.concurrent.CountDownLatch;
/**
 * 描述：<br> 线程间通信方式二 --- {@link CountDownLatch}
 *      情况：三个运动员 + 一个教练
 *              只有三个运动员准备就绪，教练才开始让运动员 同时跑步
 * </>
 * @author 周志通
 * @date 2020/7/19 23:21
 **/
public class CountDownThreadDemo01 {

    private CountDownLatch countDownLatch = new CountDownLatch(3) ; // 设置三个远动员

    // 运动员
    public void athlete(){
        System.out.println(Thread.currentThread().getName()+" ---> ~~~1. 开始准备~~~~") ;
        try {
            Thread.sleep(1000) ;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" ---> ~~~2. 准备就绪~~~~") ;
        // 准备
        countDownLatch.countDown() ;
    }

    public void coach(){
        System.out.println(Thread.currentThread().getName()+" ---> ~~~运动员准备~~~~") ;
        // 等待 3个运动员 准备就绪
        try {
            countDownLatch.await() ;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" ---> ~~~所有运动员开始训练~~~~") ;
    }

    public static void main(String[] args) {
        final CountDownThreadDemo01 count = new CountDownThreadDemo01() ;
        Thread t1 = new Thread(count::athlete,"运动员1") ;
        Thread t2 = new Thread(count::athlete,"运动员2") ;
        Thread t3 = new Thread(count::athlete,"运动员3") ;
        Thread t4 = new Thread(count::coach,"教练") ;

        t4.start() ;
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
}

总结：

- 每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

3. CyclicBarrier方式

介绍：

- CyclicBarrier是在java1.5被引入的，存在于java.util.concurrent包下。
- CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。
- CyclicBarrier底层是基于RentranLock和Condition实现。

案例：

/**
 * 描述：<br>  线程通信方式三 --- {@link CyclicBarrier} 方式
 *            场景：三个运动员【三个线程】开始训练
 *            要求：等带三个运动员同时准备就绪时，开始训练
 * </>
 * @author 周志通
 * @date 2020/7/20 8:26
 **/
public class CyclicBarrierDemo01 {
    private CyclicBarrier cyclicBarrier = new CyclicBarrier(3) ; // 设置运动员的数量
    public void startThread(){
        String name = Thread.currentThread().getName() ;
        System.out.println(name + " --> 开始准备~~~" ) ;
        try {
            Thread.sleep(2*1000) ;
            cyclicBarrier.await() ;
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(name + " --> 准备完成~~~开始训练" ) ;
    }
    public static void main(String[] args) {
        CyclicBarrierDemo01 cb = new CyclicBarrierDemo01() ;
        Thread t1 = new Thread(cb::startThread,"运动员1") ;
        Thread t2 = new Thread(cb::startThread,"运动员2") ;
        Thread t3 = new Thread(cb::startThread,"运动员3") ;
        t1.start();
        t2.start();
        t3.start();
    }
}

4. Semaphore方式

介绍：

- Semaphore是在java1.5被引入的，存在于java.util.concurrent包下。
- Semaphore用于控制对某组资源的访问权限。

案例：工人使用机器工作

/**
 * 描述：<br>线程间通信方式四 --- {@link Semaphore}
 *          场景：三台机器、多个工人使用机器
 *          要求：一台机器不能同时被多个工人一起使用</>
 * @author 周志通
 * @version 1.0.0
 * @date 2020/7/20 9:15
 **/
public class SemaphoreDemo {

    static class Machine implements Runnable{
        private int num;
        private Semaphore semaphore;

        public Machine(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }
        public void run() {
            try {
                semaphore.acquire();//请求机器
                System.out.println("工人"+this.num+"请求机器，正在使用机器");
                Thread.sleep(1000);
                System.out.println("工人"+this.num+"使用完毕，已经释放机器");
                semaphore.release();//释放机器
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        int worker = 8;//工人数
        Semaphore semaphore = new Semaphore(3);//机器数
        for (int i=0; i< worker; i++){
            new Thread(new Machine(i, semaphore)).start();
        }
    }
}