java 并行计算操作实践

package com.common.concurrent;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 
 * 并行计算操作
 * @author zoro
 *
 */
public class Parallel {
	
	private Logger log=LoggerFactory.getLogger(Parallel.class);
	
	/**
	 * 并行计算对象列表
	 */
	private List<ParallelComputing> parallelComputings;

	public void init(){
		if(parallelComputings==null){
			parallelComputings=new ArrayList<Parallel.ParallelComputing>();
		}
	}
	
	private Parallel(){}
	
	/**
	 * 创建并行对象
	 * @return
	 */
	public static Parallel create() {
		Parallel parallel = new Parallel();
		parallel.init();
		return parallel;
	}
	
	/**
	 * 增加并发结算对象
	 * @param parallelComputing
	 */
	public Parallel add(ParallelComputing parallelComputing){
		parallelComputings.add(parallelComputing);
		return this;
	}
	
	/**
	 * 开始执行并行结算
	 * @throws InterruptedException
	 */
	public void doStart() throws InterruptedException {
		/**
		 * 初始化同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
		 */
		final CountDownLatch latch = new CountDownLatch(
				parallelComputings.size());
		/**
		 * 创建一个固定长度的线程池
		 */
		ExecutorService executorService = Executors
				.newFixedThreadPool(parallelComputings.size());

		/**
		 * 循环执行并行任务
		 */
		for (final ParallelComputing computing : parallelComputings) {
			executorService.execute(new Runnable() {
				@Override
				public void run() {

					// 执行核心逻辑
					computing.execute();

					// 线程结束时计数器减1 必须等核心处理逻辑处理完成后才可以减1
					latch.countDown();

					log.info(
							"总共 {} 个线程  线程名 {} 结束. 还有 {} 个线程",
							new Object[] { parallelComputings.size(),
									Thread.currentThread().getName(),
									latch.getCount() });
				}
			});
		}

		latch.await(); // 等待所有子线程执行完 //固定线程池执行完成后 将释放掉资源 退出主进程
		executorService.shutdown();// 并不是终止线程的运行，而是禁止在这个Executor中添加新的任务
	}
	
	/**
	 * 并行计算对象
	 * 
	 * @author zoro
	 * 
	 */
	public static interface ParallelComputing {
		/**
		 * 并行执行方法
		 * 
		 * @param map
		 */
		public void execute();
	}
	
	public static void main(String [] args) throws InterruptedException{
		Parallel.create().add(new ParallelComputing() {
			@Override
			public void execute() {
				System.out.println("---------" + 1 + "---------------");
			}
		}).add(new ParallelComputing() {
			@Override
			public void execute() {
				System.out.println("---------" + 2 + "---------------");
			}
		}).add(new ParallelComputing() {
			@Override
			public void execute() {
				System.out.println("---------" + 3 + "---------------");
			}
		}).add(new ParallelComputing() {
			@Override
			public void execute() {
				System.out.println("---------" + 4 + "---------------");
			}
		}).add(new ParallelComputing() {
			@Override
			public void execute() {
				System.out.println("---------" + 5 + "---------------");
			}
		}).doStart();
	}
}