Java——多线程高并发系列之Condition接口中的await()signal()signAll()方法

Posted 2021-09-11 张起灵-小哥

文章目录：

写在前面

Demo1（Condition 等待与通知）

Demo2（多个 Condition 实现通知部分线程, 使用更灵活）

Demo3（使用 Condition 实现生产者/消费者设计模式, 两个线程交替打印）

---

写在前面

关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实现等待/通知模式。Lock 锁的 newContition()方法返回 Condition 对象，Condition 类也可以实现等待/通知模式。

使用Condition 类可以进行选择性通知. Condition 接口中比较常用的两个方法：await()会使当前线程等待，同时会释放锁，当其他线程调用 signal()时，线程会重新获得锁并继续执行，signal()用于唤醒一个等待的线程。

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的 Lock 锁。调用 await()后线程会释放这个锁，在 singal()调用后会从当前 Condition 对象的等待队列中，唤醒 一个线程，唤醒 的线程尝试获得锁， 一旦获得锁成功就继续执行。

也就是说，Condition接口中的await()方法就相当于之前与synchronized联合使用的Object类中的wait()方法；signal()方法就相当于之前与synchronized联合使用的Object类中的notify()方法。

---

Demo1（Condition 等待与通知）

package com.szh.lock.condition;

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

/**
 *  Condition 等待与通知
 */
public class Test01 {
    //定义锁对象
    static Lock lock=new ReentrantLock();

    //定义Condition类，获得Condition对象
    static Condition condition=lock.newCondition();

    static class SubThread extends Thread {
        @Override
        public void run() {
            try {
                lock.lock(); //在调用wait()前必须先获得锁
                System.out.println("method lock");
                condition.await();
                System.out.println("method await");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); //释放锁
                System.out.println("method unlock");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SubThread t=new SubThread();
        t.start(); //子线程启动后, 会转入等待状态

        Thread.sleep(1000 * 3); //主线程在睡眠 3 秒后, 唤醒子线程的等待

        try {
            lock.lock(); //在调用signal()前必须先获得锁
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

---

Demo2（多个 Condition 实现通知部分线程, 使用更灵活）

package com.szh.lock.condition;

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

/**
 *  多个 Condition 实现通知部分线程, 使用更灵活
 */
public class Test02 {

    static class Service {
        //定义锁对象
        private ReentrantLock lock=new ReentrantLock();
        //定义两个Condition对象
        private Condition conditionA=lock.newCondition();
        private Condition conditionB=lock.newCondition();

        //定义方法，使用conditionA等待
        public void waitMethodA() {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " begin wait: " + System.currentTimeMillis());
                conditionA.await();
                System.out.println(Thread.currentThread().getName() + " end wait: " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法唤醒 conditionA 对象上的等待
        public void signalMethodA() {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " signal A time = " + System.currentTimeMillis());
                conditionA.signal();
                System.out.println(Thread.currentThread().getName() + " signal A time = " + System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

        //定义方法，使用conditionB等待
        public void waitMethodB() {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " begin wait: " + System.currentTimeMillis());
                conditionB.await();
                System.out.println(Thread.currentThread().getName() + " end wait: " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法唤醒 conditionB 对象上的等待
        public void signalMethodB() {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " signal B time = " + System.currentTimeMillis());
                conditionB.signal();
                System.out.println(Thread.currentThread().getName() + " signal B time = " + System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Service service=new Service();

        //开启两个子线程，分别调用 waitMethodA(), waitMethodB() 方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodB();
            }
        }).start();

        Thread.sleep(3000); //main 线程睡眠 3 秒
        //唤醒 conditionA 对象上的等待,conditionB 上的等待依然继续等待
        service.signalMethodA();
        //service.signalMethodB();
    }
}

---

Demo3（使用 Condition 实现生产者/消费者设计模式, 两个线程交替打印）

package com.szh.lock.condition;

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

/**
 * 使用 Condition 实现生产者/消费者设计模式, 两个线程交替打印
 */
public class Test03 {

    static class Service {
        private Lock lock=new ReentrantLock(); //定义锁对象
        private Condition condition=lock.newCondition(); //创建Condition对象
        private boolean flag=true; //定义交替打印标志

        //定义方法只打印----横线
        public void printOne() {
            try {
                lock.lock(); //获得锁对象
                while (flag) { //当flag为true时，等待
                    System.out.println(Thread.currentThread().getName() + " waiting...");
                    condition.await();
                }
                //flag为false时，打印
                System.out.println(Thread.currentThread().getName() + "-----------");
                flag=true; //修改交替打印的标志
                condition.signal(); //通知另外的线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); //释放锁对象
            }
        }

        //定义方法只打印****星号
        public void printTwo() {
            try {
                lock.lock(); //获得锁对象
                while (!flag) { //当flag为false时，等待
                    System.out.println(Thread.currentThread().getName() + " waiting...");
                    condition.await();
                }
                //flag为false时，打印
                System.out.println(Thread.currentThread().getName() + "***********");
                flag=false; //修改交替打印的标志
                condition.signal(); //通知另外的线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); //释放锁对象
            }
        }
    }

    public static void main(String[] args) {
        Service s=new Service();

        //创建一个线程打印--------
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    s.printOne();
                }
            }
        }).start();

        //创建另一个线程打印********
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    s.printTwo();
                }
            }
        }).start();
    }
}

---