Fork/Join框架实战
本文介绍了使用Java的Fork/Join框架实现并行计算的方法，包括求和运算及列表处理两个具体案例，并对比了多线程与非多线程方式的性能差异。
fork/join用于计算；排序比较适用
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class ForkJoinCalculator extends RecursiveTask<Long>{
/**
*
*/
private static final long serialVersionUID = 1L;
private long start;
private long end;
public ForkJoinCalculator(long start, long end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if (end - start <= 1000) {
long sum = 0;
for (long i = start; i <= end; i++) {
sum += i;
}
return sum;
} else {
long mid = (start + end) / 2;
ForkJoinCalculator calculator1 = new ForkJoinCalculator(start, mid);
calculator1.fork();
ForkJoinCalculator calculator2 = new ForkJoinCalculator(mid + 1, end);
calculator2.fork();
return calculator1.join() + calculator2.join();
}
}
public static void main(String[] args) {
long s=System.currentTimeMillis();
System.out.println(thread());
long e=System.currentTimeMillis();
System.out.println(e-s);
long s2=System.currentTimeMillis();
System.out.println(nothread());
long e2=System.currentTimeMillis();
System.out.println(e2-s2);
}
private static long thread(){
ForkJoinPool forkJoinPool = new ForkJoinPool();
Long sum = forkJoinPool.invoke(new ForkJoinCalculator(1, 3000));
return sum;
}
private static long nothread(){
long sum = 0;
for (long i = 0; i <= 3000000000L; i++) {
sum += i;
}
return sum;
}
}
下面list 里的数据，当前的与上一个数字形成放入map,最后形成list<Map> ,fork join 操作集合，list要线程安全的，所以速度上不去；
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
public class FJStrategy extends RecursiveTask<Map<String,String>>{
private static final long serialVersionUID = 1L;
private static final int THRESHOLD =10;
private int start;
private int end;
private List<String> list;
private static List<Map<String,String>> endresult=Collections.synchronizedList(new ArrayList<Map<String,String>>());
public FJStrategy(int start, int end,List<String> list){
this.start = start;
this.end = end;
this.list=list;
}
@Override
protected Map<String,String> compute() {
if(end - start < THRESHOLD){
Map<String,String> m=new HashMap<String,String>();
for (int kk = start ; kk < end ; kk++ ){
String data1=list.get((kk-1) <=0?0:(kk-1)); //上一期
String data2=list.get(kk); //当期
m.put("start", data1);
m.put("end", data2);
endresult.add(m);
}
}else{
int middle = (start + end) /2;
FJStrategy left = new FJStrategy(start, middle,list);
FJStrategy right = new FJStrategy(middle, end,list);
ForkJoinTask<Map<String, String>> leftjoin=left.fork();
ForkJoinTask<Map<String, String>> rightjoin=right.fork();
Map<String, String> leftResult = leftjoin.join();
Map<String, String> rightResult = rightjoin.join();
endresult.add(leftResult);
endresult.add(rightResult);
}
return null;
}
public static void main(String[] args) throws Exception {
List<String> list=new ArrayList<String>();
for(int i=1;i<200000;i++){
list.add(i+"");
}
long s=System.currentTimeMillis();
forkjoin(list);
long e=System.currentTimeMillis();
System.out.println(e-s);
}
static void forkjoin(List<String> list) throws InterruptedException, ExecutionException{
ForkJoinPool pool = new ForkJoinPool();
Future<Map<String,String>>results=pool.submit(new FJStrategy(0 , list.size(),list)); // 提交可分解的PrintTask任务
results.get();
System.out.println("ddd:"+endresult);
pool.shutdown();
}
static void nothread(List<String> list){
for (int kk = 1 ; kk < list.size() ; kk++ ){
String data1=list.get((kk-1) <=0?0:(kk-1)); //上一期
String data2=list.get(kk); //当期
Map<String,String> m=new HashMap<String,String>();
m.put("start", data1);
m.put("end", data2);
endresult.add(m);
}
System.out.println(endresult);
}
}
返回Map对象，但是多线程安全问题，需要同步
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class PrintTask extends RecursiveTask<Map<String,String>>{
private static final long serialVersionUID = 1L;
private static final int THRESHOLD = 2500;
private int start;
private int end;
private List<String> list;
Map<String,String> map=Collections.synchronizedMap(new HashMap<String,String>());
public PrintTask(int start, int end,List<String> list,Map<String,String> map){
this.start = start;
this.end = end;
this.list=list;
this.map=map;
}
@Override
protected Map<String,String> compute() {
if(end - start < THRESHOLD){
for (int i = start ; i < end ; i++ ){
map.put("value"+i, list.get(i));
}
}else{
int middle = (start + end) /2;
PrintTask left = new PrintTask(start, middle,list,map);
PrintTask right = new PrintTask(middle, end,list,map);
ForkJoinTask<Map<String, String>> leftfork=left.fork();
ForkJoinTask<Map<String, String>> rightfork=right.fork();
leftfork.join();
rightfork.join();
}
return map;
}
public static void main(String[] args) throws Exception {
List<String> list=new ArrayList<String>();
for(int i=1;i<=100000;i++){
list.add(i+"");
}
long s=System.currentTimeMillis();
thread(list);
long e=System.currentTimeMillis();
System.out.println(e-s);
}
private static void nothread(List<String> list){
Map<String,String> map=Collections.synchronizedMap(new HashMap<String,String>());
for (int i = 0 ; i < list.size() ; i++ ){
map.put("value"+i, list.get(i));
}
System.out.println(map);
}
private static void thread(List<String> list) throws InterruptedException, ExecutionException{
Map<String,String> map=Collections.synchronizedMap(new HashMap<String,String>());
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Map<String, String>> resultmap=pool.submit(new PrintTask(0 , list.size(),list,map));
System.out.println(resultmap.get());
pool.shutdown();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
