Java 阻塞執行緒用法
CountDownLatch
首先先說明CountDownLatch輔助類
CountDownLatch，一個同步輔助類，在完成一組正在其他執行緒中執行的操作之前，它允許一個或多個執行緒一直等待。
主要方法
public CountDownLatch(int count);//構造方法引數指定了計數的次數
public void countDown();//當前執行緒呼叫此方法，則計數減一1
public void await() throws InterruptedException//呼叫此方法會一直阻塞當前執行緒，直到計時器的值為0
列子：
public class CountDownLatchDemo {
final static 併發佇列ConcurrentLinkedQueue和阻塞佇列LinkedBlockingQueue用法
在Java多執行緒應用中，佇列的使用率很高，多數生產消費模型的首選資料結構就是佇列(先進先出)。Java提供的執行緒安全的Queue可以分為阻塞佇列和非阻塞佇列，其中阻塞佇列的典型例子是BlockingQueue，非阻塞佇列的典型例子是ConcurrentLinkedQueue，在實際應用中要根據實際需要選用阻塞佇列或者非阻塞佇列。
注：什麼叫執行緒安全？這個首先要明確。執行緒安全就是說多執行緒訪問同一程式碼，不會產生不確定的結果。
並行和併發區別
1、並行是指兩者同時執行一件事，比如賽跑，兩個人都在不停的往前跑；
2、併發是指資源有限的情況下，兩者交替輪流使用資源，比如一段路(單核CPU資源)同時只能過一個人，A走一段後，讓給B，B用完繼續給A ，交替使用，目的是提高效率
LinkedBlockingQueue
由於LinkedBlockingQueue實現是執行緒安全的，實現了先進先出等特性，是作為生產者消費者的首選，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的話，預設最大是Integer.MAX_VALUE，其中主要用到put和take方法，put方法在佇列滿的時候會阻塞直到有佇列成員被消費，take方法在佇列空的時候會阻塞，直到有佇列成員被放進來。
package cn.thread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 多執行緒模擬實現生產者／消費者模型
*
* @author 林計欽
* @version 1.0 2013-7-25 下午05:23:11
*/
public class BlockingQueueTest2 {
/**
*
* 定義裝蘋果的籃子
*
*/
public class Basket {
// 籃子，能夠容納3個蘋果
BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3);
// 生產蘋果，放入籃子
public void produce() throws InterruptedException {
// put方法放入一個蘋果，若basket滿了，等到basket有位置
basket.put("An apple");
}
// 消費蘋果，從籃子中取走
public String consume() throws InterruptedException {
// take方法取出一個蘋果，若basket為空，等到basket有蘋果為止(獲取並移除此佇列的頭部)
return basket.take();
}
}
// 定義蘋果生產者
class Producer implements Runnable {
private String instance;
private Basket basket;
public Producer(String instance, Basket basket) {
this.instance = instance;
this.basket = basket;
}
public void run() {
try {
while (true) {
// 生產蘋果
System.out.println("生產者準備生產蘋果：" + instance);
basket.produce();
System.out.println("!生產者生產蘋果完畢：" + instance);
// 休眠300ms
Thread.sleep(300);
}
} catch (InterruptedException ex) {
System.out.println("Producer Interrupted");
}
}
}
// 定義蘋果消費者
class Consumer implements Runnable {
private String instance;
private Basket basket;
public Consumer(String instance, Basket basket) {
this.instance = instance;
this.basket = basket;
}
public void run() {
try {
while (true) {
// 消費蘋果
System.out.println("消費者準備消費蘋果：" + instance);
System.out.println(basket.consume());
System.out.println("!消費者消費蘋果完畢：" + instance);
// 休眠1000ms
Thread.sleep(1000);
}
} catch (InterruptedException ex) {
System.out.println("Consumer Interrupted");
}
}
}
public static void main(String[] args) {
BlockingQueueTest2 test = new BlockingQueueTest2();
// 建立一個裝蘋果的籃子
Basket basket = test.new Basket();
ExecutorService service = Executors.newCachedThreadPool();
Producer producer = test.new Producer("生產者001", basket);
Producer producer2 = test.new Producer("生產者002", basket);
Consumer consumer = test.new Consumer("消費者001", basket);
service.submit(producer);
service.submit(producer2);
service.submit(consumer);
// 程式執行5s後，所有任務停止
// try {
// Thread.sleep(1000 * 5);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// service.shutdownNow();
}
}ConcurrentLinkedQueue
ConcurrentLinkedQueue是Queue的一個安全實現．Queue中元素按FIFO原則進行排序．採用CAS操作，來保證元素的一致性。
LinkedBlockingQueue是一個執行緒安全的阻塞佇列，它實現了BlockingQueue介面，BlockingQueue介面繼承自java.util.Queue介面，並在這個介面的基礎上增加了take和put方法，這兩個方法正是佇列操作的阻塞版本。
package cn.thread;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ConcurrentLinkedQueueTest {
private static ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();
private static int count = 2; // 執行緒個數
//CountDownLatch，一個同步輔助類，在完成一組正在其他執行緒中執行的操作之前，它允許一個或多個執行緒一直等待。
private static CountDownLatch latch = new CountDownLatch(count);
public static void main(String[] args) throws InterruptedException {
long timeStart = System.currentTimeMillis();
ExecutorService es = Executors.newFixedThreadPool(4);
ConcurrentLinkedQueueTest.offer();
for (int i = 0; i < count; i++) {
es.submit(new Poll());
}
latch.await(); //使得主執行緒(main)阻塞直到latch.countDown()為零才繼續執行
System.out.println("cost time " + (System.currentTimeMillis() - timeStart) + "ms");
es.shutdown();
}
/**
* 生產
*/
public static void offer() {
for (int i = 0; i < 100000; i++) {
queue.offer(i);
}
}
/**
* 消費
*
* @author 林計欽
* @version 1.0 2013-7-25 下午05:32:56
*/
static class Poll implements Runnable {
public void run() {
// while (queue.size()>0) {
while (!queue.isEmpty()) {
System.out.println(queue.poll());
}
latch.countDown();
}
}
}執行結果：
costtime 2360ms
改用while (queue.size()>0)後
執行結果：
cost time 46422ms
結果居然相差那麼大，看了下ConcurrentLinkedQueue的API原來.size()是要遍歷一遍集合的，難怪那麼慢，所以儘量要避免用size而改用isEmpty().