交替打印AB

交替打印AB。

import java.util.concurrent.TimeUnit;

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintAB {

    private volatile boolean isA = true;

    public static void main(String[] args) {
        PrintAB pab = new PrintAB();

        Thread t1 = new Thread(() -> {
            while (true) {
                pab.printA();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
                pab.printB();
            }
        }, "t2");

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

    public void printA() {
        if (isA) {
            System.out.println(Thread.currentThread().getName() + " print A");
            //模拟方法执行耗时
            sleepMills(1000);
            isA = false;
        }
    }

    public void printB() {
        if (!isA) {
            System.out.println(Thread.currentThread().getName() + " print B");
            sleepMills(2000);
            isA = true;
        }
    }

    private static void sleepMills(long mills) {
        try {
            TimeUnit.MILLISECONDS.sleep(mills);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

使用一个volatile变量协调2个线程交替打印A、B的顺序。此种方式是很消耗CPU的，因为：2个线程是在while true循环中不停地测试打印条件是否成立。另一种优雅的方式则是采用通知唤醒机制：当条件不成立时，让线程放弃cpu，挂起线程，进入阻塞状态(WAITING)，当条件成立后，再唤醒线程，让它再次去争抢cpu，执行打印。这可以通过条件队列来实现，代码如下：

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

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintABCondition {
    private Lock lock = new ReentrantLock();
    private Condition pac = lock.newCondition();
    private Condition pbc = lock.newCondition();

    //决定打印A or 打印B 条件是否满足
    private volatile boolean printA = true;

    public void printA() throws InterruptedException{
        try {
            lock.lock();
            while (!printA) {
                //打印A的条件未满足,挂起线程,放弃cpu,进入WAITING状态
                pac.await();
            }
            //打印A的条件满足了,打印A
            System.out.println(Thread.currentThread().getName() + " print A");
            //模拟方法执行耗时
            sleepMills(1500);
            //A 已经打印完毕, 使得打印B的条件满足, 接下来发送通知 唤醒打印B的线程
            printA = false;
            pbc.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printB() throws InterruptedException{
        try {
            lock.lock();
            while (printA) {
                //打印B的条件未满足,挂起线程,放弃cpu,进入WAITING状态
                pbc.await();
            }
            System.out.println(Thread.currentThread().getName() + " print B");
            sleepMills(2000);
            //B 已打印完毕,使得打印A的条件满足,接下来发送通知 唤醒打印A的线程
            printA = true;
            pac.signal();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        PrintABCondition pab = new PrintABCondition();

        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    pab.printA();
                } catch (InterruptedException e) {
                    //响应中断
                    break;
                }
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    pab.printB();
                } catch (InterruptedException e) {
                    break;
                }
            }
        }, "t2");

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

    private static void sleepMills(long mills) {
        try {
            TimeUnit.MILLISECONDS.sleep(mills);
        } catch (InterruptedException e) {
            System.out.println(e);
        }
    }
}

看juc并发包Condition.java的await方法里面有一段注释：

In all cases, before this method can return the current thread must re-acquire the lock associated with this condition。When the thread returns it is guaranteed to hold this lock.

这里从打印A的线程角度来解释一下：打印A的线程在从 await()方法返回时，必须重新争抢锁，争抢到锁之后，就会再执行while循环测试条件是否满足，如果此时条件满足(printA变为true)了，那就往下执行。如果条件不满足(printA为false)，那么就放弃cpu,进入WAITING状态，等待唤醒。
从线程调度的角度来说，当执行Thread#start()后，线程从NEW状态变成RUNNABLE状态，此时线程具有运行的资格--可以被线程调度器选中占用cpu执行，但并不是说该线程一定占有cpu在运行了。由于"最小时间片"原则，每个线程一般都会占用cpu运行一小段时间，然后由于"抢占式调度"，就被调度器切换出去了，线程不再占有cpu了(这种情形下的切换是多线程并发执行所固有的性质)，与 "多个线程争抢同一把锁，未获得锁的线程被阻塞挂起，从而不再占有cpu了" 是不同的，要注意区分。

这里说一下为什么要在while循环里面测试条件，当条件不满足时，调用await方法使得线程放弃cpu，进入WAITING状态。为什么用while，if语句不可以吗？
我觉得用while循环的原因是：其它线程可能“无意”间调用了singal()使得该线程被唤醒了（又或者是线程因为某种未知原因唤醒了），线程醒来之后需要重新测试条件是否满足，所以只能用while循环。
实际上，await()底层是调用LockSupport#park(java.lang.Object)来挂起线程的，那看看该方法的注释，想起一个问题：当一个线程被阻塞挂起时，有哪些方法可以让它恢复执行？在开始讨论之前，再次明确一下：所谓恢复执行，只是使得线程"醒过来"具有执行的资格，并不一定保证线程就拿到了cpu，正在运行了，记住：抢占式调度，是由线程调度器来决定将哪个cpu分配给线程运行的。
OK，我觉得主要有两种方式唤醒线程，恢复执行。一种是"中断"，即线程通过响应 InterruptedException 异常，退出阻塞状态；另一种是其它线程发送"通知"，比如调用signal/signalAll方法(底层是调用LockSupport#unpark)，使得线程退出阻塞状态。
但是，看LockSupport#park方法的注释，还提到了一种情况：

The call spuriously (that is, for no reason) returns.

这句话也验证了，为什么只能用while循环(不能用if语句)来测试条件是否满足(比如打印AB示例代码中的 printA 条件变量)的一个原因，因为线程可能不知道什么原因被唤醒了，只有while循环才能保证线程醒来之后会重新测试条件是否满足。

额外补充一下，这里为什么是线程阻塞后，是WAITING状态，而不是BLOCKED状态呢？哈哈。看 Thread.java 类的关于线程状态描述的源码注释（hint:等待条件满足）就知道了。

使用条件队列的好处：

  • 通知唤醒机制，代码高效
  • 能清楚看到线程在哪个条件上阻塞，并发逻辑清晰

参考资料：

posted @ 2020-03-08 10:44  大熊猫同学  阅读(1814)  评论(0)  编辑  收藏  举报