线程间通信的5种方式

题目：要求三个线程A、B、C按照顺序的输出A、B、C。

1. volatile关键字（保证内存可见性）
基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。

package com.kuang.xianchengjiantongxin;

import java.util.concurrent.TimeUnit;

public class volatileTest {
    static volatile int notice = 1;

    public static void main(String[] args) {
        new Thread(() -> {
            while (notice != 1) {

            }
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("A");
            notice = 2;
        }, "A").start();
        new Thread(() -> {
            while (notice != 2) {

            }
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B");
            notice = 3;
        }, "B").start();
        new Thread(() -> {
            while (notice != 3) {

            }
            System.out.println("C");
            notice = 1;
        }, "C").start();
    }
}

2. 使用 ReentrantLock 结合 Condition

package com.kuang.xianchengjiantongxin;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class conditionTest2 {

    // 为了能让线程内部能访问到num，将num设置为static
    static int num = 1;

    public static void main(String[] args) {

        Lock lock = new ReentrantLock();
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
        Condition condition3 = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try {
                TimeUnit.SECONDS.sleep(2);
                while (num != 1) {
                    condition1.await();
                }
                System.out.println("A");
                num = 2;
                condition2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "A").start();

        new Thread(() -> {
            lock.lock();
            try {
                TimeUnit.SECONDS.sleep(1);
                while (num != 2) {
                    condition2.await();
                }
                System.out.println("B");
                num = 3;
                condition3.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "B").start();

        new Thread(() -> {
            lock.lock();
            try {
                while (num != 3) {
                    condition3.await();
                }
                System.out.println("C");
                num = 1;
                condition1.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "C").start();
    }
}

3. LockSupport实现线程间的阻塞和唤醒
LockSupport 是一种非常灵活的实现线程间阻塞和唤醒的工具，使用它不用关注是等待线程先进行还是唤醒线程先运行，但是得知道线程的名字。

public static void park(Object blocker); // 暂停当前线程
public static void parkNanos(Object blocker, long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(Object blocker, long deadline); // 暂停当前线程，直到某个时间
public static void park(); // 无期限暂停当前线程
public static void parkNanos(long nanos); // 暂停当前线程，不过有超时时间的限制
public static void parkUntil(long deadline); // 暂停当前线程，直到某个时间
public static void unpark(Thread thread); // 恢复当前线程
public static Object getBlocker(Thread t);

park，停车，让当前线程停下来。
unpark，不停车，让当前线程跑起来。

package com.kuang.xianchengjiantongxin;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * @author liushihao <liushihao@kuaishou.com>
 * Created on 2021/3/10 11:11 上午
 */
public class LockSupportTest {

    public static void main(String[] args) throws InterruptedException {
        Thread threadC = new Thread(() -> {
            LockSupport.park();
            System.out.println("C");
        });
        Thread threadB = new Thread(() -> {
            LockSupport.park();
            System.out.println("B");
            LockSupport.unpark(threadC);
        });
        Thread threadA = new Thread(() -> {
            System.out.println("A");
            LockSupport.unpark(threadB);
        });

        threadC.start();
        TimeUnit.SECONDS.sleep(2);
        threadB.start();
        TimeUnit.SECONDS.sleep(1);
        threadA.start();
    }
}

4. Object.wait()、Object.notify()、Object.notifyAll方法，但是notify方法只能随机唤醒一个线程，并不能实现精确唤醒。
5. CountDownLatch（减法计数器）同样不能实现精确唤醒。