JAVA(9)-多线程-synchronized-Condition

线程关心的就是线程通信和线程同步的问题。
例：一个线程打印 “ABCDEFG”,一个线程打印“1234567”，我想其交替输出，如何做。
1.synchronized
上代码:

//线程间通信  synchronized锁定的是某个对象o 作用域
//1.创建synchronized
//2.o.notify();// 叫醒 等待队列中的任意一个
//3.o.wait(); //  当前队列让出锁，进入等待队列
public class sync_wait_notify {
    private static volatile boolean t2started=false;
    public static void main(String[] args) {
        final Object o= new Object();
        char[] aI = "1234567".toCharArray();
        char[] aC = "abcdefg" .toCharArray();

        new Thread(() -> {
            synchronized (o)
            {
                while(!t2started)
                {
                    try{
                        o.wait();
                    }
                    catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }

                for(char c:aI)
                {
                    System.out.println(c);
                    try
                    {
                        o.notify();//等待队列 叫醒 run 任意一个 叫醒别人
                        o.wait();  //当前线程让出锁 进入等待队列
                    }catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                o.notify();//总会有一个线程是wait状态，必须释放队列中的所有线程
            }
        }, "t1").start();

        new Thread(() -> {
            synchronized (o)
            {
                for(char c:aC)
                {
                    System.out.println(c);
                    t2started=true;
                    try
                    {
                        o.notify();
                        o.wait();
                    }catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }

        }, "t2").start();
    }
}

缺点是：o.notify();是唤醒等待队列中的所有线程。无法指定下面运行哪个线程或者哪类线程。
 用Condition可以指定调用哪类。

2.Condition
 

public class LockCondition {
    public static void main(String[] args) {
        char[] aI = "1234567".toCharArray();
        char[] aC = "abcdef6".toCharArray();
        Lock lock=new ReentrantLock();
        Condition conditionT1= lock.newCondition();
        Condition conditionT2=lock.newCondition();


        new Thread(() -> {
           try{
               lock.lock();
               for(char c:aI)
                {
                    System.out.println(c);
                    conditionT2.signal();//叫醒等待队列的其它线程
                    conditionT1.await();// 本线程等待
                }
               conditionT2.signal();

        } catch (InterruptedException e) {
               e.printStackTrace();
           }finally
           {
               lock.unlock();
           }
           }, "t1").start();

          new Thread(() -> {
            try{
                lock.lock();
                for(char c:aC)
                {
                    System.out.println(c);
                    conditionT1.signal();//
                    conditionT2.await();//
                }
                conditionT2.signal();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally
            {
                lock.unlock();
            }
        }, "t2").start();   }

}