Java并发工具类CountDownLatch案例

视频链接：https://pan.baidu.com/s/1cc3ZK0JScIRYmtIi9JfD_g 密码：sqie

源码链接：https://pan.baidu.com/s/1IB3-zeJ26E3Z1GUtMczRnw 密码：bb3a

API链接：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

CountDownLatch：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

下面的案例中使用到两个方法：

void	countDown()            递减锁存器的计数，如果计数到达零，则释放所有等待的线程。

void	await()            使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断

 

案例：10,20,30,33,12,23
           21,12,18,45,11
           23,45,67,78,89
           12,12
   假如一文本中有上述数字，对其进行求和，要求一行数字使用一个线程，之后再进行总体求和 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;


public class Demo {
	
	private int[] nums;
	public  Demo(int line){
		nums = new int[line];
	}
	//每一行求和
	public void calc(String lines ,int index,CountDownLatch cdl){
		String[] ns = lines.split(",");
		int total = 0;
		for(String num :ns){
			total = total+Integer.parseInt(num);
		}
		nums[index] = total;
		System.out.println(Thread.currentThread().getName() + " 执行计算任务... " + lines + " 结果为：" + total);
		//递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
		cdl.countDown();
	}
	//汇总每一行的和
	public void sum(){
		System.out.println("汇总线程开始执行... ");
		int total = 0;
		for(int i=0;i<nums.length;i++){
			total = total+nums[i];
		}		
		System.out.println("最终的结果为：" + total);

	}
	//读文件内容
	public static List<String> readFile(){
		List<String> contents = new ArrayList<String>();
		String line = null;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader("e:\\nums.txt"));
			while((line = br.readLine())!=null){
				contents.add(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			if(br != null){
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		return contents;
	}
	//采取每一行使用线程，并且使用CountDownLatch的await方法， 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断
	public static void main(String[] args){
		final List<String> contents = readFile();
		int lineCount = contents.size();
		final Demo d  = new Demo(lineCount);
		final CountDownLatch cdl = new CountDownLatch(lineCount);
		for(int i=0;i<lineCount;i++){
			final int j = i;
			new Thread(new Runnable(){
				@Override
				public void run() {
					// TODO Auto-generated method stub
					d.calc(contents.get(j), j,cdl);
				}
				
			}).start();
		}
		try {
			cdl.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		d.sum();
	}
}

执行结果效果如下：

Thread-3 执行计算任务... 12,12 结果为：24
Thread-1 执行计算任务... 21,12,18,45,11 结果为：107
Thread-2 执行计算任务... 23,45,67,78,89 结果为：302
Thread-0 执行计算任务... 10,20,30,33,12,23 结果为：128
汇总线程开始执行... 
最终的结果为：561