Java多线程之主从设计模式-yellowcong

在Hadoop和Redis等集群的时候，都会有主从的概念，有一个主节点用于控制请求的分发和结果的统计，从节点用于真正的数据处理操作。在多线程中，我们可以把 一个大任务分割成多个小任务，给子节点处理，在这种设计模式中，我们需要使用到原子类 ConcurrentLinkedQueue （用于存储请求提交的任务），和ConcurrentHashMap（用于收集每一个节点获取的结果）。在这种无锁的设计模式中，必须用到原子类的对象，解决数据的统一问题

在多线程开发中，需要多使用原子类解决问题，而不是使用锁的方式来解决，锁的方式效率相对比较低，notify和wait方式远不及Lock类的锁，所以开发中，能使用到原子类的，尽量用原子类完成。

任务对象

任物对象，只是一个简单的java bean,没有任何的复杂处理，这个案例设计的是，有一个加法运算，分成多个任务，通过Work线程完成

package com.yellowcong.work;/** * 创建日期:2017年10月6日 <br/> * 创建用户:yellowcong <br/> * 功能描述:任务队列 */public class Task {    private String name;    private String id;    private Integer price;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    public Integer getPrice() {        return price;    }    public void setPrice(Integer price) {        this.price = price;    }}

Master类

主对象中，必须有三个重要的对象
1、ConcurrentLinkedQueue<Task> ，收集任务队列，将所有提交的任务都会放到这个队列中
2、HashMap<String, Thread> 来维护 Master管理的Work对象（任务处理节点，判断主节点可以管理多少个小弟完成人物），在添加任务后，可以遍历这个对象的线程，启动Work任务
3、ConcurrentHashMap<String, Object> 用于收集每个Work节点处理的结果，然后在主节点中做统计处理

package com.yellowcong.work;import java.security.KeyStore.Entry;import java.util.HashMap;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentLinkedQueue;/** * 创建日期:2017年10月6日 <br/> * 创建用户:yellowcong <br/> * 功能描述:   */public class Master {    //1.任务管理    private ConcurrentLinkedQueue<Task> tasks =  new ConcurrentLinkedQueue<Task>();    //2.master来管理的Works     private HashMap<String, Thread> works = new HashMap<String, Thread>();    //3.用这个容器来接收处理 完成的任务的结果集    private ConcurrentHashMap<String, Object> results = new ConcurrentHashMap<String, Object>();    //4、设定人物和启动的线程数量    public Master(Work work,int count) {        //每个work里面需要有 放result和获取人物的队列        work.setResults(results);        work.setTasks(tasks);        //将多个线程的Work都放到HashMap集合中        for(int i=0;i<count;i++){            //key 是节点的名字， val是多线程            works.put(String.valueOf(i),new Thread(work));        }    }    //5、提交任务    public void submit(Task task){        this.tasks.add(task);    }    //6、启动任务    public void execute(){        for(Map.Entry<String, Thread> entry :works.entrySet()){            //启动所有线程            entry.getValue().start();        }    }    //7.判断线程是否完毕    public boolean isComplite(){        for(Map.Entry<String, Thread> entry :works.entrySet()){            // 线程执行完毕或异常退出会进入终止状态 ,判断是否是终止状态            if(entry.getValue().getState() != Thread.State.TERMINATED){                return false;            }        }        return true;    }    //8.返回结果数据    public long getResult(){        long data = 0l;        for(Map.Entry<String, Object> entry :results.entrySet()){            data += Long.parseLong(String.valueOf(entry.getValue().toString()));        }        return data;    }}

Work 类

这个类实现了Runable接口，在这个里面，有
ConcurrentHashMap<String, Object>
ConcurrentLinkedQueue<Task>
这两个集合对象，是由Master传递过来，目的 是为了获取任务和将任务处理的结果存储起来

package com.yellowcong.work;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ConcurrentLinkedQueue;/** * 创建日期:2017年10月6日 <br/> * 创建用户:yellowcong <br/> * 功能描述:Master所管理的类,Master的人物都分派给Work做 */public class Work implements Runnable {    private ConcurrentHashMap<String, Object> results;    private ConcurrentLinkedQueue<Task> tasks;    public void setResults(ConcurrentHashMap<String, Object> results) {        this.results = results;    }    public void setTasks(ConcurrentLinkedQueue<Task> tasks) {        this.tasks = tasks;    }    public void run() {        while(true){            //当任务为空的情况            if(tasks.isEmpty()){                break;            }            //获取一个任务            Task task = this.tasks.poll();            Object result = haddle(task);            //设定结果            this.results.put(task.getId(), result);        }    }    /**     * 真正处理事情的逻辑     * 创建日期:2017年10月6日<br/>     * 创建用户:yellowcong<br/>     * 功能描述:     * @param task     * @return     */    private Object haddle(Task task) {        try {            Thread.sleep(500);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        return task.getPrice();    }}

测试类

测试类中，启动了10个 Work对象，来完成整个任务，当线程数量增加时，整体锁用的时间，就会减少。

package com.yellowcong.work;import java.util.Random;/** * 创建日期:2017年10月6日 <br/> * 创建用户:yellowcong <br/> * 功能描述:   */public class MainTest {    public static void main(String[] args) {        System.out.println(Thread.activeCount());        //建立一个主节点        Master master = new Master(new Work(), 10);        Random rand = new Random();        for(int i=0;i<100;i++){            Task task = new Task();            task.setId(String.valueOf(i));            task.setName("任务"+i);            task.setPrice(rand.nextInt(1000));            //提交任务            master.submit(task);        }        //执行任务        long start = System.currentTimeMillis();        master.execute();        //判断是否执行完成        while(true){            if(master.isComplite()){                long result = master.getResult();                long end = System.currentTimeMillis();                System.out.println("最终结果"+result+",耗时"+Long.toString(end-start));                break;            }        }    }}