前天看了 T1 大大的“关于两个世界体系的对话”[url]http://www.iteye.com/topic/231515[/url],获益良多,随笔写下2个类把文章中的 (1+2)*(3+4) 并行问题用java解决掉。
[color=red]基于这个解决方案的java代码是可以(理论上)自动被并行运算的(在方法调用这个层面上),并行部分就是对所有无相关参数并行计算[/color]
闲话少说,上代码
客户端
为了让效果明显,加法和乘法里面都sleep了1000ms
Test类有3个method, add(a,b) , mul(a,b,c), trace(starttime,result),在传统的顺序执行中是这样调用的
用了并行运算就要这样调用
用了并发的写法以后,3个加法是同时由3个不同线程执行的,直到3个加法都执行完毕,乘法才被调用。在一个完全按照sequence方式写的并行程序的运行时间大大的减少了,[color=red]4003ms[/color] => [color=red]2010ms[/color]。
Test.java
帮助类
Var.java
每个Var其实就是一个方法运行时候所需要的context,包括input parameters和return结果要调用的callback
Threading.java
这个类就是所有异步调用的底层设施了,我这里就直接new thread了,可以用threadpool之类的,也可以用grid computation,比如coherence之类的
接下来这个Func其实就是些反射动态调用并且暴露一个统一的类似function的接口。
动态调用里面我用了方法名字匹配(不包括参数类型,只要名字符合的第一个方法就被调用,这样主要是因为本人倾向可变长参数,不喜欢overloading,所以像System.out对象里面的println方法就不能直接用)。另外还负责了生成一个Var。
Func.java
[color=red]基于这个解决方案的java代码是可以(理论上)自动被并行运算的(在方法调用这个层面上),并行部分就是对所有无相关参数并行计算[/color]
闲话少说,上代码
客户端
为了让效果明显,加法和乘法里面都sleep了1000ms
Test类有3个method, add(a,b) , mul(a,b,c), trace(starttime,result),在传统的顺序执行中是这样调用的
Test t=new Test();
int a=t.add(1,2);
int b=t.add(3,4);
int c=t.add(2,5);
int result=t.mul(a,b,c);
运行结果
main: + 1 2 => 3
main: + 3 4 => 7
main: + 2 5 => 7
main: * 3 7 7 => 147
147 | time cost : 4003 | freeM/totalM : 1816576/2031616
用了并行运算就要这样调用
Test t=new Test();
Func add=Func.define(t,"add");
Func mul=Func.define(t,"mul");
Var a=add.c(1,2);
Var b=add.c(3,4);
Var c=add.c(2,5);
Var result=mul.c(a,b,c);
result.run();
运行结果
Thread-1: + 1 2 => 3
Thread-2: + 3 4 => 7
Thread-3: + 2 5 => 7
Thread-6: * 3 7 7 => 147
147 | time cost : 2010 | freeM/totalM : 1716992/2031616
用了并发的写法以后,3个加法是同时由3个不同线程执行的,直到3个加法都执行完毕,乘法才被调用。在一个完全按照sequence方式写的并行程序的运行时间大大的减少了,[color=red]4003ms[/color] => [color=red]2010ms[/color]。
Test.java
/*
* Created on 2008-9-9
* Title:
* Description:
* @author Gordon Hu
* @version 1.0
*/
package gordon.concurrence;
public class Test {
public static void main(String[] args) throws Exception {
Test t=new Test();
boolean parallel=true;
if(parallel){
Func add=Func.define(t,"add");
Func mul=Func.define(t,"mul");
Func println=Func.define(t,"trace");
Var a=add.c(1,2);
Var b=add.c(3,4);
Var c=add.c(2,5);
Var i3=mul.c(a,b,c);
long start=System.currentTimeMillis();
Var timeMe=println.c(start,i3);
timeMe.run();
}else{
long START=System.currentTimeMillis();
int A=t.add(1,2);
int B=t.add(3,4);
int C=t.add(2,5);
int I3=t.mul(A,B,C);
t.trace(START,I3);
}
}
public int add(Integer a,Integer b){
int rst=a+b;
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
// TODO
}
System.out.println(Thread.currentThread().getName()+ ": + "+a+" "+b+" => "+rst);
return rst;
}
public int mul(Integer a,Integer b,Integer c){
int rst=a*b*c;
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
// TODO
}
System.out.println(Thread.currentThread().getName()+ ": * "+a+" "+b+" "+c+" => "+rst);
return rst;
}
public void trace(Long start,Object o){
System.out.println(o+" | time cost : "+(System.currentTimeMillis()-start)+" | freeM/totalM : "+Runtime.getRuntime().freeMemory()+"/"+Runtime.getRuntime().totalMemory());
}
}
帮助类
Var.java
/*
* Created on 2008-9-9
* Title:
* Description:
* @author Gordon Hu
* @version 1.0
*/
package gordon.concurrence;
import java.util.HashSet;
import java.util.Set;
public abstract class Var implements Runnable {
public abstract Func getFunc();
public abstract void run();
public abstract void update(Var n,Object rst);
private Set<Var> updater=new HashSet<Var>();
public void setUpdater(Set<Var> updater) {
this.updater.addAll(updater);
}
public void addUpdater(Var updater){
this.updater.add(updater);
}
public Set<Var> getUpdater() {
return updater;
}
}
每个Var其实就是一个方法运行时候所需要的context,包括input parameters和return结果要调用的callback
Threading.java
/*
* Created on 2008-9-9
* Title:
* Description:
* @author Gordon Hu
* @version 1.0
*/
package gordon.concurrence;
public class Threading {
public static void runThread(Runnable r){
new Thread(r).start();
}
}
这个类就是所有异步调用的底层设施了,我这里就直接new thread了,可以用threadpool之类的,也可以用grid computation,比如coherence之类的
接下来这个Func其实就是些反射动态调用并且暴露一个统一的类似function的接口。
动态调用里面我用了方法名字匹配(不包括参数类型,只要名字符合的第一个方法就被调用,这样主要是因为本人倾向可变长参数,不喜欢overloading,所以像System.out对象里面的println方法就不能直接用)。另外还负责了生成一个Var。
Func.java
/*
* Created on 2008-9-9
* Title:
* Description:
* @author Gordon Hu
* @version 1.0
*/
package gordon.concurrence;
import java.util.ArrayList;
import java.util.List;
public abstract class Func {
public abstract Object apply(Object... args);
public Var c(final Object... args){
final Func self=this;
Var n=new Var(){
//....create a Var and bind args to it
//....具体实现省略,详情看附件中的src
};
//set callbacks
for(Object o:args){
if(o instanceof Var)((Var)o).addUpdater(n);
}
return n;
}
public static Func define(final Object worker,final String method){
//define a Func from a given object and its method name
return new Func(){
public Object apply(Object... args) {
return run(worker,method,args);
}
};
}
public static Runnable getUpdateThread(final Var updater,final Var node,final Object rst){
return new Runnable(){
public void run(){
updater.update(node,rst);
}
};
}
public static Object run(Object worker, String action,
Object... arguments) {
//dynamically call run a method
//execute worker.action(arguments) and return result
//....具体实现省略,详情看附件中的src
}
}