java多线程（线程按交替执行）

题目描述🧡：

题目：有a、b、c三个线程，使得它们按照abc依次执行10次

解题思路🧡：

控制执行线程变量flag，利用lock锁来保证线程安全，使用comdition来堵塞线程和通信

condition：

condition接口描述了可能与锁有关的条件变量。这些用法上与使用object.wait访问隐式监视器类似，但提供了更强大的功能，需要特别指出的是，单个lock能与多个Condition对象关联，为了避免兼容性问题，Condition方法的名称与对应的object版本的不同。

在condition对象中：

await方法 //等待，这时锁会释放

signa|A||方法//通知，线程等待结束，往下执行

Condition实例实质上被绑定到一个锁上，要为特定Lock实例获得Condition实例，请使用newCondition()方法；

创建一个类：AbcAlternateDemo1

创建一个内部类：Alternate

内部类定义一个属性：线程启动的顺序标识flag

写三个方法

loopA():先上锁，判断flag是不是1，不是则等待conditionA.await();如果是输出，flag是2，通知线程往下执行conditionA.signalAll();

loopB():先上锁，判断flag是不是2，不是则等待conditionA.await()；如果是则输出，flag是3，通知线程往下执行conditionA.signalAll();

looPc():先上锁，判断flag是不是3，不是则等待conditionA.await();flag是1，通知线程往下执行conditionA.signalAll()。

三代码详解🧡：

AbcAlternateDemo1

package cn.xiaoxuzhu.daily;
 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class AbcAlternateDemo1 {
    public static void main(String[] args) {
        Alternate alternate=new Alternate();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    alternate.loopA(i);
                }
            }
 
 
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    alternate.loopB(i);
                }
            }
        },"B").start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    alternate.loopC(i);
                }
            }
        },"C").start();
 
    }
    static  class  Alternate{
        /**
         * 线程启动的顺序标志
         */
        private  int flag=1;
        private Lock lock=new ReentrantLock();
        private Condition conditionA=lock.newCondition();
        private Condition conditionB=lock.newCondition();
        private Condition conditionC=lock.newCondition();
 
        public void loopA(int loopNum){
            lock.lock();
            try{
                if(flag!=1){
                    conditionA.await();
                }
                for(int i=1;i<=1;i++){
                    System.out.println(Thread.currentThread().getName()+":"+"--"+loopNum+"--"+i);
 
                }
                flag=2;
                conditionB.signalAll();
 
            }catch (Exception e){
                e.printStackTrace();
 
            }finally {
                lock.unlock();
            }
        }
        public  void  loopB(int loopNum){
            lock.lock();
            try {
                if(flag!=2){
                    conditionB.await();
                }
                for(int i=1;i<=1;i++){
                    System.out.println(Thread.currentThread().getName()+":"+"--"+loopNum+"--"+i);
 
                }
                flag=3;
                System.out.println("---------------------------------");
                conditionA.signalAll();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
 
        public  void  loopC(int loopNum){
            lock.lock();
            try {
                if(flag!=3){
                    conditionC.await();
                }
                for(int i=1;i<=1;i++){
                    System.out.println(Thread.currentThread().getName()+":"+"--"+loopNum+"--"+i);
 
                }
                flag=1;
                System.out.println("---------------------------------");
                conditionA.signalAll();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
 
 
    }
}