久久亚洲精品中文字幕,亚洲经典成人,国产女人伦码一区二区三区不卡

編者按：筆者在使用PriorityBlockingQueue實現按照優先級處理任務時遇到一類NPE問題，經過分析發現根本原因是在任務出隊列時調用比較器異常，進而導致后續任務出隊列拋出NullPointerException。本文通過完整的案例復現來演示在什么情況會觸發該問題，同時給出了處理建議。希望讀者在編程時加以借鑒，避免再次遇到此類問題。

背景知識

PriorityBlockingQueue是一個無界的基于數組的優先級阻塞隊列，使用一個全局ReentrantLock來控制某一時刻只有一個線程可以進行元素出隊和入隊操作，并且每次出隊都返回優先級別最高的或者最低的元素。PriorityBlockingQueue通過以下兩種方式實現元素優先級排序：

入隊元素實現Comparable接口來比較元素優先級；
PriorityBlockingQueue構造函數指定Comparator來比較元素優先級；

關于PriorityBlockingQueue中隊列操作的部分，基本和PriorityQueue邏輯一致，只不過在操作時加鎖了。在本文中我們主要關注PriorityBlockingQueue出隊的take方法，該方法通過調用dequeue方法將元素出隊列。當沒有元素可以出隊的時候，線程就會阻塞等待。

publicEtake()throwsInterruptedException{
finalReentrantLocklock=this.lock;
lock.lockInterruptibly();
Eresult;
try{
//嘗試獲取最小元素，即小頂堆第一個元素，然后重新排序，如果不存在表示隊列暫無元素，進行阻塞等待。
while((result=dequeue())==null)
notEmpty.await();
}finally{
lock.unlock();
}
returnresult;
}

現象

在某個業務服務中使用PriorityBlockingQueue實現按照優先級處理任務，某一天環境中的服務突然間不處理任務了，查看后臺日志，發現一直拋出NullPointerException。將進程堆dump出來，使用MAT發現某個PriorityBlockingQueue中的size值比實際元素個數多1個（入隊時已經對任務進行非空校驗）。

異常堆棧如下：

java.lang.NullPointerException
atjava.util.concurrent.PriorityBlockingQueue.siftDownComparable(PriorityBlockingQueue.java:404)
atjava.util.concurrent.PriorityBlockingQueue.dequeue(PriorityBlockingQueue.java:333)
atjava.util.concurrent.PriorityBlockingQueue.take(PriorityBlockingQueue.java:548)
...

MAT結果：

原因分析

在此我們分析下PriorityBlockingQueue是如何出隊列的，PriorityBlockingQueue最終通過調用dequeue方法出隊列，dequeue方法處理邏輯如下：

將根節點（array[0]）賦值給result；
array[n] 賦值給 arrary[0]；
將 array[n] 設置為 null；
調用siftDownComparable或siftDownUsingComparator對隊列元素重新排序；
size大小減1；
返回result；

如果在第4步中出現異常，就會出現隊列中的元素個數比實際的元素個數多1個的現象。此時size未發生改變，arry[n]已經被置為null，再進行siftDown操作時就會拋出NullPointerException。繼續分析第4步中在什么情況下會出現異常，通過代碼走讀我們可以發現只有在調用Comparable#compareTo或者Comparator#compare方法進行元素比較的時候才可能出現異常。這塊代碼的處理邏輯和業務相關，如果業務代碼處理不當拋出異常，就會導致上述現象。

/**
*Mechanicsforpoll().Callonlywhileholdinglock.
*/
privateEdequeue(){
intn=size-1;
if(n0)
returnnull;
else{
Object[]array=queue;
Eresult=(E)array[0];//step1
Ex=(E)array[n];//step2
array[n]=null;//step3
ComparatorsuperE>cmp=comparator;
if(cmp==null)//step4 如果指定了comparator，就按照指定的comparator來比較。否則就按照默認的
siftDownComparable(0,x,array,n);
else
siftDownUsingComparator(0,x,array,n,cmp);
size=n;//step5
returnresult;//step6
}
}

privatestaticvoidsiftDownComparable(intk,Tx,Object[]array,intn){
if(n>0){
ComparablesuperT>key=(ComparablesuperT>)x;
inthalf=n>>>1;
while(kintchild=(k<1)+1;
Objectc=array[child];
intright=child+1;
if(rightsuperT>)c).compareTo((T)array[right])>0)
c=array[child=right];
if(key.compareTo((T)c)<=?0)
break;
array[k]=c;
k=child;
}
array[k]=key;
}
}
privatestaticvoidsiftDownUsingComparator(intk,Tx,Object[]array,intn,
ComparatorsuperT>cmp){
if(n>0){
inthalf=n>>>1;
while(kintchild=(k<1)+1;
Objectc=array[child];
intright=child+1;
if(right0)
c=array[child=right];
if(cmp.compare(x,(T)c)<=?0)
break;
array[k]=c;
k=child;
}
array[k]=x;
}
}

復現代碼

importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.PriorityBlockingQueue;

publicclassPriorityBlockingQueueTest{
staticclassEntityimplementsComparable<Entity>{
privateintid;
privateStringname;
privatebooleanflag;

publicvoidsetFlag(booleanflag){
this.flag=flag;
}

publicEntity(intid,Stringname){
this.id=id;
this.name=name;
}

@Override
publicintcompareTo(Entityentity){
if(flag){
thrownewRuntimeException("TestException");
}
if(entity==null||this.id>entity.id){
return1;
}
returnthis.id==entity.id?0:-1;
}
}

publicstaticvoidmain(String[]args){
intnum=5;
PriorityBlockingQueuepriorityBlockingQueue=newPriorityBlockingQueue<>();
Listentities=newArrayList<>();
for(inti=0;inewEntity(i,"entity"+i);
entities.add(entity);
priorityBlockingQueue.offer(entity);
}

entities.get(num-1).setFlag(true);
intsize=entities.size();
for(inti=0;itry{
priorityBlockingQueue.take();
}catch(Exceptione){
e.printStackTrace();
}
}
}

執行結果如下：

java.lang.RuntimeException:TestException
atPriorityBlockingQueueTest$Entity.compareTo(PriorityBlockingQueueTest.java:31)
atPriorityBlockingQueueTest$Entity.compareTo(PriorityBlockingQueueTest.java:8)
atjava.util.concurrent.PriorityBlockingQueue.siftDownComparable(PriorityBlockingQueue.java:404)
atjava.util.concurrent.PriorityBlockingQueue.dequeue(PriorityBlockingQueue.java:333)
atjava.util.concurrent.PriorityBlockingQueue.take(PriorityBlockingQueue.java:548)
atPriorityBlockingQueueTest.main(PriorityBlockingQueueTest.java:71)
java.lang.NullPointerException
atjava.util.concurrent.PriorityBlockingQueue.siftDownComparable(PriorityBlockingQueue.java:404)
atjava.util.concurrent.PriorityBlockingQueue.dequeue(PriorityBlockingQueue.java:333)
atjava.util.concurrent.PriorityBlockingQueue.take(PriorityBlockingQueue.java:548)
atPriorityBlockingQueueTest.main(PriorityBlockingQueueTest.java:71)

規避方案

可以通過以下兩種方法規避：

在take方法出現NPE時，清除隊列元素，將未處理的元素重新進入隊列；
在 Comparable#compareTo 或 Comparator#compare 方法中做好異常處理，對異常情況進行默認操作；

建議使用后者。

案例引申

使用PriorityBlockingQueue作為緩存隊列來創建線程池時，使用submit提交任務會出現 java.lang.ClassCastException: java.util.concurrent.FutureTask cannot be cast to 異常，而使用execute沒有問題。

觀察submit源碼可以發現在submit內部代碼會將Runable封裝成RunnableFuture對象，然后調用execute提交任務。

publicFuturesubmit(Runnabletask){
if(task==null)thrownewNullPointerException();
RunnableFutureftask=newTaskFor(task,null);
execute(ftask);
returnftask;
}

以Comparable為例，任務入隊列時，最終會調用siftUpComparable方法。該方法第一步將RunnableFuture強轉為Comparable類型，而RunnableFuture類未實現Comparable接口，進而拋出ClassCastException異常。

publicbooleanoffer(Ee){
if(e==null)
thrownewNullPointerException();
finalReentrantLocklock=this.lock;
lock.lock();
intn,cap;
Object[]array;
while((n=size)>=(cap=(array=queue).length))
tryGrow(array,cap);
try{
ComparatorsuperE>cmp=comparator;
if(cmp==null)
siftUpComparable(n,e,array);
else
siftUpUsingComparator(n,e,array,cmp);
size=n+1;
notEmpty.signal();
}finally{
lock.unlock();
}
returntrue;
}

privatestaticvoidsiftUpComparable(intk,Tx,Object[]array){
ComparablesuperT>key=(ComparablesuperT>)x;
while(k>0){
intparent=(k-1)>>>1;
Objecte=array[parent];
if(key.compareTo((T)e)>=0)
break;
array[k]=e;
k=parent;
}
array[k]=key;
}