一起Talk Android吧（第三百六十九回：多线程之按序操作）

本文链接：https://blog.csdn.net/talk_8/article/details/126084161

各位看官们，大家好，上一回中咱们说的是Android中多线程之精准唤醒的例子,这一回中咱们介绍的例子是多线程之按序操作。闲话休提，言归正转。让我们一起Talk Android吧！

概述

看官们，我们在上一章回中介绍如何使用精准唤醒技术来实现线程之间的通信，不过上一章回中的例子中不能完全展示出它的优势，因为例子中只涉及到两种操作，本章回中我们还使用上一章回中生产者和消费者的例子，不过在操作上做扩展：增加一种操作，也就是自产自销的操作。这种操作先生产商品，然后又把商品消费完。

示例程序

下面是示例程序，请大家参考：

public class ThreadLock {
    public static void main(String[] args) {
       // 使用Lock锁和Condition对线程进行精准唤醒,以实现线程间的通信
        class ProducerAndCustomer {
            //临界资源或者叫共享资源
            private int criticalResource;
            //定义锁
            private Lock threadLock;
            //定义condition
            private Condition conditionP;
            private Condition conditionC;
            private Condition conditionPC;
            //控制访问顺序的标识
            private int orderFlag;

            public ProducerAndCustomer() {
                criticalResource = 0;
                orderFlag = 1;
                threadLock = new ReentrantLock();
                conditionP = threadLock.newCondition();
                conditionC = threadLock.newCondition();
                conditionPC = threadLock.newCondition();
            }

            public void produce() {
                //操作共享资源前加锁
                threadLock.lock();
                //确认顺序标识，如果轮到自已就开始生产，否则停止生产，进入睡眠状态，等待唤醒
                while (orderFlag != 1) {
                    try {
                        System.out.println("produce criticalResource = "+criticalResource+" sleeping");
                        conditionP.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                criticalResource += 1;
                System.out.println("produce finished CriticalResource : "+criticalResource);
                //生产者生产了共享资源，唤醒消费者去消费
                orderFlag = 2;
                conditionC.signal();
                //操作共享资源后去锁
                threadLock.unlock();
            }
            public void consume() {
                //操作共享资源前加锁
                threadLock.lock();
                //确认顺序标识，如果轮到自已就开始消费，否则停止消费，进入睡眠状态，等待唤醒
                while (orderFlag != 2) {
                    try {
                        System.out.println("consume CriticalResource = "+criticalResource+" sleeping");
                        conditionC.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //消息者消费完共享资源，唤醒生产者生产资源
                criticalResource -= 1;
                System.out.println("consume finished CriticalResource : "+criticalResource);
                orderFlag = 3;
                conditionPC.signal();
                //操作共享资源后去锁
                threadLock.unlock();
            }

            public void internalProduceConsume() {
                //操作共享资源前加锁
                threadLock.lock();
                //如果有共享资源，生产者停止生产，进行睡眠状态，等待消费者唤醒
                //确认顺序标识，如果轮到自已就开始生产和消费，否则进入睡眠状态，等待唤醒
                while (orderFlag != 3) {
                    try {
                        System.out.println("internalProduceConsume produce criticalResource = "+criticalResource+" sleeping");
                        conditionPC.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                criticalResource += 1;
                System.out.println("internalProduceConsume produce finished CriticalResource : "+criticalResource);
                criticalResource -= 1;
                System.out.println("internalProduceConsume consume finished CriticalResource : "+criticalResource);

                orderFlag = 1;
                conditionP.signal();
                //操作共享资源后去锁
                threadLock.unlock();
            }
        }

        ProducerAndCustomer obj = new ProducerAndCustomer();

        new Thread(()->{
            for (int i=0; i<3; i++) {
                obj.produce();
            }},"Produce: ").start();

        new Thread(()->{
            for (int i=0; i<3; i++) {
                obj.consume();
            }},"Consume: ").start();

        new Thread(()->{
            for (int i=0; i<3; i++) {
                obj.internalProduceConsume();
            }},"P&C: ").start();
    }

}

上面的代码中增加了自产自销的操作，以及与它配套的condition，同时还增加了一个线程来完成自产自销操作。需要注意的是代码中多了控制操作执行顺序的变量，它和精准唤醒一起来控制各个操作的执行顺序，代码中它的值为1时执行生产操作，为2时执行消费操作，为3时执行自产自销操作。三种操作的执行顺序按照自然数：1、2、3依次执行。整个示例代码可以看作是三个线程按顺序执行三种操作。

编译并且运行上面的程序可以得到以下结果：

produce finished CriticalResource : 1
produce criticalResource = 1 sleeping
internalProduceConsume produce criticalResource = 1 sleeping
consume finished CriticalResource : 0
consume CriticalResource = 0 sleeping
internalProduceConsume produce finished CriticalResource : 1
internalProduceConsume consume finished CriticalResource : 0
internalProduceConsume produce criticalResource = 0 sleeping
produce finished CriticalResource : 1
produce criticalResource = 1 sleeping
consume finished CriticalResource : 0
consume CriticalResource = 0 sleeping
internalProduceConsume produce finished CriticalResource : 1
internalProduceConsume consume finished CriticalResource : 0
internalProduceConsume produce criticalResource = 0 sleeping
produce finished CriticalResource : 1
consume finished CriticalResource : 0
internalProduceConsume produce finished CriticalResource : 1
internalProduceConsume consume finished CriticalResource : 0