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

呵呵，昨天看到两新粉，一激动，就想着今天来写这篇文章。  其实一直在关注这个领域，但是一直没有信心来写，所以一直期望着有一个开源的来用。 
看到了彭渊大师的淘宝分布式框架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);



下面是运算输出结果：  

1 50005000



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

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("name", name + "_1");
        return outputWarehouse;
    }
}



这个工人有点怪，每次都是给名字后面附加一个"_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还是有显著差异的。 
小结 在上面的例子中，我们展示了分布式计算的使用，应该是老小兼宜，简单易懂。 
职业介绍所，工人，工头，可以在一台计算机上的，也可以都在一台计算机上。 
现在，你可以很牛掰的说，速度慢？哥给你搞个分布式计算不就快了？

posted @ 2015-07-01 09:56  Tiny框架  阅读(374)  评论(0)  编辑  收藏  举报