• java多线程 -- Condition 控制线程通信


    Api文档如此定义:

    ConditionObject 监视器方法(waitnotifynotifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set(wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。

    Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似,但提供了更强大的功能。需要特别指出的是,单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题,Condition 方法的名称与对应的 Object 版本中的不同。
    在 Condition 对象中,与 wait、notify 和 notifyAll 方法对应的分别是await、signal 和 signalAll
    Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例,请使用其 newCondition() 方法。

    api相关方法:

    1. void await()造成当前线程在接到信号或被中断之前一直处于等待状态。
    2. boolean await(long time, TimeUnit unit) 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
    3. long awaitNanos(long nanosTimeout) 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
    4. void awaitUninterruptibly()造成当前线程在接到信号之前一直处于等待状态。
    5. boolean awaitUntil(Date deadline)造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。
    6. void signal()唤醒一个等待线程。
    7. void signalAll()唤醒所有等待线程。

    例如:

    package com.company;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    /*
     * 生产者消费者案例:
     */
    public class TestProductorAndConsumerForLock {
    
        public static void main(String[] args) {
            Clerk clerk = new Clerk();
    
            Productor pro = new Productor(clerk);
            Consumer con = new Consumer(clerk);
    
            new Thread(pro, "生产者 A").start();
            new Thread(con, "消费者 B").start();
    
    //         new Thread(pro, "生产者 C").start();
    //         new Thread(con, "消费者 D").start();
        }
    
    }
    
    class Clerk {
        private int product = 0;
    
        private Lock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
    
        // 进货
        public void get() {
            lock.lock();
    
            try {
                if (product >= 1) { // 为了避免虚假唤醒,应该总是使用在循环中。
                    System.out.println("产品已满!");
    
                    try {
                        condition.await();//替代this.wait;
                    } catch (InterruptedException e) {
                    }
    
                }
                System.out.println(Thread.currentThread().getName() + " : "
                        + ++product);
    
                condition.signalAll();//代替this.notifyall();
            } finally {
                lock.unlock();
            }
    
        }
    
        // 卖货
        public void sale() {
            lock.lock();
    
            try {
                if (product <= 0) {
                    System.out.println("缺货!");
    
                    try {
                        condition.await();//替代this.wait;
                    } catch (InterruptedException e) {
                    }
                }
    
                System.out.println(Thread.currentThread().getName() + " : "
                        + --product);
    
                condition.signalAll();//代替this.notifyall();
    
            } finally {
                lock.unlock();
            }
        }
    }
    
    // 生产者
    class Productor implements Runnable {
    
        private Clerk clerk;
    
        public Productor(Clerk clerk) {
            this.clerk = clerk;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                clerk.get();
            }
        }
    }
    
    // 消费者
    class Consumer implements Runnable {
    
        private Clerk clerk;
    
        public Consumer(Clerk clerk) {
            this.clerk = clerk;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 20; i++) {
                clerk.sale();
            }
        }
    
    }

     结果:

    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
    缺货!
    生产者 A : 1
    消费者 B : 0
  • 相关阅读:
    JavaWeb学习篇之----自定义标签&&JSTL标签库详解
    JavaWeb学习篇之----EL表达式详解
    JavaWeb学习篇之----Jsp详解
    JavaWeb学习篇之----Servlet过滤器Filter和监听器
    JavaWeb学习篇之----Session&&Cookie
    JavaWeb学习篇之----容器Request详解
    JavaWeb学习篇之----浏览器缓存问题详解
    JavaWeb学习篇之----容器Response详解
    JavaWeb学习篇之----HTTP协议详解
    factory工厂模式之抽象工厂AbstractFactory
  • 原文地址:https://www.cnblogs.com/androidsuperman/p/6657818.html
Copyright © 2020-2023  润新知