java多线程初探（零）使用Lock-线程间通信

测试类

package gcc.thread.Lock.condition;

/**
 * 类似wait和notify，ReentrantLock使用Condition来控制等待和唤醒机制，并且可以根据分组唤醒指定的线程，选择性通知
 * 如下，线程aa和ab在等待时所属不同的Condition，通过condition_A只唤醒了aa的等待
 */
public class Test {

    public static void main(String[] args) {
        try {
            ConditionService c = new ConditionService();
            ThreadA a = new ThreadA(c);
            ThreadB b = new ThreadB(c);
            a.start();
            Thread.sleep(1000);
            b.start();
            //
            ThreadA_a aa = new ThreadA_a(c);
            ThreadA_b ab = new ThreadA_b(c);
            aa.start();
            ab.start();
            Thread.sleep(1000);
            c.signalAll_A();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
    
}

服务方法

package gcc.thread.Lock.condition;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class ConditionService {

    protected static Logger logger = LoggerFactory.getLogger(ConditionService.class);

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Condition condition_A = lock.newCondition();
    private Condition condition_B = lock.newCondition();

    public void await(){
        try {
            lock.lock();
            logger.info("开始等待时间："+System.currentTimeMillis());
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitA(){
        try {
            lock.lock();
            logger.info("condition_A开始等待时间："+System.currentTimeMillis());
            condition_A.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try {
            lock.lock();
            logger.info("condition_B开始等待时间："+System.currentTimeMillis());
            condition_B.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signal(){
        try {
            lock.lock();
            condition.signal();
            logger.info("唤醒时间："+System.currentTimeMillis());
        } finally {
            lock.unlock();
        }
    }

    public void signalAll_A(){
        try {
            lock.lock();
            condition_A.signalAll();
            logger.info("condition_A唤醒时间："+System.currentTimeMillis());
        } finally {
            lock.unlock();
        }
    }

    public void signalAll_B(){
        try {
            lock.lock();
            condition_B.signalAll();
            logger.info("condition_B唤醒时间："+System.currentTimeMillis());
        } finally {
            lock.unlock();
        }
    }

}

线程A

package gcc.thread.Lock.condition;

public class ThreadA extends Thread {
    ConditionService conditionService;
    public ThreadA(ConditionService conditionService){
        this.conditionService=conditionService;
    }

    @Override
    public void run() {
        conditionService.await();
    }
}

线程B

package gcc.thread.Lock.condition;

public class ThreadB extends Thread {
    ConditionService conditionService;
    public ThreadB(ConditionService conditionService){
        this.conditionService=conditionService;
    }

    @Override
    public void run() {
        conditionService.signal();
    }
}

线程Aa

package gcc.thread.Lock.condition;

public class ThreadA_a extends Thread {
    ConditionService conditionService;
    public ThreadA_a(ConditionService conditionService){
        this.conditionService=conditionService;
    }

    @Override
    public void run() {
        conditionService.awaitA();
    }
}

线程Ab

package gcc.thread.Lock.condition;

public class ThreadA_b extends Thread {
    ConditionService conditionService;
    public ThreadA_b(ConditionService conditionService){
        this.conditionService=conditionService;
    }

    @Override
    public void run() {
        conditionService.awaitB();
    }
}