java中併發Queue種類與各自API特點以及使用場景!

阿新 • • 發佈：2018-12-21

一先說下佇列

佇列是一種資料結構．它有兩個基本操作：在佇列尾部加入一個元素，和從佇列頭部移除一個元素（注意不要弄混佇列的頭部和尾部）

就是說，佇列以一種先進先出的方式管理資料，如果你試圖向一個已經滿了的阻塞佇列中新增一個元素或者是從一個空的阻塞佇列中移除一個元索，將導致執行緒阻塞．

在多執行緒進行合作時，阻塞佇列是很有用的工具。工作者執行緒可以定期地把中間結果存到阻塞佇列中而其他工作者執行緒把中間結果取出並在將來修改它們。佇列會自動平衡負載。

如果第一個執行緒集執行得比第二個慢，則第二個執行緒集在等待結果時就會阻塞。如果第一個執行緒集執行得快，那麼它將等待第二個執行緒集趕上來.

說白了,就是先進先出,執行緒安全!

java中併發佇列都是在java.util.concurrent併發包下的,Queue介面與List、Set同一級別，都是繼承了Collection介面,最近學習了java中的併發Queue的所有子類應用場景,這裡記錄分享一下:

1.1 這裡可以先用wait與notify(腦忒fai) 模擬一下佇列的增刪資料,簡單瞭解一下佇列:

import java.util.LinkedList;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 模擬佇列增刪資料

* @author houzheng

*/

public class MyQueue {

//元素集合

private LinkedList<Object> list=new LinkedList<Object>();

//計數器(同步),判斷集合元素數量

private AtomicInteger count=new AtomicInteger();

//集合上限與下限,final必須指定初值

private final int minSize=0;

private final int maxSize;

//構造器指定最大值

public MyQueue(int maxSize) {

this.maxSize = maxSize;

}

//初始化物件,用於加鎖,也可直接用this

private Object lock=new Object();

//put方法:往集合中新增元素,如果集合元素已滿,則此執行緒阻塞,直到有空間再繼續

public void put(Object obj){

synchronized (lock) {

while(count.get()==this.maxSize){

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();}

}

list.add(obj);

//計數器加一

count.incrementAndGet();

System.out.println("放入元素:"+obj);

//喚醒另一個執行緒,(處理極端情況:集合一開始就是空,此時take執行緒會一直等待)

lock.notify();

}

//take方法:從元素中取資料,如果集合為空,則執行緒阻塞,直到集合不為空再繼續

public Object take(){

Object result=null;

synchronized(lock){

while(count.get()==this.minSize){

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();}

}

//移除第一個

result=list.removeFirst();

//計數器減一

count.decrementAndGet();

System.out.println("拿走元素:"+result);

//喚醒另一個執行緒,(處理極端情況:集合一開始就是滿的,此時put執行緒會一直等待)

lock.notify();

}

return result;

}

public int getSize(){

return this.count.get();

}

public static void main(String[] args) {

//建立集合容器

MyQueue queue=new MyQueue(5);

queue.put("1");

queue.put("2");

queue.put("3");

queue.put("4");

queue.put("5");

System.out.println("當前容器長度為:"+queue.getSize());

Thread t1=new Thread(()->{

queue.put("6");

queue.put("7");

},"t1");

Thread t2=new Thread(()->{

Object take1 = queue.take();

Object take2 = queue.take();

},"t2");

//測試極端情況,兩秒鐘後再執行另一個執行緒

t1.start();

try {

TimeUnit.SECONDS.sleep(2);

} catch (InterruptedException e) {

e.printStackTrace();

}

t2.start();

}

　　這裡用執行緒通訊的方式簡單模擬了佇列的進出,那麼接下來就正式進入java的併發佇列:

二併發Queue

JDK中併發佇列提供了兩種實現,一種是高效能佇列ConcurrentLinkedQueue,一種是阻塞佇列BlockingQueue,兩種都繼承自Queue:

1 ConcurrentLinkedQueue

這是一個使用於高併發場景的佇列(額,各位看這塊部落格的小朋友,最好對執行緒基礎比較熟悉再來看,當然我也在拼命學習啦,哈哈哈),主要是無鎖的方式,他的想能要比BlockingQueue好

,是基於連結節點的無界執行緒安全佇列,先進先出,不允許有null元素,廢話不多說,上demo:

這種queue比較簡單,沒什麼好說的,和ArrayList一樣用就可以,關鍵是BlockingQUeue

2 BlockingQueue

blockingQueue主要有5中實現,我感覺都挺有意思的,其中幾種還比較常用就都學習了下,這裡都介紹下:

2.1 ArrayBlockingQueue

@Test

public void test02() throws Exception{

//必須指定佇列長度

ArrayBlockingQueue<String> abq=new ArrayBlockingQueue<String>(2);

abq.add("a");

//add :新增元素,如果BlockingQueue可以容納,則返回true,否則拋異常,支援新增集合

System.out.println(abq.offer("b"));//容量如果不夠,返回false

//offer: 如果可能的話,新增元素,即如果BlockingQueue可以容納,則返回true,否則返回false,支援設定超時時間

//設定超時,如果超過時間就不新增,返回false,

abq.offer("d", 2, TimeUnit.SECONDS);// 新增的元素,時長,單位

//put 新增元素,如果BlockQueue沒有空間,則呼叫此方法的執行緒被阻斷直到BlockingQueue裡面有空間再繼續.

abq.put("d");//會一直等待

//poll 取走頭部元素,若不能立即取出,則可以等time引數規定的時間,取不到時返回null,支援設定超時時間

abq.poll();

abq.poll(2,TimeUnit.SECONDS);//兩秒取不到返回null

//take() 取走頭部元素,若BlockingQueue為空,阻斷進入等待狀態直到Blocking有新的物件被加入為止

abq.take();

//取出頭部元素,但不刪除

abq.element();

//drainTo()

//一次性從BlockingQueue獲取所有可用的資料物件（還可以指定獲取資料的個數），通過該方法，可以提升獲取資料效率；不需要多次分批加鎖或釋放鎖。

List list=new ArrayList();

abq.drainTo(list,2);//將佇列中兩個元素取到list中，取走後佇列中就沒有取走的元素

System.out.println(list); //[a,b]

System.out.println(abq); //[]

}

2.2 LinkedBlockingQueue

@Test

public void test03(){

LinkedBlockingQueue lbq=new LinkedBlockingQueue();//可指定容量，也可不指定

lbq.add("a");

lbq.add("b");

lbq.add("c");

//API與ArrayBlockingQueue相同

//是否包含

System.out.println(lbq.contains("a"));

//移除頭部元素或者指定元素 remove("a")

System.out.println(lbq.remove());

//轉陣列

Object[] array = lbq.toArray();

//element 取出頭部元素，但不刪除

System.out.println(lbq.element());

}

2.3 SynchronousQueue

public static void main(String[] args) {

SynchronousQueue<String> sq=new SynchronousQueue<String>();

// iterator() 永遠返回空，因為裡面沒東西。

// peek() 永遠返回null

/**

* isEmpty()永遠是true。

* remainingCapacity() 永遠是0。

* remove()和removeAll() 永遠是false。

*/

new Thread(()->{

try {

//取出並且remove掉queue裡的element（認為是在queue裡的。。。），取不到東西他會一直等。

System.out.println(sq.take());

} catch (InterruptedException e) {

e.printStackTrace();

}

}).start();

new Thread(()->{

try {

//offer() 往queue裡放一個element後立即返回，

//如果碰巧這個element被另一個thread取走了，offer方法返回true，認為offer成功；否則返回false

//true ,上面take執行緒一直在等,

////下面剛offer進去就被拿走了,返回true,如果offer執行緒先執行,則返回false

System.out.println(sq.offer("b"));

} catch (Exception e) {

e.printStackTrace();

}

}).start();

new Thread(()->{

try {

//往queue放進去一個element以後就一直wait直到有其他thread進來把這個element取走

sq.put("a");

} catch (Exception e) {

e.printStackTrace();

}

}).start();

}

2.4 PriorityBlockingQueue

@Test

public void test04() throws Exception{

//佇列裡元素必須實現Comparable介面,用來決定優先順序

PriorityBlockingQueue<String> pbq=new PriorityBlockingQueue<String>();

pbq.add("b");

pbq.add("g");

pbq.add("a");

pbq.add("c");

//獲取的時候會根據優先順序取元素,插入的時候不會排序,節省效能

//System.out.println(pbq.take());//a,獲取時會排序,按優先順序獲取

System.out.println(pbq.toString());//如果前面沒有取值,直接syso也不會排序

Iterator<String> iterator = pbq.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

@Test

public void test05(){

PriorityBlockingQueue<Person> pbq=new PriorityBlockingQueue<Person>();

Person p2=new Person("姚振",20);

Person p1=new Person("侯徵",24);

Person p3=new Person("何毅",18);

Person p4=new Person("李世彪",22);

pbq.add(p1);

pbq.add(p2);

pbq.add(p3);

pbq.add(p4);

System.out.println(pbq);//沒有按優先順序排序

try {

//只要take獲取元素就會按照優先順序排序,獲取一次就全部排好序了,後面就會按優先順序迭代

pbq.take();

} catch (InterruptedException e) {

e.printStackTrace();

}

//按年齡排好了序

for (Iterator iterator = pbq.iterator(); iterator.hasNext();) {

Person person = (Person) iterator.next();

System.out.println(person);

}

2.5 最後說一下DelayQueue ,這裡用個網上很經典的例子,網咖上網計時

網民實體queue中元素

//網民

public class Netizen implements Delayed {

//身份證

private String ID;

//名字

private String name;

//上網截止時間

private long playTime;

//比較優先順序,時間最短的優先

@Override

public int compareTo(Delayed o) {

Netizen netizen=(Netizen) o;

return this.getDelay(TimeUnit.SECONDS)-o.getDelay(TimeUnit.SECONDS)>0?1:0;

}

public Netizen(String iD, String name, long playTime) {

ID = iD;

this.name = name;

this.playTime = playTime;

}

//獲取上網時長,即延時時長

@Override

public long getDelay(TimeUnit unit) {

//上網截止時間減去現在當前時間=時長

return this.playTime-System.currentTimeMillis();

}

　網咖類:

//網咖

public class InternetBar implements Runnable {

//網民佇列,使用延時佇列

private DelayQueue<Netizen> dq=new DelayQueue<Netizen>();

//上網

public void startPlay(String id,String name,Integer money){

//截止時間= 錢數*時間+當前時間(1塊錢1秒)

Netizen netizen=new Netizen(id,name,1000*money+System.currentTimeMillis());

System.out.println(name+"開始上網計費......");

dq.add(netizen);

}

//時間到下機

public void endTime(Netizen netizen){

System.out.println(netizen.getName()+"餘額用完,下機");

}

@Override

public void run() {

//執行緒,監控每個網民上網時長

while(true){

try {

//除非時間到.否則會一直等待,直到取出這個元素為止

Netizen netizen=dq.take();

endTime(netizen);

}

catch (InterruptedException e) {

e.printStackTrace();

}

public static void main(String[] args) {

//新建一個網咖

InternetBar internetBar=new InternetBar();

//來了三個網民上網

internetBar.startPlay("001","侯徵",3);

internetBar.startPlay("002","姚振",7);

internetBar.startPlay("003","何毅",5);

Thread t1=new Thread(internetBar);

t1.start();

}

　　這樣就可以完美實現業務需求了,

結果,

這塊東西比較深,還需要不斷加強學習實踐才行!!

好文要頂關注我收藏該文

java中併發Queue種類與各自API特點以及使用場景!

一先說下佇列佇列是一種資料結構．它有兩個基本操作：在佇列尾部加入一個元素，和從佇列頭部移除一個元素（注意不要弄混佇列的頭部和尾部）就是說，佇列以一種先進先出的方式管理資料，如果你試圖向一個已經滿了的阻塞佇列中新增一個元素或者是從一個空的阻塞佇列中移除一個元索，將導

java中的二進位制int與byte互轉以及&0xff的作用

1. 按位與& ：兩位全位1，結果才為1； 0&0=0; 0&1=0 ; 1&1=1 如：51 &5 =0011 0011 & 0000 0101=0000 0001 = 1 作用：清零、取一個數中指定位（即

Java中a=a+b 與 a+=b區別以及和型別轉換的關係

很久之前學習過 a=a+b 和a+=b的一些區別，進來再次回想起來，發現理解的還不透徹，所以又查資料找檔案重新學習了一番。比較這兩種運算子的區別，可以有以下兩個方面的比較：執行效率和型別轉換。首先說一下執行效率問題就單純的執行這兩條語句，不考慮編譯器的優化的話，a

理解Java中字符流與字節流的區別

png 技術 print 復制代碼 bar 顯式數字 length ava 1. 什麽是流 Java中的流是對字節序列的抽象，我們可以想象有一個水管，只不過現在流動在水管中的不再是水，而是字節序列。和水流一樣，Java中的流也具有一個“流動的方向”，通常可以從中讀

java中註解的使用與實例(一)

title 編譯器 new ng2 警告元素 epc 目前而且 http://www.cnblogs.com/pepcod/archive/2013/02/16/2913474.html 註解目前非常的流行，很多主流框架都支持註解，而且自己編寫代碼的時候也會盡量的去用註

java中容器的學習與理解

優化是我 move 查找 map 常常 ise 線性 arr 　　以前一直對於java中容器的概念不理解，雖然學習過，但始終沒有認真理解過，這幾天老師提出了這樣一個問題，你怎麽理解java中的容器。瞬間就蒙了。於是各種搜資料學習了一下，下面是我學習後整理出來的的一些心得。

Java中Javadoc的{@link}與@see的簡單區別

java http 技術 pan lan 分享圖片參考 article 圖片 {@link}與@see這兩個Javadoc註解都可以直接鏈接類和方法。用法基本一致。但是@see必須頂頭寫，而{@link可以任意地方}，如下所示：參考： http:

類與接口（三）java中的接口與嵌套接口

strong span class .... 定義成員抽象數列多個一、接口 1. 接口簡介接口：是java的一種抽象類型，是抽象方法的集合。接口比抽象類更加抽象的抽象類型。接口語法： [修飾符] [abstract] interface 接口名 [exten

[Js-Java SE]Java中的Native關鍵字與JNI

pan 基礎好文 native ava 文章 aid java se targe 一篇精細基礎到令人發指的好文章mark 鏈接： https://pan.baidu.com/s/1-9X8YFBdmFyaWDJoSZyBtQ 密碼： 90sf[Js-Java SE]Jav

Java中方法遞歸與File例題

方法遞歸 File類不死神兔遞歸刪除文件輸出文件後綴名固定的文件絕對路徑 1、有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子長到第三個月後每個月又生一對兔子，假如兔子都不死，問第二十個月的兔子對數為多少？(不死神兔)（1）數組方式 package 遞歸.作業; publi

Java中的抽象類與接口

12px 課程 java abstract nature RF IT reat eth 主要內容來自MIT6.031 Software Construction課程及HIT 軟件構造課程。在介紹抽象類（Abstract Class）之前，我們先來談什麽是抽象方法（Ab

第6篇 Java中的接口與抽象類

集合 conn event int str ckey 實現類 bst div 接口 Interface 在JAVA編程語言中是一個抽象類型，是抽象方法的集合。接口通常以interface來聲明。一個類通過實現接口(implements)的方式，從而實現接口的抽象方法。接

Java中，&&與&，||與|的區別

key int ron sso keyword 邏輯運算一個 || mil 原文地址： Java中，&&與&，||與|的區別在java的邏輯運算符中，有這麽四類：&&（短路與），&，|，||（短路或）。 &am

深入理解Java中的字段與屬性的區別

ring rgs name 私有變量 pub tail 博文們的方式轉載出處 http://blog.csdn.net/chenchunlin526/article/details/69939337 1、Java中的屬性和字段有什麽區別？答：Java中的屬性(p

Java中Json對象與xml字符串互轉

sonar string https 使用 noclass err str java 2.x JSON 轉XML 轉：https://blog.csdn.net/u013714419/article/details/24804337 XMLSerializer xmlSer

Java中字符流與字節流的區別

重載方法二進制抽象類相同緩沖區 pre pub 不支持之間 1. 什麽是流 Java中的流是對字節序列的抽象，我們可以想象有一個水管，只不過現在流動在水管中的不再是水，而是字節序列。和水流一樣，Java中的流也具有一個“流動的方向”，通常可以從中讀入一個字

java中的AutoCloseable介面與try with resources

try-with-resources引入的背景很多Java程式都需要操作一些資源，如檔案、流（streams）、套接字（sockets）和資料庫連線（database connections）。操作這些資源的時候得很小心，因為它們操作的時候獲取了作業系統的資源。所以你得保證，即使在發生

Java中陣列的定義與使用

陣列 — 一種引用資料型別一、一維陣列的定義與使用 1.1 陣列初始化 1.1.1 陣列動態初始化：資料型別[ ] 陣列名稱 = new 資料型別[陣列長度]; 舉個例子：陣列通過下標索引來獲取元素，即陣列名[下標]，下標預設從0開始，到長度

Java中方法的定義與使用

一、方法的定義：方法：指的是一段可以重複呼叫的程式碼（和C語言中的函式一樣）（注：這裡說的是直接在主方法中呼叫的方法）方法的定義語法： public static 返回值型別方法名（引數） { //方法體 //返回值 } 如果返回值型別為void，則沒有返

JAVA中類、例項與Class物件

類類是面向物件程式語言的一個重要概念，它是對一項事物的抽象概括，可以包含該事物的一些屬性定義，以及操作屬性的方法。面向物件程式設計中，我們都是以類來編碼。例項簡單理解，就是new，就是對類的例項化，建立這個類對應

java中併發Queue種類與各自API特點以及使用場景!

一 先說下佇列

二 併發Queue

1 ConcurrentLinkedQueue

2 BlockingQueue

相關推薦

一先說下佇列

二併發Queue