线程间通信实例之轮流打印ABC

A
A
A
A
A
A
A
A
A
A
//BC依次排列

public class TestSwapThread {
    public static void main(String[] args){
    //创建三把锁
        final Object obj1 = new Object();
        final Object obj2 = new Object();
        final Object obj3 = new Object();
        SwapThread swapThread = new SwapThread(obj1,obj2);
        SwapThread swapThread2 = new SwapThread(obj3,obj1);
        SwapThread swapThread3 = new SwapThread(obj2,obj3);
        swapThread.setName("A");
        swapThread.start();
        //这里来保证次序
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        swapThread2.setName("B");
        swapThread2.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread extends  Thread{
    private Object obj1 = null;
    private Object obj2 = null;
    public SwapThread(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    @Override
    public void run() {
        synchronized (obj1){
            System.out.println(Thread.currentThread().getName()+"准备进入第二层");
            synchronized (obj2){
                for (int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                }
         //nofityAll并不会释放锁，但是同步代码块执行完会自动释放锁
                obj2.notifyAll();
            }//这里释放内存锁
         //nofityAll并不会释放锁，但是同步代码块执行完会自动释放锁
            obj1.notifyAll();
            System.out.println(Thread.currentThread().getName()+" : end");
        }//这里释放外层锁
    }
}

public class TestSwapThread3 {
    public static void main(String[] args){
      //这里也可作为swapThread3 构造参数传入
        //Lock lock = new ReentrantLock();
        SwapThread3 swapThread3 = new SwapThread3();
        new Thread(swapThread3,"A").start();
        new Thread(swapThread3,"B").start();
        new Thread(swapThread3,"C").start();
    }
}
class SwapThread3 implements Runnable{
  //共享数据--同一把锁 ReentrantLock
    private Lock lock =new ReentrantLock() ;
    @Override
    public void run() {
      //加锁
        lock.lock();
        try {
            int count =0;
            while (count<10){
                System.out.println(Thread.currentThread().getName()+" : "+count );
                count++;
            }
        }finally {
          //释放锁
            lock.unlock();
        }
    }
}

A
B
C
//....

public class TestSwapThread4 {
    public static void main(String[] args){
        final Object obj1 = new Object();
        final Object obj2 = new Object();
        final Object obj3 = new Object();
        SwapThread4 swapThread = new SwapThread4(obj1,obj2);
        SwapThread4 swapThread2 = new SwapThread4(obj2,obj3);
        SwapThread4 swapThread3 = new SwapThread4(obj3,obj1);
        swapThread.setName("A");
        swapThread.start();
        swapThread2.setName("B");
        swapThread2.start();
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread4 extends  Thread{
    private Object obj1 = null;
    private Object obj2 = null;
    public SwapThread4(Object obj1,Object obj2){
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            synchronized (obj1){
                synchronized (obj2){
                    System.out.println(Thread.currentThread().getName()+" : "+i);
                    //notifyAll并不会释放锁，代码块结束后释放锁
                    obj2.notifyAll();
                }
                try {
                    //避免程序不能正常结束
                    if (i==9){
                        obj1.notifyAll();
                    }else{
                    //wait方法将会释放锁标志，进入阻塞状态，等到唤醒
                        obj1.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class TestSwapThread2 {
    public static void main(String[] args){
        Lock lock = new ReentrantLock();
        Condition conditionA = lock.newCondition();
        Condition conditionB = lock.newCondition();
        Condition conditionC = lock.newCondition();
        SwapThread2 swapThread = new SwapThread2(lock,conditionA,conditionB);
        SwapThread2 swapThread2 = new SwapThread2(lock,conditionB,conditionC);
        SwapThread2 swapThread3 = new SwapThread2(lock,conditionC,conditionA);
        swapThread.setName("A");
        swapThread.start();
        swapThread2.setName("B");
        swapThread2.start();
        swapThread3.setName("C");
        swapThread3.start();
    }
}
class SwapThread2 extends Thread{
    private Lock lock ;
    private Condition condition1;
    private Condition condition2 ;
    public SwapThread2(Lock lock,Condition condition1,Condition condition2){
        this.lock = lock;
        this.condition1=condition1;
        this.condition2=condition2;
    }
    @Override
    public void run() {
      //加锁
        lock.lock();
        try {
            int count =0;
            while (count<10){
            //唤醒等待condition2的线程
                condition2.signal();
                System.out.println(Thread.currentThread().getName()+" : "+count );
                count++;
                if (count==10){
                //避免程序不能结束
                    condition1.signalAll();
                }else{
                    try {
                      //当前线程进入阻塞，等到condition1被唤醒
                        condition1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }finally {
            lock.unlock();
        }
    }
}