ReentrantLock Condition 随笔

Condition作用和Object.wait()和Object.notify()方法作用类似,但是wait()和notify()是和synchronized关键字结合使用的,而Condition是和ReentrantLock(重入锁)相关联的且更灵活:一个锁实例,可以绑定多个Condition实例,实现多路通知;notify()方法进行通知时,是随机进行选择的,但重入锁结合Condition对象,可以实现有选择性的通知。

Condition接口API:

public interface Condition {
    //阻塞当前线程。使当前线程加入等待队列中,同时释放当前锁,当其他线程使用signal()或者signalAll()方法时,线程会重新请求锁,得到锁后会继续执行。或者当线程被中断时,也能跳出等待。类似Object.wait()方法
    void await() throws InterruptedException;

    //调用该方法的前提是,当前线程已经成功获得与该Condition对象绑定的重入锁,否则调用该方法时会抛出IllegalMonitorStateException。
    //基本同await()方法,但是不会在等待过程中响应中断。调用该方法后,结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断,该方法仍然会继续等待,同时保留该线程的中断状态。
    void awaitUninterruptibly();

    //调用该方法的前提是,当前线程已经成功获得与该Condition对象绑定的重入锁,否则调用该方法时会抛出IllegalMonitorStateException。
    //等待的的最大时间(单位为纳秒)。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间;若指定时间内未收到通知,则返回0或负数。
    //在等待过程中会响应中断,若指定时间内有其它线程中断该线程,则抛出InterruptedException并清除当前线程的打断状态。
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    //与await()基本一致,不同点:指定时间之内没有收到signal()或signalALL()或线程中断会返回false;其它情况返回true。
    boolean await(long time, TimeUnit unit) throws InterruptedException;

   //与awaitNanos(long nanosTimeout)一致,不同点在于它不是等待指定时间,而是等待时间到达参数指定的某一时刻。
    boolean awaitUntil(Date deadline) throws InterruptedException;
    
    //唤醒一个等待队列中的线程。与Object.notify()相似,但是signal()唤醒的线程与该Condition对象有关
    void signal();

   //唤醒等待队列中所有线程。与object.notifyAll()相似,但是signalAll()唤醒的线程与该Condition对象有关
    void signalAll();
}

代码Demo:
 

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

/**
 * 可重入锁不同condition测试
 */
public class MyReentrantLockCondition implements Runnable {
    //共享锁
    public static ReentrantLock lock = new ReentrantLock();
    //condition不共享
    public Condition condition;
    //共享变量
    //public static volatile int i = 1;

    public MyReentrantLockCondition() {
        //每个对象独立condition
        this.condition = lock.newCondition();
    }

    public void await() {
        //自旋获取锁,直到获取锁成功
        lock.lock();
        try {
            System.out.println("-->await(): " + Thread.currentThread().getName() + " 获取了锁");
            //当前线程等待,释放了锁。类比Object.wait()。多线程操作共享变量是否有问题?没有问题,唤醒时会重新获取锁重新获取值
            condition.await();
            System.out.println("-->await(): " + Thread.currentThread().getName() + " 结束执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //任何情况都释放锁对象
            lock.unlock();
        }
    }

    public void signal() {
        lock.lock();
        try {
            //唤醒等待队列中关联condition的一个线程.类比Object.notify()
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    //测试
    public static void main(String[] args) throws InterruptedException {
        MyReentrantLockCondition condition1 = new MyReentrantLockCondition();
        MyReentrantLockCondition condition2 = new MyReentrantLockCondition();
        MyReentrantLockCondition condition3 = new MyReentrantLockCondition();
        MyReentrantLockCondition condition4 = new MyReentrantLockCondition();
        new Thread(condition1).start();
        new Thread(condition2).start();
        new Thread(condition3).start();
        new Thread(condition4).start();
        Thread.sleep(3000);
        //通知线程继续执行
        condition1.signal();
        condition2.signal();
//        condition3.signal();

/*        MyReentrantLockCondition.lock.lock();
        try {
            condition4.condition.signalAll();
        } finally {
            MyReentrantLockCondition.lock.unlock();
        }*/
    }

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

运行main()方法,可看到结果:

-->await(): Thread-0 获取了锁
-->await(): Thread-1 获取了锁
-->await(): Thread-2 获取了锁
-->await(): Thread-3 获取了锁
-->await(): Thread-0 结束执行
-->await(): Thread-1 结束执行

Thread-2、Thread-3没有“结束执行”,还在一直等待signal()唤醒。

Condition在JDK源码中的应用:

java.util.concurrent.ArrayBlockingQueue阻塞队列:基于数组的阻塞队列实现,在ArrayBlockingQueue内部,维护了一个定长数组,以便缓存队列中的数据对象,还保存着两个整形变量,分别标识着队列的头部和尾部在数组中的位置。

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

    final Object[] items;

    int takeIndex;

    int putIndex;

    int count;

    final ReentrantLock lock;

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

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

    //往队列中添加对象
    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();//自旋获取锁
        try {
            while (count == items.length)//队列已满
                notFull.await();//进入等待队列中等待,关联notFull条件
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

    //队列中移除对象
    private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();//唤醒一个等待队列中等待notFull条件的线程
        return x;
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值