CountDownLatch学习

<pre code_snippet_id="569358" snippet_file_name="blog_20150417_1_1404918" name="code" class="java">CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行

</pre><pre code_snippet_id="569358" snippet_file_name="blog_20150417_3_2248647" name="code" class="java">

package com.sgcc.uds.search.mq;

import java.util.concurrent.CountDownLatch;

/**
 * CountDownlatch,是一种Sychronizer，它可以延迟线程的进度直到线程的进度到线程到达终止状态。
 
它本身而言是Java并发包中非常有用的一个类，它可以让某些任务完成以后再继续运行下面的内容，
每个任务本身执行完毕后让计数器减一，直到计数器清零后，以下的内容才可以继续运行，否则将阻塞等待。
 
想了一下，这个场景非常适合用于项目中这样的场景： 我们有个项目，它需要三个第三方的API，
并把结果拿到，在一个线程中顺序去拿结果没有问题，但是这里这三个任务是非常耗时的操作，
如果顺序获取性能非常差，因此可以考虑用三个线程，当三个线程拿到结果后才继续主线程的工作，
等三个线程运行结束后，由主线程去取子线程运行的结果。 这里有个很重要的前提：我们的系统运行在4个cpu的server上，
这样多线程才能体现性能，JVM会分配这些线程尽量运行在不同的cpu上。
 * @author Administrator
 *
 */
public class CountDownLatchSample {
    
    public static void main(String[] args) {
        String[] strs = getResult();
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        
    }
    
    public static String[] getResult(){
        String[] strs = new String[3];
        CountDownLatch countDownLatch = new CountDownLatch(3);
        Work1 work1 = new Work1(countDownLatch,strs[0]);
        Work2 work2 = new Work2(countDownLatch,strs[1]);
        Work3 work3 = new Work3(countDownLatch,strs[2]);
        work1.start();
        work2.start();
        work3.start();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        strs[0] = work1.str1;
        strs[1] = work2.str2;
        strs[2] = work3.str3;
        return strs;
    }
}

class Work1 extends Thread{
    public String str1;
    public CountDownLatch latch1;
    public Work1(CountDownLatch latch1,String str1){
        this.latch1 = latch1;
        this.str1 = str1;
    }
    
    public void run(){
        str1="work1";
        latch1.countDown();
    }
}

class Work2 extends Thread{
    public String str2;
    public CountDownLatch latch2;
    public Work2(CountDownLatch latch2,String str2){
        this.latch2 = latch2;
        this.str2 = str2;
    }
    
    public void run(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        str2="work2";
        latch2.countDown();
    }
}

class Work3 extends Thread{
    public String str3;
    public CountDownLatch latch3;
    public Work3(CountDownLatch latch3,String str3){
        this.latch3 = latch3;
        this.str3 = str3;
    }
    
    public void run(){
        try {
			Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        str3="work3";
        latch3.countDown();
    }
}

package com.sgcc.uds.search.mq;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;

public class CountDownLatchWorkerDemo {
	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", 5000, 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();
			}
		}
	}

}

package com.sgcc.uds.search.mq;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 
 * @author Administrator
 *该程序用来模拟发送命令与执行命令，主线程代表指挥官，新建3个线程代表战士，战士一直等待着指挥官下达命令，
 *若指挥官没有下达命令，则战士们都必须等待。一旦命令下达，战士们都去执行自己的任务，指挥官处于等待状态，
 *战士们任务执行完毕则报告给指挥官，指挥官则结束等待。
 */
public class CountdownLatchOrderTest {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool(); //创建一个线程池
        final CountDownLatch cdOrder = new CountDownLatch(1);//指挥官的命令，设置为1，指挥官一下达命令，则cutDown,变为0，战士们执行任务
        final CountDownLatch cdAnswer = new CountDownLatch(3);//因为有三个战士，所以初始值为3，每一个战士执行任务完毕则cutDown一次，当三个都执行完毕，变为0，则指挥官停止等待。        
        for(int i=0;i<3;i++){
            Runnable runnable = new Runnable(){
                    public void run(){
                    try {
                        System.out.println("线程" + Thread.currentThread().getName() + 
                                "正准备接受命令");                        
                        cdOrder.await(); //战士们都处于等待命令状态
                        System.out.println("线程" + Thread.currentThread().getName() + 
                        "已接受命令");                                
                        Thread.sleep((long)(Math.random()*10000));    
                        System.out.println("线程" + Thread.currentThread().getName() + 
                                "回应命令处理结果");                        
                        cdAnswer.countDown(); //任务执行完毕，返回给指挥官，cdAnswer减1。                    
                    } catch (Exception e) {
                        e.printStackTrace();
                    }                
                }
            };
            service.execute(runnable);//为线程池添加任务
        }        
        try {
            Thread.sleep((long)(Math.random()*10000));
        
            System.out.println("线程" + Thread.currentThread().getName() + 
                    "即将发布命令");                        
            cdOrder.countDown(); //发送命令，cdOrder减1，处于等待的战士们停止等待转去执行任务。
            System.out.println("线程" + Thread.currentThread().getName() + 
            "已发送命令，正在等待结果");    
            cdAnswer.await(); //命令发送后指挥官处于等待状态，一旦cdAnswer为0时停止等待继续往下执行
            System.out.println("线程" + Thread.currentThread().getName() + 
            "已收到所有响应结果");    
        } catch (Exception e) {
            e.printStackTrace();
        }                
        service.shutdown(); //任务结束，停止线程池的所有线程

    }
}

package com.sgcc.uds.search.mq;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 一个CountDouwnLatch实例是不能重复使用的，也就是说它是一次性的，
//锁一经被打开就不能再关闭使用了，如果想重复使用，请考虑使用CyclicBarrier。
public class CountDownLatch100Test {

    // 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。
    public static void main(String[] args) throws InterruptedException {

        // 开始的倒数锁 
        final CountDownLatch begin = new CountDownLatch(1);  

        // 结束的倒数锁 
        final CountDownLatch end = new CountDownLatch(10);  

        // 十名选手 
        final ExecutorService exec = Executors.newFixedThreadPool(10);  

        for (int index = 0; index < 10; index++) {
            final int NO = index + 1;  
            Runnable run = new Runnable() {
                public void run() {  
                    try {  
                        // 如果当前计数为零，则此方法立即返回。
                        // 等待
                        begin.await();  
                        Thread.sleep((long) (Math.random() * 10000));  
                        System.out.println("No." + NO + " arrived");  
                    } catch (InterruptedException e) {  
                    } finally {  
                        // 每个选手到达终点时，end就减一
                        end.countDown();
                    }  
                }  
            };  
            exec.submit(run);
        }  
        System.out.println("Game Start");  
        // begin减一，开始游戏
        begin.countDown();  
        // 等待end变为0，即所有选手到达终点
        end.await();  
        System.out.println("Game Over");  
        exec.shutdown();  
    }
}