14.多线程设计模式

多线程设计模式 - Master-Worker模式

 并发设计模式属于设计优化的一部分，它对于一些常用的多线程结构的总结和抽象。与串行相比并行程序结构通常较为复杂，因此合理的使用并行模式在多线程并发中更具有意义。

1. Master-Worker模式

• - Master-Worker模式是常用的并行模式。它的核心思想是系统由两类进程协作工作：Master进程和Worker进程。Master负责接收和分配任务，Worker负责处理子任务。当各个Worker子进程处理完成后，会将结果返回给Master，由Master做归纳和总结。
• - 其好处是能将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。

示例：下
说明：看类注释即可明了 不明白可以去屎了

//Task.java  
  public class Task {

      private int id;
      private String name;
      private int price;
      public int getId() {
          return id;
      }
      public void setId(int id) {
          this.id = id;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getPrice() {
          return price;
      }
      public void setPrice(int price) {
          this.price = price;
      }
  }
  //Worker.java   
  public class Worker implements Runnable{

      private ConcurrentLinkedQueue<Task> workQueue;
      private ConcurrentHashMap<String,Object> resultMap;

      @Override
      public void run() {
          while(true){
              Task input = this.workQueue.poll();
              if(input==null)break;
              //真正的去做业务处理
              Object output = MyWorker.handle(input);
              this.resultMap.put(Integer.toString(input.getId()), output);
          }
      }

      public static Object handle(Task input){
          return null;
      }

      public void setWorkerQueue(ConcurrentLinkedQueue<Task> workQueue) {
          this.workQueue=workQueue;
      }

      public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
          this.resultMap=resultMap;

      }
  }

  //MyWorker.java继承Worker.java，重写handle方法
  public class MyWorker extends Worker{

      public static Object handle(Task input) {
          Object output = null;
          try {
              //处理task的耗时，可能是数据的加工，也可能是操作数据库
              Thread.sleep(500);
              output = input.getPrice();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
          return output;
      }

  }
  //Master.java *
  public class Master {

      //1 应该有一个承装任务的集合
      private ConcurrentLinkedQueue<Task> workQueue = new  ConcurrentLinkedQueue<Task>();
      //2 使用普通的HashMap去承装所有的worker对象
      private HashMap<String,Thread> workers = new HashMap<String,Thread>();
      //3 使用一个容器承装每一个worker并发执行的结果集
      private ConcurrentHashMap<String,Object> resultMap = new ConcurrentHashMap<String,Object>();
      //4 构造方法
      public Master(Worker worker,int workerCount){
          //每一个worker对象都需要有master的应用workQueue用于任务的领取，resultMap用于任务的提交
          worker.setWorkerQueue(this.workQueue);
          worker.setResultMap(this.resultMap);

          for(int i=0;i<workerCount;i++){
              //key表示每一个worker的名字,value表示线程执行对象
              workers.put("子节点"+Integer.toString(i), new Thread(worker));
          }
      }
      //5 提交方法
      public void submit(Task task){
          this.workQueue.add(task);
      }
      //6 需要有一个执行的方法(启动应用程序让所有的worker工作)
      public void execute(){
          for(Map.Entry<String,Thread> me:workers.entrySet()){
              me.getValue().start();
          }
      }
      //8 判断线程是否执行完毕
      public boolean isComplete() {
          for(Map.Entry<String, Thread> me:workers.entrySet()){
              if(me.getValue().getState()!=Thread.State.TERMINATED){
                  return false;
              }
          }
          return true;
      }
      //9 返回结果集数据
      public int getResult() {
          int ret = 0;
          for(Map.Entry<String,Object> me:resultMap.entrySet()){
              //汇总逻辑
              ret+=(Integer)me.getValue();
          }
          return ret;
      }
  }
  //主函数
  public class Main {

      public static void main(String[] args) {
          System.out.println("我的机器可用processor的数量："+Runtime.getRuntime().availableProcessors());
          Master master = new Master(new MyWorker(),10);

          Random r = new Random();
          for(int i=0;i<100;i++){
              Task task = new Task();
              task.setId(i);
              task.setName("任务"+i);
              task.setPrice(r.nextInt(1000));
              master.submit(task);
          }
          master.execute();

          long start = System.currentTimeMillis();
          while(true){
              if(master.isComplete()){
                  long end = System.currentTimeMillis() -start;
                  int ret = master.getResult();
                  System.out.println("最终结果："+ret+",执行耗时："+end+"毫秒");
                  break;
              }
          }
      }

  }