Tiny并行计算框架之使用介绍

最新推荐文章于 2021-11-14 21:34:22 发布

TINY框架

最新推荐文章于 2021-11-14 21:34:22 发布

阅读量186

点赞数

呵呵，昨天看到两新粉，一激动，就想着今天来写这篇文章。其实一直在关注这个领域，但是一直没有信心来写，所以一直期望着有一个开源的来用。
看到了彭渊大师的淘宝分布式框架Fourinone介绍，确实有一种相见恨晚的感觉，于是就准备去研究一番，详细见本人的感想文章由 fourinone初步学习想到的，确实来说，感觉到有一种啃不动的感觉，当然也可能是本人水平不足的原因所致。但是不管怎么说，促动了本人来写一个简单的并行计算框架。
在此引用本人的名言：“ 牛人的代码就是生手也一看就懂；生手的代码就是牛人来了也看不懂。”
好的，亲们，不管你是生手还是牛人，let's GO!
HelloWorld之一 当然，还是从Hello说起，不过这次的hello与之前不太一样，管呢，先看看再说：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class WorkerHello extends AbstractWorker {
public WorkerHello() throws RemoteException {
super("hello");
}

public Warehouse doWork(Work work) throws RemoteException {
String name = work.getInputWarehouse().get("name");
System.out.println(String.format("id %s: Hello %s", getId(), name));
Warehouse outputWarehouse = new WarehouseDefault();
outputWarehouse.put("helloInfo", "Hello," + name);
return outputWarehouse;
}
}

首先，工人Hello继承自抽象工人，也就是说他首先得是个工人，然后呢是个Hello工人。
在它的构造函数中，抛出一个RemoteException，表明，它是可以被远程调用的工人,在构造方法中调用super("hello")，表明这个工人是个干hello活的工人。
既然是工人么，因此当然得做工作了。
首先从工作的的仓库中取出一个叫name的字符串，然后控制台打一下，然后构建了一个输出的仓库，在里面放了一个helloInfo的字符串，然后返回输出仓库，工人的任务就算完成了。
下面看看示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
JobCenter jobCenter = new JobCenterLocal();

for (int i = 0; i < 5; i++) {
jobCenter.registerWorker(new WorkerHello());
}

Foreman helloForeman = new ForemanSelectOneWorker("hello");
jobCenter.registerForeman(helloForeman);
Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("name", "world");
Work work = new WorkDefault("hello", inputWarehouse);

Warehouse outputWarehouse = jobCenter.doWork(work);
System.out.println(outputWarehouse.get("helloInfo"));
jobCenter.stop();
}

首先开个职业介绍所，然后构建一了5个Hello工人，放在注册到职业介绍所去。
然后又注册了一个专门干hello活的包工头到职业介绍所，这个包工头有点特别，随便找一个hello工人来干hello这个活。
然后，构建了一个工作，介个工作是个hello工作，它的来料仓库里放了个name是world的值。
然后他就对职业介绍所说，你帮咱把这个活干干。
活干完了，也没有发生异常，顺利的在结果仓库里找到了helloInfo这个值，并且从控制台打出。
下面是运行结果：

1 2	id 46fbffdeb18b45f28cda4617795c2a52: Hello world Hello,world

从上面的例子当中，我们理解了下面几个概念：

1
2
3
4
5
6
7
8

职业介绍所：JobCenter,主要用于注册工人，注册包工头，接受或处理任务；

包工头：领取工作并招募工人，完成工作，并返回结果

工人：就是我们常说的民工了，只知道来料加工，处于生态环境的低层，最后还没有得工资

工作：只有工作类型和来料仓库
仓库：用于放各种来料或成品

职业介绍所，一般来说不用写，框架已经提供；工作，一般来说不用写；工头，绝大多数不需要写，框架已经提供了若干类型工头，一般够用了；工人，一定需要写。
自此，简单的hello并行计算就算完成了。
HelloWorld之二 上面的hello工作完成之后，老板突发齐想，一个hello吼得声音太小了，偶想让所有的工人都帮偶齐声喊一起Hello,World，那该多壮观，当然老板有钱，说干就干：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String[] args) throws IOException, ClassNotFoundException {
JobCenter jobCenter = new JobCenterLocal();
for (int i = 0; i < 5; i++) {
jobCenter.registerWorker(new WorkerHello());
}
Foreman helloForeman = new ForemanSelectAllWorker("hello");
jobCenter.registerForeman(helloForeman);

Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("name", "world");
Work work = new WorkDefault("hello", inputWarehouse);
jobCenter.doWork(work);
jobCenter.stop();
}

当然，这次的包工头换了一下，这个包工头会找所有的工人来干活，结果如下：

1
2
3
4
5

id 83274d8f8c194bb89d773c232e867cc4: Hello world
id 16fbf219d3cf4ba48eef23c260de509a: Hello world
id 9c17a119a4f341d68b589a503712b0f9: Hello world
id e7e3b2bdc9444a179ad62abdd35275e1: Hello world
id 4b12a1b70f5d43e2bff473382096dfbe: Hello world

老板一看，尼妈，这帮工人喊是喊完了，这声音就响过(用的是System.out)就没有了，也不知道有几个工人给喊过，包工头说哦，我没有干这收集数据的活，你想要呀，你想要就吱声呀，我加个结果合并给你：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public static void main(String[] args) throws IOException, ClassNotFoundException {
JobCenter jobCenter = new JobCenterLocal();
for (int i = 0; i < 5; i++) {
jobCenter.registerWorker(new WorkerHello());
}
Foreman helloForeman = new ForemanSelectAllWorker("hello", new HelloWorkCombiner());
jobCenter.registerForeman(helloForeman);

Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("name", "world");
Work work = new WorkDefault("hello", inputWarehouse);
Warehouse outputWarehouse = jobCenter.doWork(work);
List<String> result = outputWarehouse.get("helloInfo");
System.out.println(result.size());
jobCenter.stop();
}

Hello结果收集器，用于把工人干的活合并成一个结果出来：

1
2
3
4
5
6
7
8
9
10
11
12

public class HelloWorkCombiner implements WorkCombiner {

public Warehouse combine(List<Warehouse> warehouseList) throws RemoteException {
Warehouse warehouse = new WarehouseDefault();
List<String> helloList = new ArrayList<String>();
for (Warehouse w : warehouseList) {
helloList.add((String) w.get("helloInfo"));
}
warehouse.put("helloInfo", helloList);
return warehouse;
}
}

老板终于称心如意了。
分布式求和 老板消停了一下下，又想，偶想知道从1加到10000这个结果值是多少。但是一个计算机算，算得太慢了，能不能多几台机器帮我看看，让我早些知道结果？（仅用于说明原理，你可以理解为从1加到10000需要几个小时）
首先造个工人：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class WorkerSum extends AbstractWorker {
public WorkerSum() throws RemoteException {
super("sum");
}

public Warehouse doWork(Work work) throws RemoteException {
long start = (Long) work.getInputWarehouse().get("start");
long end = (Long) work.getInputWarehouse().get("end");
long sum = 0;
for (long i = start; i <= end; i++) {
sum += i;
}
Warehouse outputWarehouse = new WarehouseDefault();
outputWarehouse.put("sum", sum);
return outputWarehouse;
}
}

工人从来料仓库获取开始和结束，然后计算合计值并放在输出仓库中的sum值域中。
但是这活该怎么分给工人呢，工人算完的结果又怎么合并呢？
这个时候，就需要搞个工作分解合并器给包工头用了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class SumSplitterCombiner implements WorkSplitterCombiner {
public List<Warehouse> split(Work work, List<Worker> workers) throws RemoteException {
List<Warehouse> list = new ArrayList<Warehouse>();
long start = (Long) work.getInputWarehouse().get("start");
long end = (Long) work.getInputWarehouse().get("end");
long count = end - start + 1;
long step = count / workers.size();
for (int i = 0; i < workers.size(); i++) {
Warehouse subInputWarehouse = new WarehouseDefault();
subInputWarehouse.put("start", step * i + start);
if (i == workers.size() - 1) {
subInputWarehouse.put("end", end);
} else {
subInputWarehouse.put("end", step * (i + 1));
}
list.add(subInputWarehouse);
}
return list;
}

public Warehouse combine(List<Warehouse> warehouseList) throws RemoteException {
Warehouse outputWarehouse = new WarehouseDefault();
long sum = 0;
for (Warehouse w : warehouseList) {
sum += (Long) w.get("sum");
}
outputWarehouse.put("sum", sum);
return outputWarehouse;
}
}

一共两方法，一个分解方法，一个合并方法，非常容易理解。
万事具备，呵呵，开工：
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
JobCenter jobCenter = new JobCenterLocal();
JobCenter center = new JobCenterRemote();
for (int i = 0; i < 5; i++) {
center.registerWorker(new WorkerSum());
}
Foreman helloForeman = new ForemanSelectAllWorker("sum", new SumSplitterCombiner());
center.registerForeman(helloForeman);
Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("start", 1l);
inputWarehouse.put("end", 10000l);
Work work = new WorkDefault("sum", inputWarehouse);

Warehouse outputWarehouse = center.doWork(work);
System.out.println(outputWarehouse.get("sum"));
jobCenter.stop();
center.stop();
}
}

注意，输入仓库是两个长整型数，因此，下面两句最后的值是1-10000，而不是11~100001

1 2	inputWarehouse.put("start", 1l); inputWarehouse.put("end", 10000l);

下面是运算输出结果：

50005000

多阶段任务 当然，简单的任务都是一下就干完了的，复杂的工作就需要分成多个阶段进行了。不同的阶段需要的包工头或工人又都是不一定相同的。对于解决这种类型的任务，咱也有相当简单的解决办法。
先造个工人：

1
2
3
4
5
6
7
8
9
10
11
12
13

这个工人有点怪，每次都是给名字后面附加一个"_1"，然后原样返回。别的没有啥子不同。
EN,然后来做做一系列的工作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class TestSerialWork {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
JobCenter jobCenter = new JobCenterLocal();
for (int i = 0; i < 5; i++) {
jobCenter.registerWorker(new WorkerHello());
}
Foreman helloForeman = new ForemanSelectOneWorker("hello");
jobCenter.registerForeman(helloForeman);
Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("name", "world");
Work work = new WorkDefault("hello", inputWarehouse);
work.setNextWork(new WorkDefault("hello")).setNextWork(new WorkDefault("hello"));
Warehouse warehouse = jobCenter.doWork(work);
System.out.println(warehouse.get("name"));
jobCenter.stop();
}
}

与前面的例子唯一的不同就是

1	work.setNextWork(new WorkDefault("hello")).setNextWork(new WorkDefault("hello"));

这里通过指定下一工作，来建立了一个系列工作，这里定义的工作是三步，下面是运行结果：

1
2
3
4

id 2a53a967e3b84289beb3dbaf12a7d8be: Hello world
id e3d471c27e264a1a87cf263605bfe9bd: Hello world_1
id 2a53a967e3b84289beb3dbaf12a7d8be: Hello world_1_1
world_1_1_1

运行结果与预期完全一致。
通过序列工作的方式可以把复杂的工作分解成简单的工作，而且不同的工作可以由不同的包工头和工人来完成。

圆周率计算 圆周率的计算一般来说是比较费时间的，详细fourinone作者在文章 http://my.oschina.net/fourinone/blog/113731?p=3#comments中已经在详细的描述，这里仅采用其文章中所述方法。

1
2
3
4
5
6
7
8

public static void main(String[] args)
{
double pi=0.0;
for(double i=1.0;i<1000000001d;i++){
pi += Math.pow(-1,i+1)/(2*i-1);
}
System.out.println(4*pi);
}

来计算，先创建个工人：
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class PiWorker extends AbstractWorker {
public PiWorker() throws RemoteException {
super("pi");
}

@Override
protected Warehouse doWork(Work work) throws RemoteException {
long m = (Long) work.getInputWarehouse().get("start");
long n = (Long) work.getInputWarehouse().get("end");
double pi = 0.0d;
for (double i = m; i < n; i++) {
pi += Math.pow(-1, i + 1) / (2 * i - 1);
}
work.getInputWarehouse().put("pi", 4 * pi);
return work.getInputWarehouse();
}
}

再写个拆分合并器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class PiSplitterCombiner implements WorkSplitterCombiner {
public List<Warehouse> split(Work work, List<Worker> workers) throws RemoteException {
List<Warehouse> list = new ArrayList<Warehouse>();
long start = (Long) work.getInputWarehouse().get("start");
long end = (Long) work.getInputWarehouse().get("end");
long count = end - start + 1;
long step = count / workers.size();
for (int i = 0; i < workers.size(); i++) {
Warehouse subInputWarehouse = new WarehouseDefault();
subInputWarehouse.put("start", step * i + start);
if (i == workers.size() - 1) {
subInputWarehouse.put("end", end);
} else {
subInputWarehouse.put("end", step * (i + 1));
}
list.add(subInputWarehouse);
}
return list;
}
public Warehouse combine(List<Warehouse> warehouseList) throws RemoteException {
Warehouse outputWarehouse = new WarehouseDefault();
double pi = 0d;
for (Warehouse w : warehouseList) {
pi += (Double) w.get("pi");
}
outputWarehouse.put("pi", pi);
return outputWarehouse;
}
}

接下来是测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
JobCenter jobCenter = new JobCenterLocal();
for (int i = 0; i < 10; i++) {
jobCenter.registerWorker(new PiWorker());
}
Foreman helloForeman = new ForemanSelectAllWorker("pi", new PiSplitterCombiner());
jobCenter.registerForeman(helloForeman);
Warehouse inputWarehouse = new WarehouseDefault();
inputWarehouse.put("start", 1l);
inputWarehouse.put("end", 1000000001l);
Work work = new WorkDefault("pi", inputWarehouse);

Warehouse outputWarehouse = jobCenter.doWork(work);
System.out.println("pi:"+outputWarehouse.get("pi"));
jobCenter.stop();
}
}

运行结果：

1
2
3
4

并行计算运行结果：
time:10326ms pi:3.141592694075038
单线程计算运行结果
time:24857ms pi:3.1415926525880504

这个结果是在本人笔记本跑出来的，笔记本是4核机器，而不是4CPU机器，所以4个并行跑，并没有得到期望的1/4的时间，而是1/2.4左右的时间，因此可以得出两个结论：
结论1：通过并行计算，确实可以缩短计算时间，更好的利用CPU资源。
绪论2：4核和4C还是有显著差异的。
小结在上面的例子中，我们展示了分布式计算的使用，应该是老小兼宜，简单易懂。
职业介绍所，工人，工头，可以在一台计算机上的，也可以都在一台计算机上。
现在，你可以很牛掰的说，速度慢？哥给你搞个分布式计算不就快了？