美文网首页java源码解读@IT·互联网程序员
java基础:java.util.concurrent.lock

java基础:java.util.concurrent.lock

作者: wuxiaowei | 来源:发表于2017-06-01 10:42 被阅读264次

    前言

    在BlockingQueue队列中,每当我们put和take元素时,当队列满时或空时,各自会阻塞,而这个阻塞方用的是Condition接口的await();与我们平时直接用Object的wait方法和notify方法大同小异,我将通过源码和一些例子来分析Condtion用法和它与Object的wait、notify之间的区别和各自的优点。

    在JDK源码中有段解释是:
    The key property that waiting for a condition provides is that it atomically releases the associated lock and suspends the current thread, just like Object.wait
    Condition执行等待(阻塞)方法提供的关键属性是,它会原子地释放相关的锁,并挂起当前线程,就像object.wait一样。

    由于Condition是一个接口,而实现这个接口的ConditionObject又是AbstractQueuedLongSynchronizer抽象类的内部类,所以,得到这个ConditionObject实例并不能直接newCondition,而是配合着AbstractQueuedLongSynchronizer方法使用,所以理解这层关系成了理解Condition的关键。

    简单用法

    下面是模拟Blockqueue写的一个关于Condition的用法,关于BlockQueue,大家可以参考java基础:java.util.concurrent.BlockingQueue,用法与wait和notify类似。
    创建一个队列,生产者往队列里put元素,如果队列已满,则阻塞,无法继续添加数据。然后再有一个消费者取数据,每取出一个数据,就用Condition.signal()方法唤醒阻塞方法,让生产者可以继续put元素。
    当队列为空时,再取元素就会开成阻塞,当再有生产者往队列里加数据时,也会唤醒取数据的阻塞方法。这样就形成了带阻塞的数据模型。

    package com.company.condition;
    
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.ReentrantLock;
    
    /**
     * Created by wxwall on 2017/5/31.
     */
    public class ConditionDemo {
    
    
        public static void main(String[] args) throws InterruptedException {
            //创建一个队列
            Queue queue = new Queue(3);
            //创建一个生产者,往队列里put数据
            Produce produce = new Produce(queue);
            Thread t = new Thread(produce);
            t.start();
            //Thread.sleep(3000);
            //创建一个消费者,用来取数据
            Consumer consumer = new Consumer(queue);
            Thread t1 = new Thread(consumer);
            t1.start();
        }
        static class Produce implements Runnable{
            Queue q = null;
            public Produce(Queue queue){
                this.q = queue;
            }
            @Override
            public void run() {
                try {
                    long begin = System.currentTimeMillis();
                    for (int i = 0;i<10;i++){
                        q.put(new String("aa"));
                        q.put(new String("bb"));
                        q.put(new String("cc"));
                    }
                    System.out.println("耗时:" + (System.currentTimeMillis() - begin));
    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        static class Consumer implements Runnable{
            Queue q = null;
            public Consumer(Queue queue){
                this.q = queue;
            }
            @Override
            public void run() {
                try {
                    for (int i = 0 ;i<10;i ++){
                        Object obj1 = q.take();
                        Object obj2 = q.take();
                        Object obj3 = q.take();
                        System.out.println((String)obj1.toString()  + "   " + (String)obj2.toString() + "   " + (String)obj3.toString());
                    }
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 创建一个简单的数组队列
         */
        private static class Queue {
            ReentrantLock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
            Object obj [] = null;
            private int size = 0;
            private int consInt = 0;
    
            public Queue(Integer obj){
                this.obj = new Object[obj];
            }
    
            //往队列里加数据
            public void put(Object obj) throws InterruptedException {
                //获得锁
                lock.lock();
                try {
                    if(size > this.obj.length -1){
                        //如果队列满了就阻塞
                        condition.await();
                    }
                    this.obj[size] = obj;
                    size ++;
                    //如果队列空了,添加元素后要通知take,唤醒condition
                    condition.signal();
                }finally {
                    lock.unlock();
                }
            }
    
            public Object take(){
                lock.lock();
                try{
                    if(size == 0 ){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Object obj = this.obj[size - 1];
                    size --;
                    condition.signal();
                    return obj;
                }finally {
                    lock.unlock();
                }
            }
        }
    }
    

    执行结果(因为没有用链表实现队列,所以结果并不是FIFO形式)

    cc   bb   aa
    cc   bb   aa
    cc   bb   aa
    cc   bb   aa
    cc   bb   aa
    cc   bb   aa
    aa   aa   cc
    cc   bb   bb
    cc   bb   aa
    cc   bb   aa
    耗时:1
    

    另外注意的一点是,BlockingQueue的实现ArrayBlockingQueue的put方法和take方法,分别用的是两个不同的condition实例,源码如下:

        /** Condition for waiting takes */
        private final Condition notEmpty;
        /** Condition for waiting puts */
        private final Condition notFull;
    

    上面代码模型如图所示:

    Paste_Image.png

    下面用实现一个简单的wait、notify模型

    package com.company.condition;
    
    
    import java.util.concurrent.locks.Condition;
    
    /**
     * Created by wxwall on 2017/5/29.
     */
    public class ConditionTest {
    
        public static void main(String[] args) throws InterruptedException {
            Condition condition;
            Integer a = 2;
            Thread t1 = new Thread(new ThreadCondition(a));
            Thread t2 = new Thread(new ThreadCondition(a));
            t1.start();
            t2.start();
        }
    
        public static class ThreadCondition implements Runnable{
            Integer a = 0;
            public ThreadCondition(Integer a){
                this.a = a;
            }
            @Override
            public void run() {
                try {
                    int  i = 0;
                    while(i < 3){
                        synchronized (a){
                            a.notify();
                            System.out.println(Thread.currentThread().getName());
                            a.wait();
                            System.out.println("wait被唤醒");
                        }
                        i++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    下面是输出结果:

    Thread-0
    Thread-1
    wait被唤醒
    Thread-0
    wait被唤醒
    Thread-1
    wait被唤醒
    Thread-0
    wait被唤醒
    Thread-1
    wait被唤醒
    

    与notify、wait方法的区别

    Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 Lock 实现组合使用,为每个对象提供多个等待 set (wait-set)。其中,Lock 替代了 synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。
    在同一个monitor中Conditioin可以存在多个实例,在生产者和消费者模型里比较常见。
    而wait,notify和notifyAll必须在同步块或者同步方法中进行(synchronized块或者synchronized方法)

    • wait()、notify()和notifyAll()方法是本地方法,并且为final方法,无法被重写。

    • 调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的monitor(即锁)

    • 调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程,如果有多个线程都在等待这个对象的monitor,则只能唤醒其中一个线程;

    • 调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程;

    JDK原文整理如下

    Condition 实现可以提供不同于 Object 监视器方法的行为和语义,比如受保证的通知排序,或者在执行通知时不需要保持一个锁。如果某个实现提供了这样特殊的语义,则该实现必须记录这些语义。
    注意,Condition 实例只是一些普通的对象,它们自身可以用作 synchronized 语句中的目标,并且可以调用自己的 wait 和 notification 监视器方法。获取 Condition 实例的监视器锁或者使用其监视器方法,与获取和该 Condition 相关的 Lock或使用其 waiting和 signalling 方法没有什么特定的关系。为了避免混淆,建议除了在其自身的实现中之外,切勿以这种方式使用 Condition 实例。

    为何这三个不是Thread类声明中的方法,而是Object类中声明的方法(当然由于Thread类继承了Object类,所以Thread也可以调用者三个方法)?

    由于每个对象都拥有monitor(即锁),所以让当前线程等待某个对象的锁,当然应该通过这个对象来操作了。而不是用当前线程来操作,因为当前线程可能会等待多个线程的锁,如果通过线程来操作,就非常复杂了。

    相关文章

      网友评论

      本文标题:java基础:java.util.concurrent.lock

      本文链接:https://www.haomeiwen.com/subject/bxidfxtx.html