java同步工具类之--

package com.test;
/**
 * 今天听同事讲了一个需求，他需要启动多个线程把接口数据分批导入目标，要求
 * 每次执行的时候必须保证前一次任务已结束,处理这个需求的方式有很多种，其实质即
 * 线程间同步问题，正好这两天我也在关注线程同步相关的东东，jdk提供了不少的线程
 * 同步工具类，CountDownLatch：一个同步辅助类，在完成一组正在其他线程中执行的
 * 操作之前，它允许一个或多个线程一直等待。 
 * 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，
 * await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。
 * 这种现象只出现一次——计数无法被重置（这点很重要哦）。如果需要重置计数，请考虑使用 CyclicBarrier。
 * 下面是一个简单的例子来模拟该需求，当然可能因为为了模拟场景，会有一些不合理的地方，这里主要阐述
 * CountDownLatch同步,关于CountDownLatch的源码将在后面来分析，其主要涉及AbstractQueuedSynchronizer
 * 这个类，他的类容相对比较复杂
 * **/

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class Driver {
	static List<Integer> strList = null;
	int k = 0;
	static {
		//模拟数据
		strList = new ArrayList<Integer>();
		for (int i = 0; i < 50; i++) {
			strList.add(i);
		}
	}

	public static void main(String args[]) {
		boolean isEnd = true;
		//为了验证正确性，只执行20次
		int count=0;
		Driver d = new Driver();
		while (isEnd && strList.size() > 0&&count<20) {
			CountDownLatch startSignal = new CountDownLatch(1);
			final CountDownLatch doneSignal = new CountDownLatch(5);
			for (int i = 0; i < 5; ++i)
			{
				new Thread(d.new Worker(startSignal, doneSignal,i)).start();
			}
			//计数减1 子线程Worker可以执行
			startSignal.countDown(); 
			try {
				new Thread(new Runnable() {
					Random r = new Random();
					@Override
					public void run() {
						try {
							//主线程阻塞 知道所有子线程将doneSignal清零
							doneSignal.await();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						while(strList.size()<=0){
							int pos = r.nextInt(1000);
							strList.clear();
							for (int i = pos; i < pos + 50; i++) {
								strList.add(i);
							}
						}
					}
				}).start();
				isEnd = true;
			} catch (Exception e) {
				e.printStackTrace();
			}
			count++;
		}
	}

	class Worker implements Runnable {
		private final CountDownLatch startSignal;
		private final CountDownLatch doneSignal;
		private int i;

		Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int i) {
			this.startSignal = startSignal;
			this.doneSignal = doneSignal;
			this.i=i;
			
		}

		public void run() {
			try {
				// 等待主线程执行countDown
				startSignal.await();
				doWork();
				//计数减1
				doneSignal.countDown();
			} catch (InterruptedException ex) {
			} // return;
		}

		void doWork() {
			synchronized (strList) {
				int start=(i)*(50/5);
				int end=(i+1)*(50/5);
				for (int i = start; i < end; i++) {
					System.out.println(strList.get(i) + "---" + "已被删除");
				}
			}
		}
	}
}