欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

java集合框架 arrayblockingqueue應用分析

 更新時間:2012年11月28日 10:07:39   作者:  
ArrayBlockingQueue是一個由數組支持的有界阻塞隊列。此隊列按 FIFO(先進先出)原則對元素進行排序。隊列的頭部 是在隊列中存在時間最長的元素
Queue
------------
1.ArrayDeque, (數組雙端隊列)
2.PriorityQueue, (優(yōu)先級隊列)
3.ConcurrentLinkedQueue, (基于鏈表的并發(fā)隊列)
4.DelayQueue, (延期阻塞隊列)(阻塞隊列實現了BlockingQueue接口)
5.ArrayBlockingQueue, (基于數組的并發(fā)阻塞隊列)
6.LinkedBlockingQueue, (基于鏈表的FIFO阻塞隊列)
7.LinkedBlockingDeque, (基于鏈表的FIFO雙端阻塞隊列)
8.PriorityBlockingQueue, (帶優(yōu)先級的無界阻塞隊列)
9.SynchronousQueue (并發(fā)同步阻塞隊列)
-----------------------------------------------------
ArrayBlockingQueue
是一個由數組支持的有界阻塞隊列。此隊列按 FIFO(先進先出)原則對元素進行排序。隊列的頭部 是在隊列中存在時間最長的元素。隊列的尾部 是在隊列中存在時間最短的元素。新元素插入到隊列的尾部,隊列獲取操作則是從隊列頭部開始獲得元素。
這是一個典型的“有界緩存區(qū)”,固定大小的數組在其中保持生產者插入的元素和使用者提取的元素。一旦創(chuàng)建了這樣的緩存區(qū),就不能再增加其容量。試圖向已滿隊列中放入元素會導致操作受阻塞;試圖從空隊列中提取元素將導致類似阻塞。
此類支持對等待的生產者線程和消費者線程進行排序的可選公平策略。默認情況下,不保證是這種排序。然而,通過將公平性 (fairness) 設置為 true 而構造的隊列允許按照 FIFO 順序訪問線程。公平性通常會降低吞吐量,但也減少了可變性和避免了“不平衡性”。
復制代碼 代碼如下:

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
/** 隊列元素 數組 */
private final E[] items;
/** 獲取、刪除元素時的索引(take, poll 或 remove操作) */
private int takeIndex;
/** 添加元素時的索引(put, offer或 add操作) */
private int putIndex;
/** 隊列元素的數目*/
private int count;
/** 鎖 */
private final ReentrantLock lock;
/** 獲取操作時的條件 */
private final Condition notEmpty;
/** 插入操作時的條件 */
private final Condition notFull;
//超出數組長度時,重設為0
final int inc(int i) {
return (++i == items.length)? 0 : i;
}
/**
* 插入元素(在獲得鎖的情況下才調用)
*/
private void insert(E x) {
items[putIndex] = x;
putIndex = inc(putIndex);
++count;
notEmpty.signal();
}
/**
* 獲取并移除元素(在獲得鎖的情況下才調用)
*/
private E extract() {
final E[] items = this.items;
E x = items[takeIndex];
items[takeIndex] = null;
takeIndex = inc(takeIndex);//移到下一個位置
--count;
notFull.signal();
return x;
}
/**
* 刪除i位置的元素
*/
void removeAt(int i) {
final E[] items = this.items;
// if removing front item, just advance
if (i == takeIndex) {
items[takeIndex] = null;
takeIndex = inc(takeIndex);
} else {
// 把i后面的直到putIndex的元素都向前移動一個位置
for (;;) {
int nexti = inc(i);
if (nexti != putIndex) {
items[i] = items[nexti];
i = nexti;
} else {
items[i] = null;
putIndex = i;
break;
}
}
}
--count;
notFull.signal();
}
/**
*構造方法,指定容量,默認策略(不是按照FIFO的順序訪問)
*/
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
/**
*構造方法,指定容量及策略
*/
public ArrayBlockingQueue(int capacity, boolean fair) {
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = (E[]) new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
/**
* 通過集合構造
*/
public ArrayBlockingQueue(int capacity, boolean fair,
Collection<? extends E> c) {
this(capacity, fair);
if (capacity < c.size())
throw new IllegalArgumentException();
for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
add(it.next());
}
/**
* 插入元素到隊尾(super調用offer方法)
* public boolean add(E e) {
* if (offer(e))
* return true;
* else
* throw new IllegalStateException("Queue full");
* }
* 將指定的元素插入到此隊列的尾部(如果立即可行且不會超過該隊列的容量),
* 在成功時返回 true,如果此隊列已滿,則拋出 IllegalStateException。
*/
public boolean add(E e) {
return super.add(e);
}
/**
* 將指定的元素插入到此隊列的尾部(如果立即可行且不會超過該隊列的容量),
* 在成功時返回 true,如果此隊列已滿,則返回 false。
*/
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == items.length)
return false;
else {
insert(e);
return true;
}
} finally {
lock.unlock();
}
}
/**
* 將指定的元素插入此隊列的尾部,如果該隊列已滿,則等待可用的空間。
*/
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == items.length)
notFull.await();
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
insert(e);
} finally {
lock.unlock();
}
}
/**
* 將指定的元素插入此隊列的尾部,如果該隊列已滿,則在到達指定的等待時間之前等待可用的空間。
*/
public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException {
if (e == null) throw new NullPointerException();
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
if (count != items.length) {
insert(e);
return true;
}
if (nanos <= 0)//如果時間到了就返回
return false;
try {
nanos = notFull.awaitNanos(nanos);
} catch (InterruptedException ie) {
notFull.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
}
//獲取并移除此隊列的頭,如果此隊列為空,則返回 null。
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == 0)
return null;
E x = extract();
return x;
} finally {
lock.unlock();
}
}
//獲取并移除此隊列的頭部,在元素變得可用之前一直等待(如果有必要)。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
try {
while (count == 0)
notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
E x = extract();
return x;
} finally {
lock.unlock();
}
}
//獲取并移除此隊列的頭部,在指定的等待時間前等待可用的元素(如果有必要)。
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
if (count != 0) {
E x = extract();
return x;
}
if (nanos <= 0)
return null;
try {
nanos = notEmpty.awaitNanos(nanos);
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
}
//獲取但不移除此隊列的頭;如果此隊列為空,則返回 null。
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return (count == 0) ? null : items[takeIndex];
} finally {
lock.unlock();
}
}
/**
* 返回此隊列中元素的數量。
*/
public int size() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return count;
} finally {
lock.unlock();
}
}
/**
*返回在無阻塞的理想情況下(不存在內存或資源約束)此隊列能接受的其他元素數量。
*/
public int remainingCapacity() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return items.length - count;
} finally {
lock.unlock();
}
}
/**
* 從此隊列中移除指定元素的單個實例(如果存在)。
*/
public boolean remove(Object o) {
if (o == null) return false;
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lock();
try {
int i = takeIndex;
int k = 0;
for (;;) {
if (k++ >= count)
return false;
if (o.equals(items[i])) {
removeAt(i);
return true;
}
i = inc(i);
}
} finally {
lock.unlock();
}
}
/**
* 如果此隊列包含指定的元素,則返回 true。
*/
public boolean contains(Object o) {
if (o == null) return false;
final E[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lock();
try {
int i = takeIndex;
int k = 0;
while (k++ < count) {
if (o.equals(items[i]))
return true;
i = inc(i);
}
return false;
} finally {
lock.unlock();
}
}
……
}

相關文章

  • java線性表的存儲結構及其代碼實現

    java線性表的存儲結構及其代碼實現

    這篇文章主要為大家詳細介紹了Java數據結構學習筆記第一篇,線性表的存儲結構及其代碼實現,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2017-09-09
  • 淺談關于Java正則和轉義中\(zhòng)\和\\\\的理解

    淺談關于Java正則和轉義中\(zhòng)\和\\\\的理解

    這篇文章主要介紹了淺談關于Java正則和轉義中\(zhòng)\和\\\\的理解,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2019-08-08
  • IDEA Maven 配置備忘筆記

    IDEA Maven 配置備忘筆記

    這篇文章主要介紹了IDEA Maven 配置備忘筆記,小編覺得挺不錯的,現在分享給大家,也給大家做個參考。一起跟隨小編過來看看吧
    2018-09-09
  • java arrayList遍歷的四種方法及Java中ArrayList類的用法

    java arrayList遍歷的四種方法及Java中ArrayList類的用法

    arraylist是動態(tài)數組,它具有三個好處分別是:動態(tài)的增加和減少元素 、實現了ICollection和IList接口、靈活的設置數組的大小,本文給大家介紹java arraylist遍歷及Java arraylist 用法,感興趣的朋友一起學習吧
    2015-11-11
  • java之生產故障定位Arthas問題

    java之生產故障定位Arthas問題

    這篇文章主要介紹了java之生產故障定位Arthas問題,具有很好的參考價值,希望對大家有所幫助。如有錯誤或未考慮完全的地方,望不吝賜教
    2022-06-06
  • SpringCloud服務注冊和發(fā)現組件Eureka

    SpringCloud服務注冊和發(fā)現組件Eureka

    對于微服務的治理而言,其核心就是服務的注冊和發(fā)現。在SpringCloud 中提供了多種服務注冊與發(fā)現組件,官方推薦使用Eureka。本篇文章,我們來講解springcloud的服務注冊和發(fā)現組件,感興趣的可以了解一下
    2021-05-05
  • 淺談java多態(tài)的實現主要體現在哪些方面

    淺談java多態(tài)的實現主要體現在哪些方面

    下面小編就為大家?guī)硪黄獪\談java多態(tài)的實現主要體現在哪些方面。小編覺得挺不錯的,現在就分享給大家,也給大家做個參考。一起跟隨小編過來看看吧
    2016-09-09
  • Java利用泛型實現折半查找法

    Java利用泛型實現折半查找法

    泛型是JAVA重要的特性,使用泛型編程,可以使代碼復用率提高。查找作為泛型的一個簡單應用,本文將使用泛型實現折半查找法,感興趣的可以了解一下
    2022-08-08
  • SpringBoot實現簡單的日志鏈路追蹤

    SpringBoot實現簡單的日志鏈路追蹤

    隨著分布式應用的普及,現在的一些應用系統(tǒng)不再像以前,所有的文件(前后端程序)都打包在一個包中,本文通過一個簡單的SpringBoot應用來總結,我們如何將日志串聯(lián)起來,文中有詳細的代碼示例,需要的朋友可以參考下
    2023-10-10
  • 如何使用Spring自定義Xml標簽

    如何使用Spring自定義Xml標簽

    要實現自定義的xml配置,需要有兩個默認spring配置文件來支持。一個是spring.schemas,一個是spring.handlers,前者是為了驗證你自定義的xml配置文件是否符合你的格式要求,后者是告訴spring該如何來解析你自定義的配置文件。本文將介紹如何使用Spring自定義Xml標簽
    2021-06-06

最新評論