欢迎访问昆山宝鼎软件有限公司网站! 设为首页 | 网站地图 | XML | RSS订阅 | 宝鼎邮箱 | 后台管理


新闻资讯

MENU

软件开发知识

而await()方法会在中断标志设 劳务派遣信息管理系统 置后抛出InterruptedException异常后退出

点击: 次  来源:宝鼎软件 时间:2017-07-12

原文出处: 本日你不格斗来日诰日你就落伍

一、 媒介

上节先容了无界链表方法的阻塞行列LinkedBlockingQueue,本节来研究下有界利用数组方法实现的阻塞行列ArrayBlockingQueue

二、 ArrayBlockingQueue类图布局

而await()要了解在间断符号设 劳务调派信息打点系统 置后抛出InterruptedException异常退却出
如图ArrayBlockingQueue内部有个数组items用来存放行列元素,软件开发,putindex下标标示入队元素下标,takeIndex是出队下标,count统计行列元素个数,从界说可知道并没有利用volatile修饰,这是因为会见这些变量利用都是在锁块内,并不存在可见性问题。别的有个独有锁lock用来对进出队操纵加锁,这导致同时只有一个线程可以会见入队出队,别的notEmpty,notFull条件变量用来举办进出队的同步。

别的结构函数必需传入行列巨细参数,所觉得有界行列,默认是Lock为非公正锁。

public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
  }

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

三、offer操纵

在队尾插入元素,假如行列满则返回false,否者入队返回true。

public boolean offer(E e) {

    //e为null,则抛出NullPointerException异常
    checkNotNull(e);

    //获取独有锁
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //假如行列满则返回false
        if (count == items.length)
            return false;
        else {
            //否者插入元素
            insert(e);
            return true;
        }
    } finally {
        //释放锁
        lock.unlock();
    }
}


private void insert(E x) {

    //元素入队
    items[putIndex] = x;

    //计较下一个元素应该存放的下标
    putIndex = inc(putIndex);
    ++count;
    notEmpty.signal();
}

//轮回行列,计较下标
final int inc(int i) {
    return (++i == items.length) ? 0 : i;
}

这里由于在操纵共享变量前加了锁,所以不存在内存不行见问题,加过锁后获取的共享变量都是从主内存获取的,而不是在CPU缓存可能寄存器内里的值,释放锁后修改的共享变量值会刷新会主内存中。

别的这个行列是利用轮回数组实现,所以计较下一个元素存放下标时候有些非凡。别的insert后挪用 notEmpty.signal();是为了激活挪用notEmpty.await()阻塞后放入notEmpty条件行列中的线程。

四、put操纵

在行列尾部添加元素,假如行列满则期待行列有空位置插入后返回

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;

    //获取可被间断锁
    lock.lockInterruptibly();
    try {

        //假如行列满,则把当前线程放入notFull打点的条件行列
        while (count == items.length)
            notFull.await();

        //插入元素
        insert(e);
    } finally {
        lock.unlock();
    }
}

需要留意的是假如行列满了那么当前线程会阻塞,知道出队操纵挪用了notFull.signal要领激该死线程。

代码逻辑很简朴,可是这里需要思考一个问题为啥挪用lockInterruptibly要领而不是Lock要领。我的领略是因为挪用了条件变量的await()要领,而await()要了解在间断符号配置后抛出InterruptedException异常退却出,所以还不如在加锁时候先看间断符号是不是被配置了,假如配置了直接抛出InterruptedException异常,就不消再去获取锁了。然后看了其他并发类内里每每挪用了await的要领获取锁时候都是利用的lockInterruptibly要领而不是Lock也验证了这个想法。

五、poll操纵

从队头获取并移除元素,行列为空,则返回null。

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //当前行列为空则返回null,否者
        return (count == 0) ? null : extract();
    } finally {
        lock.unlock();
    }
}

private E extract() {
    final Object[] items = this.items;

    //获取元素值
    E x = this.<E>cast(items[takeIndex]);

    //数组中值值为null;
    items[takeIndex] = null;

    //队头指针计较,行列元素个数减一
    takeIndex = inc(takeIndex);
    --count;

    //发送信号激活notFull条件行列内里的线程
    notFull.signal();
    return x;
}

六、take操纵

从队头获取元素,假如行列为空则阻塞直到行列有元素。

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {

        //行列为空,则期待,直到行列有元素
        while (count == 0)
            notEmpty.await();
        return extract();
    } finally {
        lock.unlock();
    }
}