最近的工作需要统计一些复杂的报表,为了提高效率,想用多线程按列去统计,但要在所有线程完成统计任务后,将结果汇总,然后统一展现。
先设计一个执行器,负责任务的派发和汇总
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.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.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.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;
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;
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();
}
}
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
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资源。