java中使用ReentrantLock锁中的Condition实现三个线程之间通信，交替输出信息

本文直接附上源代码，如下是自己写的一个例子

面试题
需求: 使用Condition来实现
三个线程
线程1
线程2
线程3
三个交替输出
【按照 线程1(main)-->线程2-->线程3】
如此往复50次 请写出程序

public class ThreeConditionCommunication
{
    /**
     * 用于标记那个线程进行执行 
     * 1:主线程
     * 2:线程2
     * 3:线程3
     */
    private static int HASOUT = 1;
    public static void main(String[] args) throws InterruptedException
    {
        final Core core = new Core();
        //子线程2
        new Thread(
                new Runnable()
                {
                    @Override
                    public void run()
                    {
                        for (int i = 1; i <= 50; i++)
                        {
                            core.SubMethod2(i);
                        }    
                    }
                }
        ).start();
        
        //子线程3
        new Thread(
                new Runnable()
                {
                    @Override
                    public void run()
                    {
                        for (int i = 1; i <= 50; i++)
                        {
                            core.SubMethod3(i);
                        }    
                    }
                }
        ).start();
        
        //主线程
        for (int i = 1; i <= 50; i++)
        {
            core.MainMethod(i);
        }
    }
    
    /**
     * 创建一个静态的类
     * 将核心的业务逻辑的方法放在这里
     * 体现了高内聚的特点
     * @author huang.jf
     */
    static class Core{
        //创建一个Lock锁对象
        public Lock lock = new ReentrantLock();
        //创建三个Condition对象 分别用于控制三个线程
        public Condition condition1 = lock.newCondition();
        public Condition condition2 = lock.newCondition();
        public Condition condition3 = lock.newCondition();
        //线程2   循环输出10次
        public void SubMethod2(int j){
            lock.lock();//开启Lock锁
            try{
                //true 执行
                //false 等待
                while(HASOUT!=2){
                    try
                    {
                        condition2.await();//线程2等待
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                //线程2执行
                for (int i = 1; i <= 10; i++)
                {
                    System.out.println("this is sub2 thread..."+i+"......."+j);
                }
                    HASOUT = 3;
                    condition3.signal();//唤醒线程3
            }finally{
                lock.unlock();//释放锁
            }
        }
        
        //线程3   循环输出20次
        public void SubMethod3(int j){
            lock.lock();//开启Lock锁
            try{
                //true 执行
                //false 等待
                while(HASOUT!=3){
                    try
                    {
                        condition3.await();//线程3等待
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                //线程3执行
                for (int i = 1; i <= 20; i++)
                {
                    System.out.println("this is sub3 thread..."+i+"......."+j);
                }
                    HASOUT = 1;
                    condition1.signal();//唤醒线程1(主线程)
            }finally{
                lock.unlock();//释放锁
            }
        }
        
        
        //主线程调用循环输出一百次
        public void MainMethod(int j){
            lock.lock();
            try{
                //false 执行
                //true 等待
                while(HASOUT!=1){
                    try
                    {
                        condition1.await();//主线程等待
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                //执行主线程
                for (int i = 1; i <= 100; i++)
                {
                    System.out.println("this is main thread..."+i+"......"+j);
                }
                    HASOUT = 2;
                    condition2.signal();//唤醒线程2
            }finally{
                lock.unlock();
            }
        }
    }
}

输出结果可以自己尝试输出，指定到一个输出文件中，便于查看。