CountDownLatchjava
首先先說明CountDownLatch輔助類web
CountDownLatch，一個同步輔助類，在完成一組正在其餘線程中執行的操做以前，它容許一個或多個線程一直等待。
主要方法
public CountDownLatch(int count);//構造方法參數指定了計數的次數
public void countDown();//當前線程調用此方法，則計數減一1
public void await() throws InterruptedException//調用此方法會一直阻塞當前線程，直到計時器的值爲0
列子：安全
public class CountDownLatchDemo {
final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch=new CountDownLatch(2);//兩個工人的協做
Worker worker1=new Worker("zhang san", 5000, latch);
Worker worker2=new Worker("li si", 8000, latch);
worker1.start();//
worker2.start();//
latch.await();//等待全部工人完成工做
System.out.println("all work done at "+sdf.format(new Date()));
}
static class Worker extends Thread{
String workerName;
int workTime;
CountDownLatch latch;
public Worker(String workerName ,int workTime ,CountDownLatch latch){
this.workerName=workerName;
this.workTime=workTime;
this.latch=latch;
}
public void run(){
System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
doWork();//工做了
System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
latch.countDown();//工人完成工做，計數器減一
}
private void doWork(){
try {
Thread.sleep(workTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
輸出：
Worker zhang san do work begin at 2011-04-14 11:05:11
Worker li si do work begin at 2011-04-14 11:05:11
Worker zhang san do work complete at 2011-04-14 11:05:16
Worker li si do work complete at 2011-04-14 11:05:19
all work done at 2011-04-14 11:05:19
併發隊列ConcurrentLinkedQueue和阻塞隊列LinkedBlockingQueue用法數據結構
在Java多線程應用中，隊列的使用率很高，多數生產消費模型的首選數據結構就是隊列(先進先出)。Java提供的線程安全的Queue能夠分爲阻塞隊列和非阻塞隊列，其中阻塞隊列的典型例子是BlockingQueue，非阻塞隊列的典型例子是ConcurrentLinkedQueue，在實際應用中要根據實際須要選用阻塞隊列或者非阻塞隊列。多線程
注：什麼叫線程安全？這個首先要明確。線程安全就是說多線程訪問同一代碼，不會產生不肯定的結果。併發
並行和併發區別app
一、並行是指二者同時執行一件事，好比賽跑，兩我的都在不停的往前跑；
二、併發是指資源有限的狀況下，二者交替輪流使用資源，好比一段路(單核CPU資源)同時只能過一我的，A走一段後，讓給B，B用完繼續給A ，交替使用，目的是提升效率svg
LinkedBlockingQueue
因爲LinkedBlockingQueue實現是線程安全的，實現了先進先出等特性，是做爲生產者消費者的首選，LinkedBlockingQueue 能夠指定容量，也能夠不指定，不指定的話，默認最大是Integer.MAX_VALUE，其中主要用到put和take方法，put方法在隊列滿的時候會阻塞直到有隊列成員被消費，take方法在隊列空的時候會阻塞，直到有隊列成員被放進來。this
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方法，這兩個方法正是隊列操做的阻塞版本。spa
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().