java 多线程（十一）

Condition的功能类似传统线程技术中的Object.wait和Object.notify的功能

package com.thread.threadTest;


import sun.awt.SunHints;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 两个线程之间的互斥和相互通信
 * 在等待Condition时,允许发生"虚假唤醒",这通常作为对基础平台语义的让步.对于大多数
 * 应用程序,这带来的实际影响很小,因为Condition应该总是在一个循环中被等待,并测试正被等待的状态声明,
 * 某个实现可以随意移除可能的虚假唤醒，但建议总是假定这些虚假唤醒可能发生,因此总在一个循环中等待.
 *
 * 一个锁内部可以有多个Condition,即有多路等待和通知,可以参考jdk中提供Lock和Condition实现的
 * 可阻赛队列的案例(BoundedBuffer)，在传统的线程机制中国呢一个监视器对象只能有一路等待和通知,
 * 要想实现多路等待和通知,必须嵌套使用多个同步监视器对象.(如果只用一个Condition,两个放的都在等,一旦一个放的进去路,
 * 那么它通知可能会导致另一个放接着往下走)
 *
 */
public class ConditionCommunication {

    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<50;i++) {
                    business.sub(i);
                }
            }
        }).start();


        for (int i=0;i<50;i++) {
            business.main(i);
        }
    }

    static class Business{
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        private boolean bShouldSub = true ;
        public  void sub(int i){
            lock.lock();
            try{
                while (!bShouldSub){
                    try {
                        condition.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j=1; j<=10; j++) {
                    System.out.println("子线程第"+i+"次循环,循环第"+j+"次");
                }
                bShouldSub = false;
               condition.signal();
            }finally {
                lock.unlock();
            }

        }

        public  void main(int i){
            lock.lock();
            try{
                while (bShouldSub){
                    try {
                        condition.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j=1;j<=100;j++){
                    System.out.println("主线程第" + i + "次循环,循环第" + j + "次");
                }
                bShouldSub = true;
                condition.signal();
            }finally {
                lock.unlock();
            }
        }
    }
}

package com.thread.threadTest;


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 三个线程来回切换执行
 */
public class ThreeConditionCommunication {

    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<50;i++) {
                    business.subTwo(i);
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<50;i++) {
                    business.subThree(i);
                }
            }
        }).start();


        for (int i=0;i<50;i++) {
            business.main(i);
        }
    }

    static class Business{
        Lock lock = new ReentrantLock();
        Condition conditionone = lock.newCondition();
        Condition conditiontwo = lock.newCondition();
        Condition conditionthree = lock.newCondition();


        private int bShouldSub = 1 ;
        public  void subTwo(int i){
            lock.lock();
            try{
                while (bShouldSub != 2){
                    try {
                        conditiontwo.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j=1; j<=10; j++) {
                    System.out.println("子线程2第"+i+"次循环,循环第"+j+"次");
                }
                bShouldSub = 3;
                conditionthree.signal();
            }finally {
                lock.unlock();
            }

        }

        public  void subThree(int i){
            lock.lock();
            try{
                while (bShouldSub!=3){
                    try {
                        conditionthree.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j=1; j<=10; j++) {
                    System.out.println("子线程3第"+i+"次循环,循环第"+j+"次");
                }
                bShouldSub = 1;
                conditionone.signal();
            }finally {
                lock.unlock();
            }

        }

        public  void main(int i){
            lock.lock();
            try{
                while (bShouldSub!=1){
                    try {
                        conditionone.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                for (int j=1;j<=10;j++){
                    System.out.println("主线程第" + i + "次循环,循环第" + j + "次");
                }
                bShouldSub = 2;
                conditiontwo.signal();
            }finally {
                lock.unlock();
            }
        }
    }
}