三个线程交替按顺序打印ABC之条件队列的理解

如题。本文给出交替打印的代码示例,并解释了条件变量在代码实现中所起的作用。

  • 使用三个线程,一个只负责打印A,另一个只负责打印B,最后一个只负责打印C
  • 按顺序交替。即打印A后,才能打印B,打印B后,才能打印C

由于按序交替,最好采用条件队列来实现。初始时,只有打印A的条件满足 打印B、C的条件都不满足。A打印后,使得打印B的条件满足,同时打印A的条件由原来的满足变成不满足;B打印后,使得打印C的条件满足,同时打印B的条件由原来的满足变成不满足;C打印后,使得打印A的条件满足,同时打印C的条件由原来的满足变成不满足。

采用锁+条件队列实现的优势:
锁+条件队列是基于"通知-唤醒"机制实现的,比sleep+轮询的方式要高效。这篇文章最后第6点简要说明了这2种机制。

完整代码如下:

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

/**
 * @author psj
 * @date 20-3-7
 */
public class PrintABC {
    private ReentrantLock lock = new ReentrantLock();
    //与锁关联的条件队列,当打印条件不满足时,挂起线程(通知唤醒机制,而不是sleep或者轮询)
    private Condition printA = lock.newCondition();
    private Condition printB = lock.newCondition();
    private Condition printC = lock.newCondition();

    //初始化 打印A的条件成立,打印B不成立,打印C不成立
    private volatile boolean isA = true;
    private volatile boolean isB = false;
    private volatile boolean isC = false;


    public static void main(String[] args) {
        PrintABC pabc = new PrintABC();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printA();
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printB();
                    } catch (InterruptedException e) {
                        //响应中断退出打印
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t2");

        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        pabc.printC();
                    } catch (InterruptedException e) {
                        System.out.println(Thread.currentThread().getName() + " 退出打印");
                        break;
                    }
                }
            }
        }, "t3");

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


//        sleepMills(10 * 1000);
//        t1.interrupt();
    }

    public void printA() throws InterruptedException{
        try {
            lock.lock();
            while (!isA) {
                printA.await();
            }
            System.out.println(Thread.currentThread().getName() + " print A");
            sleepMills(2000);
            //A 已打印,将打印A的条件由原来的满足变成不满足
            isA = false;
            //将打印B的条件变成满足
            isB = true;
            //通知线程打印B
            printB.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printB()throws InterruptedException {
        try {
            lock.lock();
            while (!isB) {
                printB.await();
            }
            System.out.println(Thread.currentThread().getName() + " print B");
            //模拟方法执行耗时
            sleepMills(2000);
            //打印B的条件由满足变成不满足
            isB = false;
            //使得打印C的条件变成满足
            isC = true;
            printC.signal();
        }finally {
            lock.unlock();
        }
    }

    public void printC()throws InterruptedException {
        try {
            lock.lock();
            while (!isC) {
                printC.await();
            }
            System.out.println(Thread.currentThread().getName() + " print C");
            sleepMills(2000);
            //C已打印,将打印C的条件由原来的满足变成不满足
            isC = false;
            //将打印A的条件变成满足
            isA = true;
            printA.signal();
        }finally {
            lock.unlock();
        }
    }

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

再来看一个交替打印AB的示例。这里给出了2种实现思路,一种是基于 volatile变量;另一种是采用条件队列。对比了这2种实现之后,讨论了条件队列背后的原理(通知唤醒机制、线程调度、线程阻塞状态……)

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  hapjin  阅读(1005)  评论(0编辑  收藏  举报