多线程间通讯问题的几种实现方式

概括

多线程通信问题是一个老生常谈的知识点，今天有空通过一个编程题把所有的实现方式整理一遍。
实现方式有：
1、通过全局变量实现（有多种实现方式）
2、通过wait，notify，notifyAll实现
3、通过lock，condition实现
4、通过LockSupport实现

题目

已知两个字符串"123456789"和"ABCDEFGGH"，请用两个线程交替打出字符串每个字符，要求数字首先出现。
这是一道典型的多线程通信的编程题，下面给出多种方式的实现。

实现

1、通过全局变量实现（有多种实现方式）###

/***
 * 使用枚举全局变量实现，实现方式类似与自旋锁原理
 * 不满足条件的时候就一直空转。
 * 通过r公共变量控制两个线程交替执行
 */
public class T01_CAS {
    // 定义两个枚举
    enum ReadyToRun{T1,T2};
    // 定义r变量，控制线程执行
    static volatile ReadyToRun r = ReadyToRun.T1;

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGGH".toCharArray();
        new Thread(() ->{
            for (char c : aI) {
                // r变量不是T1就空转，直到T1才执行
                while (r != ReadyToRun.T1){}
                System.out.print(c);
                r = ReadyToRun.T2;
            }
        },"t1").start();

        new Thread(()->{
            for (char c : aC) {
                while (r != ReadyToRun.T2){}
                    System.out.print(c);
                r = ReadyToRun.T1;
            }
        },"t2").start();
    }
}

执行结果：

1A2B3C4D5E6F7G8G9H
Process finished with exit code 0

也可以通过AtomicInteger等原子类来实现：

public class T01_AtomicInteger {
    // 控制两个线程执行顺序
    static AtomicInteger threadNo = new AtomicInteger(1);

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGGH".toCharArray();
        new Thread(() ->{
            for (char c : aI) {
                while (threadNo.get() != 1){}
                System.out.print(c);
                threadNo.set(2);
            }
        },"t1").start();

        new Thread(()->{
            for (char c : aC) {
                while (threadNo.get() != 2){}
                    System.out.print(c);
                threadNo.set(1);
            }
        },"t2").start();
    }
}

执行结果：

1A2B3C4D5E6F7G8G9H
Process finished with exit code 0

2、通过wait，notify，notifyAll实现

public class T01_Sync_wait_notify {
    // 全局变量，控制让T1先执行，先出数字
    static boolean t1IsStart = false;
    public static void main(String[] args) {
        final Object lockObject = new Object(); // 锁对象
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGGH".toCharArray();

        new Thread(() ->{
            synchronized (lockObject) {
                for (char c : aI) {
                    if(!t1IsStart){ //T1执行时发现标记为未启动，修改标记位
                        t1IsStart = true;
                    }
                    System.out.print(c);
                    try {
                        lockObject.notify();
                        lockObject.wait(); // 让出锁
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                lockObject.notify();
            }
        },"t1").start();

        new Thread(()->{
            synchronized (lockObject) {
                for (char c : aC) {
                    if(!t1IsStart){// 若T2先抢到锁，发现T1未执行，则主动让出锁让T1先执行
                        try {
                            lockObject.wait(); // 让出锁
                        }catch (Exception ex){
                            ex.printStackTrace();
                        }
                    }
                    System.out.print(c);
                    try {
                        lockObject.notify();
                        lockObject.wait(); // 让出锁
                    }catch (Exception ex){
                        ex.printStackTrace();
                    }
                }
                lockObject.notify();
            }
        },"t2").start();        
    }
}

执行结果：

1A2B3C4D5E6F7G8G9H
Process finished with exit code 0

3、通过lock，condition实现

public class T01_Lock_Condition {

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGGH".toCharArray();

        Lock lock = new ReentrantLock();
        Condition condition1 = lock.newCondition(); // 控制线程1
        Condition condition2 = lock.newCondition(); // 控制线程2

        new Thread(() ->{
            try{
                lock.lock();
                for (char c : aI) {
                    System.out.print(c);
                    condition2.signal();// 唤醒线程2
                    condition1.await();// 线程1等待
                }
                condition2.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t1").start();

        new Thread(()->{
            try{
                lock.lock();
                for (char c : aC) {
                    System.out.print(c);
                    condition1.signal();
                    condition2.await();
                }
                condition1.signal();
            }catch (Exception ex){
                ex.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }
}

执行结果：

1A2B3C4D5E6F7G8G9H
Process finished with exit code 0

4、通过LockSupport实现

public class T01_LockSupport {
    static Thread t1 = null, t2 = null;

    public static void main(String[] args) {
        char[] aI = "123456789".toCharArray();
        char[] aC = "ABCDEFGGH".toCharArray();
        t1 = new Thread(() ->{
            for (char c : aI) {
                System.out.print(c);
                LockSupport.unpark(t2);// 让t2线程获得执行许可
                LockSupport.park();// 当前线程阻塞
            }
        },"t1");

        t2 = new Thread(()->{
            for (char c : aC) {
                LockSupport.park();// 若T2先执行则当前线程阻塞
                System.out.print(c);
                LockSupport.unpark(t1);// 让t1线程获得执行许可
            }
        },"t2");

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

执行结果：

```java
1A2B3C4D5E6F7G8G9H
Process finished with exit code 0

总结

下面实现方式：
3、通过lock，condition实现
4、通过LockSupport实现
是比较优雅的实现方式.