java实现简单的并行计算框架

2019独角兽企业重金招聘Python工程师标准>>>

最近的工作需要统计一些复杂的报表，为了提高效率，想用多线程按列去统计，但要在所有线程完成统计任务后，将结果汇总，然后统一展现。

先设计一个执行器，负责任务的派发和汇总

package com.boco.concurrent;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 并行计算框架
 * @author xueliang
 * 例子：
 * 创建10个线程,true表示需要汇总结果
 * Executer e = new Executer(10, true);
 * for(...){
 * 	  Job<Result> job = new MyJob();
 *    //Job<List<Result>> job = new MyJob();
 * 	  e.fork(job);//将任务派发给executer
 * }
 * 将结果汇总后返回
 * List<Result> obj = e.join();
 * e.shutdown();
 */
public class Executer {
	// 存储任务的执行结果
	private List<Future> futres = new ArrayList<Future>();
	// 条件队列锁,以及线程计数器
	private Lock lock = null;
	// 线程池
	private ExecutorService pool = null;
	
	/**
	 * 创建并发执行器
	 * @param threadPoolSize 执行任务的线程数
	 * @param isJoin 是否需要将任务结果汇总
	 */
	public Executer(int threadPoolSize, boolean isJoin) {
		pool = Executors.newFixedThreadPool(threadPoolSize);
		lock = new Lock(threadPoolSize);
		lock.isJoin = isJoin;
	}

	/**
	 * 任务派发
	 * @param <E> 任务返回值类型
	 * @param job
	 */
	public <E> void fork(Job<E> job) {
		// 设置同步锁
		job.setLock(lock);
		// 获取许可，如果没有可用线程许可，则一直等待
		lock.semaphore.acquireUninterruptibly();
		// 将任务派发给线程池去执行
		Future future = pool.submit(job);
		// 判断是否需要汇总结果
		if(lock.isJoin){
			futres.add(future);
			// 增加线程数
			synchronized (lock) {
				lock.thread_count++;
			}
		}
	}

	/**
	 * 汇集任务结果
	 * @param <E>
	 * @return E类型的集合
	 */
	public <E> List<E> join() {
		synchronized (lock) {
			while (lock.thread_count > 0) {// 检查线程数，如果为0，则表示所有任务处理完成
				// System.out.println("threadCount: "+THREAD_COUNT);
				try {
					// 如果任务没有全部完成，则挂起。等待完成的任务给予通知
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		List list = new ArrayList();
		// 取出每个任务的处理结果，汇总后返回
		for (Future future : futres) {
			try {
				// 因为任务都已经完成，这里直接get
				Object result = future.get();
				if (result != null) {
					if (result instanceof Collection)
						list.addAll((Collection) result);
					else
						list.add(result);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return list;
	}
	
	/**
	 * 关闭所有任务
	 */
	public void shutdown(){
		if(pool != null)
			pool.shutdown();
	}
}

一个抽象的任务接口

package com.boco.concurrent;

import java.util.concurrent.Callable;

/**
 * @author xueliang
 *
 * @param <T> 任务的执行结果类型
 */
public abstract class Job<E> implements Callable<E> {

	// 锁
	private Lock lock = null;

	void setLock(Lock lock) {
		this.lock = lock;
	}

	public E call() throws Exception {
		E result = null;
		try {
			result = this.execute();// 执行子类具体任务
		} catch (Exception e) {
			e.printStackTrace();
		}
		//判断是否需要将结果汇总
		if(lock.isJoin){
			synchronized (lock) {
				// 处理完业务后，任务结束，递减线程数，同时唤醒主线程
				lock.thread_count--;
				lock.notifyAll();
			}
		}
		lock.semaphore.release();//释放线程使用许可
		return result;
	}

	/**
	 * 业务处理函数
	 */
	public abstract E execute();

}

一个共享锁，负责线程之间的协调

package com.boco.concurrent;

import java.util.concurrent.Semaphore;

class Lock {
	/**
	 * 任务是否需要汇总
	 */
	boolean isJoin = false;

	/**
	 * 计数正在执行的线程数
	 */
	int thread_count;
	
	/**
	 * 线程使用许可证
	 */
	Semaphore semaphore;
	
	Lock(int threadPoolSize){
		semaphore = new Semaphore(threadPoolSize);;
	}

}

测试一下，先实现一个任务，以及任务需要的执行结果

package com.boco.test;

import com.boco.concurrent.Job;


public class MyJob extends Job<Result> {
	int record = 0;
	
	public MyJob(int record){
		this.record = record;
	}

	public Result execute() {
        System.out.println("running thread id = "+Thread.currentThread().getId());  
        //模拟业务需要处理几秒钟.  
        try {Thread.sleep(100 * Thread.currentThread().getId());} catch (InterruptedException e) {}  
        Result r = new Result();
        r.setCode(record * Thread.currentThread().getId());
		return r;
	}

	

}

package com.boco.test;

public final class Result {
	
	private long code;

	public long getCode() {
		return code;
	}

	public void setCode(long code) {
		this.code = code;
	}

}

 测试类

package com.boco.test;

import java.util.List;

import com.boco.concurrent.Executer;

public class Test {
	public static void main(String[] args) {
		Executer e = new Executer(50,true);
		long start = System.currentTimeMillis();
		for(int i = 0; i < 100; i++){
			e.fork(new MyJob(i));
		}
		List<Result> l = e.join();
		for (Result result : l) {
			System.out.println(result + " \t " + result.getCode());
		}
		long time = System.currentTimeMillis() - start;
		System.out.println("result size: " + l.size() + " time: " + time);
		e.shutdown();
	}
}

执行结果片段

com.boco.test.Result@17fa65e 	 1950
com.boco.test.Result@18385e3 	 684
com.boco.test.Result@1cb25f1 	 2079
com.boco.test.Result@2808b3 	 1092
com.boco.test.Result@535b58 	 2212
com.boco.test.Result@922804 	 2320
com.boco.test.Result@1815859 	 1215
com.boco.test.Result@cf40f5 	 820
com.boco.test.Result@b1c260 	 2490
com.boco.test.Result@503429 	 2604
com.boco.test.Result@1908ca1 	 680
com.boco.test.Result@100ab23 	 1376
com.boco.test.Result@e3b895 	 2784
com.boco.test.Result@6b7920 	 2904
com.boco.test.Result@1dd46f7 	 979
com.boco.test.Result@5e3974 	 1530
com.boco.test.Result@df503 	 3094
com.boco.test.Result@50d89c 	 3220
com.boco.test.Result@1bd0dd4 	 837
com.boco.test.Result@d70d7a 	 1128
com.boco.test.Result@b5f53a 	 1710
com.boco.test.Result@1f6f0bf 	 3456
com.boco.test.Result@137c60d 	 3589
com.boco.test.Result@ab853b 	 1862
com.boco.test.Result@b82368 	 3762
result size: 100 time: 7620

去掉休眠时间，调大任务数为100000，线程为10个后，CPU利用率

从上图来看，windows下java的多线程技术还是可以利用多核的。

不知道在多cpu下能否利用cpu资源。

 

转载于:https://my.oschina.net/shenxueliang/blog/136488