多线程交替打印ABC

题目描述

建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

基本思路

并发编程核心是三大块：分工、互斥和同步。(出自极客时间APP中，王宝令的《Java并发编程实战》)

• 互斥

  • 这道题并不涉及共享变量，所以不需要考虑互斥，首先排除。

• 同步

  • 一眼就能看出这道题考的就是同步，那怎么同步呢？很容易想到的方法，就是每个线程打印前，等待别的线程通知；打印后，再去通知别的线程。
  • 等待与唤醒，无非就是Object的wait、notify、notifyAll，以及Java并发包中Condition的await、signal、signalAll。Object的wait和notify只能作用于同一个锁对象，不能满足我们的需求。所以就需要使用后者。

• 分工：就是考虑每个线程要做什么事情，需要哪些成员变量

  • 等待与唤醒
    • 需要一个Lock变量
    • 需要两个Condition变量，一个condition用来等待上个线程通知，一个condition用来通知下个线程。
  • 打印字母
    • 需要一个本地变量，存储这个线程要打印的字母。

具体代码

1.可重入锁以及try-with-resource

想玩一玩try-with-resource，但是发现无论是Lock还是ReentrantLock都没有实现AutoCloseable接口。网上查了一下，发现可以自己封装一下。

package concurrent;

import java.util.concurrent.locks.ReentrantLock;

public class CloseableReentrantLock extends ReentrantLock implements AutoCloseable {
    public CloseableReentrantLock open() {
        this.lock();
        return this;
    }

    @Override
    public void close() {
        try {
            this.unlock();
        } catch (Exception e) {
            System.out.println(e.toString());
        }
    }
}

2. 工作线程代码

package concurrent;

import java.util.concurrent.locks.Condition;

public class ConditionSyncPrinter implements Runnable{
    private static final int PRINT_COUNT = 10;
    private final CloseableReentrantLock lock;
    private final Condition thisCondition;
    private final Condition nextCondition;
    private final char printChar;

    public ConditionSyncPrinter(CloseableReentrantLock lock, Condition thisCondition, Condition nextCondition, char printChar) {
        this.lock = lock;
        this.thisCondition = thisCondition;
        this.nextCondition = nextCondition;
        this.printChar = printChar;
    }

    @Override
    public void run() {
        try(CloseableReentrantLock closeableLock = lock.open()) {
            for (int i = 0; i < PRINT_COUNT; i++) {
                try {
                    thisCondition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.print(printChar);
                nextCondition.signalAll();
            }
        }
    }
}

3. 主方法

先出一版跑跑看

package concurrent;

import java.util.concurrent.locks.Condition;

public class Main {
    public static void main(String[] args) {
        CloseableReentrantLock lock = new CloseableReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Condition conditionC = lock.newCondition();
        Thread printerA = new Thread(new ConditionSyncPrinter(lock, conditionA, conditionB, 'A'));
        Thread printerB = new Thread(new ConditionSyncPrinter(lock, conditionB, conditionC, 'B'));
        Thread printerC = new Thread(new ConditionSyncPrinter(lock, conditionC, conditionA, 'C'));
        Thread signaler = new Thread(new Signaler(lock, conditionA));
        printerA.start();
        printerB.start();
        printerC.start();
        //这里会有问题
        try(CloseableReentrantLock closeableLock = lock.open()) {
            conditionA.signalAll();
        }

动手一跑就会发现，卡住了。

为什么会卡住，答案当然很简单，肯定是我们最后1行的signalAll没有通知成功，导致printerA永远等待在await方法上。

那为什么signalAll方法会没通知成功呢？不是说好的happen-before规则吗？答案当然也很简单，我们在主线程中signalAll的时候，printerA线程还没准备好。

解决方法有两个：

1. 我们新写一个唤醒线程，专门执行conditionA.signalAll();来唤醒printerA，而不在主进程中搞唤醒。这是最推荐的做法。
2. 如果一定要在主线程中唤醒呢？那等待printerA准备好了就行了。怎么等呢？用Thread.sleep(100);，注意这里时间要留足，如果只睡1毫秒，仍然是没什么卵用的。

这两个解法就留给读者自己写着玩吧~