java線程並發blockingqueue類應用示例

假如BlockingQueue是滿的任何試圖往裡存器械的操作也會被阻斷進入期待狀況，直到BlockingQueue裡有新的空間才會被叫醒持續操作。

BlockingQueue供給的辦法重要有：

add(anObject): 把anObject加到BlockingQueue裡，假如BlockingQueue可以包容前往true，不然拋出IllegalStateException異常。
offer(anObject)：把anObject加到BlockingQueue裡，假如BlockingQueue可以包容前往true，不然前往false。
put(anObject)：把anObject加到BlockingQueue裡，假如BlockingQueue沒有空間，挪用此辦法的線程被阻斷直到BlockingQueue裡有新的空間再持續。
poll(time)：掏出BlockingQueue裡排在首位的對象，若不克不及立刻掏出可等time參數劃定的時光。取不到時前往null。
take()：掏出BlockingQueue裡排在首位的對象，若BlockingQueue為空，阻斷進入期待狀況直到BlockingQueue有新的對象被參加為止。

依據分歧的須要BlockingQueue有4種詳細完成：

（1）ArrayBlockingQueue：劃定年夜小的BlockingQueue，其結構函數必需帶一個int參數來指明其年夜小。其所含的對象是以FIFO（先入先出）次序排序的。
（2）LinkedBlockingQueue：年夜小不定的BlockingQueue，若其結構函數帶一個劃定年夜小的參數，生成的BlockingQueue有年夜小限制，
若不帶年夜小參數，所生成的BlockingQueue的年夜小由Integer.MAX_VALUE來決議。其所含的對象是以FIFO（先入先出）次序排序的。
LinkedBlockingQueue和ArrayBlockingQueue比擬起來，它們面前所用的數據構造紛歧樣，
招致LinkedBlockingQueue的數據吞吐量要年夜於ArrayBlockingQueue，但在線程數目很年夜時其機能的可預感性低於ArrayBlockingQueue。
（3）PriorityBlockingQueue：相似於LinkedBlockingQueue，但其所含對象的排序不是FIFO，而是根據對象的天然排序次序或許是結構函數所帶的Comparator決議的次序。
（4）SynchronousQueue：特別的BlockingQueue，對其的操作必需是放和取瓜代完成的。

package com.yao;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BlockingQueueTest {

 /**
 界說裝蘋果的籃子
  */
 public static class Basket{
  // 籃子，可以或許包容3個蘋果
  BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);

  // 臨盆蘋果，放入籃子
  public void produce() throws InterruptedException{
   // put辦法放入一個蘋果，若basket滿了，比及basket有地位
   basket.put("An apple");
  }
  // 花費蘋果，從籃子中取走
  public String consume() throws InterruptedException{
   // get辦法掏出一個蘋果，若basket為空，比及basket有蘋果為止
   String apple = basket.take();
   return apple;
  }

  public int getAppleNumber(){
   return basket.size();
  }

 }
 //　測試辦法
 public static void testBasket() {
  // 樹立一個裝蘋果的籃子
  final Basket basket = new Basket();
  // 界說蘋果臨盆者
  class Producer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 臨盆蘋果
      System.out.println("臨盆者預備臨盆蘋果："
        + System.currentTimeMillis());
      basket.produce();
      System.out.println("臨盆者臨盆蘋果終了："
        + System.currentTimeMillis());
      System.out.println("臨盆完後有蘋果："+basket.getAppleNumber()+"個");
      // 休眠300ms
      Thread.sleep(300);
     }
    } catch (InterruptedException ex) {
    }
   }
  }
  // 界說蘋果花費者
  class Consumer implements Runnable {
   public void run() {
    try {
     while (true) {
      // 花費蘋果
      System.out.println("花費者預備花費蘋果："
        + System.currentTimeMillis());
      basket.consume();
      System.out.println("花費者花費蘋果終了："
        + System.currentTimeMillis());
      System.out.println("花費完後有蘋果："+basket.getAppleNumber()+"個");
      // 休眠1000ms
      Thread.sleep(1000);
     }
    } catch (InterruptedException ex) {
    }
   }
  }

  ExecutorService service = Executors.newCachedThreadPool();
  Producer producer = new Producer();
  Consumer consumer = new Consumer();
  service.submit(producer);
  service.submit(consumer);
  // 法式運轉10s後，一切義務停滯
  try {
   Thread.sleep(10000);
  } catch (InterruptedException e) {
  }
  service.shutdownNow();
 }

 public static void main(String[] args) {
  BlockingQueueTest.testBasket();
 }
}