日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網營銷解決方案
帶你見識一下，Java中的方法爆炸！

本文轉載自微信公眾號「小姐姐味道」，作者小姐姐養(yǎng)的狗。轉載本文請聯(lián)系小姐姐味道公眾號。

創(chuàng)新互聯(lián)建站從2013年創(chuàng)立，是專業(yè)互聯(lián)網技術服務公司，擁有項目網站設計制作、做網站網站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元無棣做網站,已為上家服務,為無棣各地企業(yè)和個人服務,聯(lián)系電話:13518219792

要想了解Java的API有多變態(tài)，就不得不提一下隊列這個接口，許多工作多年的人，依然是對此非常迷惑。雖然隊列是計算機算法中的一個基本結構，但它并不僅僅只有add這個方法。

讀完本文，再看到add、offer、put，不要再犯暈了！

1. 一段小代碼

猜猜下面的代碼會輸出啥？

 
 
 
    
  
  
  
  1. void run(Callable c){ 
  
  
  
  2.     try{ 
    3. 
  
  
  
  3.         System.out.println(c.call()); 
    4. 
  
  
  
  4.     }catch (Exception ex){ 
    5. 
  
  
  
  5.         System.out.println(ex); 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. void testSynchronousQueue(){ 
    9. 
  
  
  
  9.     Queue q1 = new SynchronousQueue(); 
    10. 
  
  
  
  10.     run(()-> q1.add(1)); 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.     Queue q2 = new SynchronousQueue(); 
    13. 
  
  
  
  13.     run(()-> q1.offer(1)); 
    14. 
  
  
  
  14. } 
    15. 
 
 
 
    實在是讓人非常失望，兩次執(zhí)行都失敗了。
     
 
 
      
  
  
  
    1. java.lang.IllegalStateException: Queue full 
      2. 
  
  
  
    2. false 
      3. 
 
 
 
    第一次，使用add方法，程序拋出了異常，表示隊列滿了；第二次，程序返回了false，證明添加失敗。既然無法向隊列中添加元素，又沒有指定隊列大小的地方。那這個隊列，有什么鳥用！
    2. Queue的方法
    

    在了解這個隊列的使用之前，我們來看一下Queue接口所定義的方法。
      

    • add(E e) 插入一個元素到隊列的尾部。如果無法插入，則拋出異常
      • 

    • offer(E e) 插入一個元素到隊列的為
      • 

    • E remove() 從隊列頭移除一個元素，如果隊列為空，則拋出異常
      • 

    • E poll() 從隊列頭移除一個元素，如果隊列為空，則返回null
      • 

    • E element() 查看對頭元素，如果隊列為空，則拋出異常
      • 

    • E peek() 查看對頭元素，如果隊列為空，則返回null
      • 

    

    可以看到，對隊列的基本操作，只有三個：插入新元素、查看隊頭、隊頭出對。根據是否拋出異常，又分為了兩類。3x2=6，共6個方法。
    喜歡刷題的同學，常用的肯定是offer、poll、peek，這樣可以免去惱人的異常處理。平常的編碼，也推薦使用非異常的api，但Java為什么提供了兩套方法，來供我們使用呢？
    原因就是，Queue接口繼承了Collection接口，而add和remove等方法，是屬于Collection接口的，Queue不得不實現一套。事實上，add方法直接調用了offer方法，為什么多出這么一套api來，真的是個謎。
     
 
 
      
  
  
  
    1. public boolean add(E e) { 
      2. 
  
  
  
    2. if (offer(e)) 
      3. 
  
  
  
    3.    return true; 
      4. 
  
  
  
    4. else 
      5. 
  
  
  
    5.    throw new IllegalStateException("Queue full"); 
      6. 
  
  
  
    6. } 
      7. 
 
 
 
    不拋異常，就容易被遺忘處理，確實是個比較牽強的原因。就憑這，能讓人在這么重要的基礎類庫里面，創(chuàng)造出這么多不同名稱的方法么？
    3. Put和Take
    

    相比較上面讓人糾結的add和offer，put和take方法就確實有用了。但put和take是不屬于Queue接口的，它的歸屬是BlockingQueue。不好意思，一不小心就跳到concurrent包了。
    put和take，意味著阻塞。如果操作不成功，它就一直在那里阻塞。想要它們能夠正常運行下去，就需要有多個線程的配合。下面的代碼會往隊列里發(fā)送一個1，然后take方法拿出它，進行打印。
     
 
 
      
  
  
  
    1. void testBlockingSynchronousQueue() throws InterruptedException { 
      2. 
  
  
  
    2.     BlockingQueue q1 = new SynchronousQueue(); 
      3. 
  
  
  
    3.     new Thread(()-> { 
      4. 
  
  
  
    4.         try { 
      5. 
  
  
  
    5.             q1.put(1); 
      6. 
  
  
  
    6.         } catch (InterruptedException e) { 
      7. 
  
  
  
    7.             e.printStackTrace(); 
      8. 
  
  
  
    8.         } 
      9. 
  
  
  
    9.     }).start(); 
      10. 
  
  
  
    10.     new Thread(()-> { 
      11. 
  
  
  
    11.         try { 
      12. 
  
  
  
    12.             System.out.println(q1.take()); 
      13. 
  
  
  
    13.         } catch (InterruptedException e) { 
      14. 
  
  
  
    14.             e.printStackTrace(); 
      15. 
  
  
  
    15.         } 
      16. 
  
  
  
    16.     }).start(); 
      17. 
  
  
  
    17. } 
      18. 
 
 
 
    所以，我們來看一下這對方法。
      

    • put(E e) 插入元素，如果隊列滿了，它會一直阻塞等待
      • 

    • E take() 獲取隊頭元素，如果隊列為空則一直等待
      • 

    

    可以看到put和take配合起來，很容易實現一個線程安全的生產者消費者模型。相比較使用Queue的接口方法，我們只能通過死循環(huán)去檢測，這樣阻塞的方式就特別節(jié)省資源。
    但是還沒完。阻塞的take和put方法，只能被interrupt，如何讓程序阻塞等待一段時間，然后恢復運行呢？那就只有加入一個帶時間戳的阻塞方法。
    BlockingQueue選擇了offer和poll方法，而不是take和put，咱也搞不懂到底是為什么。
      

    • E poll(long timeout, TimeUnit unit)
      • 

    • boolean offer(E e, long timeout, TimeUnit unit) 依然是有返回值的
    4. 你以為這樣就完了？
    

    你以為這樣就完了？并沒有。我們需要把目光投向LinkedList，傳說中幾行代碼實現LRU緩存的類。
    ArrayList是一個比較純凈的List，僅僅實現了List接口，但LinkedList就胃口大了一些。由于API設計者，盡最大可能想讓這個鏈表功能更強大一些，它繼承了Deque接口。由于Deque繼承了Queue，所以這個鏈表不僅僅是個隊列，還是個雙向隊列。
    所以，它們又多了一堆API，分別來描述到底是在隊頭還是隊尾進行操作。
      

    • addFirst 操作隊頭，加入元素
      • 

    • addLast 操作隊尾，加入元素
      • 

    • offerFirst 操作隊頭，加入元素
      • 

    • offerLast 操作隊尾，加入元素
      • 

    • removeFirst 操作隊頭，刪除元素
      • 

    • removeLast 操作隊尾，刪除元素
      • 

    • pollFirst 操作隊頭，刪除元素
      • 

    • pollLast 操作隊尾，刪除元素
      • 

    • getFirst 獲取隊頭元素，類似element。TMD，這里為什么不用element？
      • 

    • getLast 獲取隊尾元素
      • 

    • peekFirst 獲取隊頭元素
      • 

    • peekLast 獲取隊尾元素
      • 

    

    當然，這里還有pop和push，pop=removeFirst，push=addFirst。//建議不要用，太難記了。
    很好很好，由于有了頭和尾的概念，api的大小變成了3x2x2=12個！加上原來的那6個，共18個（直接把pop和push忽略）。
    你要說，怎么沒有take和put這種阻塞的方法啊。原因就是LinkedList并不是并發(fā)的集合，你要找的功能，在LinkedBlockingDeque中，肯定會有takeFirst、takeLast、putLast、putFirst等。
    5. 隊列大小
    

    反過頭來再看我們剛開始的SynchronousQueue，為什么無論向里面添加元素，還是提取元素，都會返回失?。克娜萘康降资嵌嗌?？
    這是一個非常奇葩的類，它的內部容量是0！已經被硬編碼進代碼里了。
     
 
 
      
  
  
  
    1. public int size() { 
      2. 
  
  
  
    2.    return 0; 
      3. 
  
  
  
    3. } 
      4. 
 
 
 
    它僅僅建立了一個通道，一旦有生產，消費者就能立馬拿到它，它本身是不不存任何數據的。Executors.newCachedThreadPool()就使用了SynchronousQueue。
    常用的LinkedBlockingQueue、ArrayBlockingQueue，都是有界的。
    但這里還有一個比較奇葩的類，那就是ConcurrentLinkedQueue，從名字可以看出來，它并不是一個阻塞的并發(fā)類，所以并沒有take和put等方法。另外，它是無界的，使用時要特別小心。你或許說，我每次判斷它的size()方法來看一下是否越界不就行了。
     
 
 
      
  
  
  
    1. public int size() { 
      2. 
  
  
  
    2.     int count = 0; 
      3. 
  
  
  
    3.     for (Node p = first(); p != null; p = succ(p)) 
      4. 
  
  
  
    4.         if (p.item != null) 
      5. 
  
  
  
    5.            // Collection.size() spec says to max out 
      6. 
  
  
  
    6.            if (++count == Integer.MAX_VALUE) 
      7. 
  
  
  
    7.                 break; 
      8. 
  
  
  
    8.     return count; 
      9. 
  
  
  
    9. } 
      10. 
 
 
 
    如上代碼所示，這就是比較坑的地方，size方法，并不是O(1)時間級別的。xjjdog就曾在上面吃過大虧，最后還是不敢再亂用了。
    End
    

    從上面的描述可以看出來。對于一個隊列，有三套接口：插入、彈出、檢測；根據是否拋異常，又分為兩套，一套會拋出異常，另外一套直接返回值，刷題黨自然喜歡后者了；如果再加上雙向的隊列，就需要再區(qū)分對頭隊尾；如果是阻塞隊列，還要再加上一個維度。
    所以，對于一個阻塞的雙向隊列，它的基本操作方法有：(3[基本]x2[異常與返回值]+4[阻塞加超時])x3[隊頭隊尾]=5x2x3=30個方法，這就是王者LinkedBlockingDeque。
    這樣的代碼，我反正是寫吐了。你呢？
    作者簡介：小姐姐味道 (xjjdog)，一個不允許程序員走彎路的公眾號。聚焦基礎架構和Linux。十年架構，日百億流量，與你探討高并發(fā)世界，給你不一樣的味道。我的個人微信xjjdog0，歡迎添加好友，進一步交流。
                                                    
    
                                                分享名稱：帶你見識一下，Java中的方法爆炸！                                                
    
                                                分享網址：http://www.5511xx.com/article/djpjiee.html