本案例测试Master-Worker并发设计模式，网上关于该模式，都大差不差，本案例使用线程池的方式，重新实现，并进行测试对比。笔者希望进行优化，并作为工具使用，技术水平有限，请多多指教，提出不同意见，共同进步。

建议Clone代码，学习
GIT仓库地址

目录

• 使用方法
• 测试对比

  

   

    

     

    
    

     

      测试ThreadMap result:216474736
     
    
   

    

     

    
    

     

      测试ExecutorService result:216474736
     
    
   

    

     

    
    

     

      StopWatch '': running time (millis) = 652
     
    
   

    

     

    
    

     

      -----------------------------------------
     
    
   

    

     

    
    

     

      ms     %     Task name
     
    
   

    

     

    
    

     

      -----------------------------------------
     
    
   

    

     

    
    

     

      00432  066%  测试ThreadMap
     
    
   

    

     

    
    

     

      00220  034%  测试ExecutorService
     
    
  
 

使用方法

SmileWorkerHandler

实现 SmileWorkerHandler 类，为每个任务写处理方法

  

   

    

     

    
    

     

      public interface SmileWorkerHandler<T> {
     
    
   

    

     

    
    

     
    default  T handler(T input) {
     
    
   

    

     

    
    

     
        return input;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
  
 

SmileMaster

该类任务主要用于任务分配，提供多种构造，运行自定义线程池和线程工厂

  

   

    

     

    
    

     
 /**
     
    
   

    

     

    
    

     

       * @param worker Worker进程逻辑
     
    
   

    

     

    
    

     

       * @param countWorker Worker进程数量
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
 public SmileMaster(SmileWorker worker, int countWorker)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 /**
     
    
   

    

     

    
    

     

       * @param worker Worker进程逻辑
     
    
   

    

     

    
    

     

       * @param countWorker Worker进程数量
     
    
   

    

     

    
    

     

       * @param threadFactory 自定义线程工厂
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
 public SmileMaster(SmileWorker worker, int countWorker, ThreadFactory threadFactory)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
  /**
     
    
   

    

     

    
    

     

       * @param worker Worker进程逻辑
     
    
   

    

     

    
    

     

       * @param executor 线程池
     
    
   

    

     

    
    

     

       * 使用线程池来维护工作队列
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
 public SmileMaster(SmileWorker worker, int countWorker, ExecutorService executor)
     
    
  
 

  
 
 

测试对比及使用代码

运行返回值就是本文开头的代码块，多余的不解释，直接撸代码，欢迎提出问题，共同解决，进步

  

   

    

     

    
    

     

      /**
     
    
   

    

     

    
    

     

       * @Package: flyer.worker.core
     
    
   

    

     

    
    

     

       * @Description: 测试版本
     
    
   

    

     

    
    

     

       * @author: liuxin
     
    
   

    

     

    
    

     

       * @date: 2017/9/14 下午5:15
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     

      public class SmileMasterTest {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    public static void main(String[] args) throws Exception {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        /**
     
    
   

    

     

    
    

     

       * 测试使用Map维护Thread
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     
        StopWatch watch = new StopWatch();
     
    
   

    

     

    
    

     

              watch.start("测试ThreadMap");
     
    
   

    

     

    
    

     
        Integer testthreadMapResult = testthreadMap(10,100000);
     
    
   

    

     

    
    

     
        System.out.println("测试ThreadMap result:"+testthreadMapResult);
     
    
   

    

     

    
    

     

              watch.stop();
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        /**
     
    
   

    

     

    
    

     

       * 使用线程池维护现场
     
    
   

    

     

    
    

     

       */
     
    
   

    

     

    
    

     

              watch.start("测试ExecutorService");
     
    
   

    

     

    
    

     
        Integer testExecutorServiceResult = testExecutorService(10,100000);
     
    
   

    

     

    
    

     
        System.out.println("测试ExecutorService result:"+testExecutorServiceResult);
     
    
   

    

     

    
    

     

              watch.stop();
     
    
   

    

     

    
    

     
        System.out.println(watch.prettyPrint());
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    public static Integer testthreadMap(int countWorker,int countTask) {
     
    
   

    

     

    
    

     
        SmileMaster<Integer> smileMaster = new SmileMaster(new SmileWorker(new DefaultWorkerHandler() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public Integer handler(Integer input) {
     
    
   

    

     

    
    

     
                return input * input;
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              }), countWorker);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        //提交100个子任务
     
    
   

    

     

    
    

     
        for (int i = 0; i < countTask; i++) {
     
    
   

    

     

    
    

     

                  smileMaster.submit(i);
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              smileMaster.execute();
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        Map<String, Object> resultMap = smileMaster.getResultMap();
     
    
   

    

     

    
    

     

              int re = 0;
     
    
   

    

     

    
    

     
        for (Map.Entry<String, Object> entry : resultMap.entrySet()) {
     
    
   

    

     

    
    

     
            String key = entry.getKey();
     
    
   

    

     

    
    

     
            Integer o = (Integer) resultMap.get(key);
     
    
   

    

     

    
    

     

                  re += o;
     
    
   

    

     

    
    

     

                  resultMap.remove(key);
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     
        return re;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    public static Integer testExecutorService(int countWorker,int countTask) {
     
    
   

    

     

    
    

     
        ExecutorService executorService2 = Executors.newCachedThreadPool();
     
    
   

    

     

    
    

     
        SmileMaster smileMaster1 = new SmileMaster(new SmileWorker(new DefaultWorkerHandler() {
     
    
   

    

     

    
    

     
            @Override
     
    
   

    

     

    
    

     
            public Integer handler(Integer input) {
     
    
   

    

     

    
    

     
                return input * input;
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              }), countWorker, executorService2);
     
    
   

    

     

    
    

     
        for (int i = 0; i < countTask; i++) {
     
    
   

    

     

    
    

     

                  smileMaster1.submit(i);
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

              smileMaster1.executePool();
     
    
   

    

     

    
    

     
        Map<String, Object> resultMapPool = smileMaster1.getResultMapPool();
     
    
   

    

     

    
    

     

              int re1 = 0;
     
    
   

    

     

    
    

     
        for (Map.Entry<String, Object> entry : resultMapPool.entrySet()) {
     
    
   

    

     

    
    

     
            String key = entry.getKey();
     
    
   

    

     

    
    

     
            Integer o = (Integer) resultMapPool.get(key);
     
    
   

    

     

    
    

     

                  re1 += o;
     
    
   

    

     

    
    

     

                  resultMapPool.remove(key);
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     
        return re1;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 
 

文章来源: springlearn.blog.csdn.net，作者：西魏陶渊明，版权归原作者所有，如需转载，请联系作者。

原文链接：springlearn.blog.csdn.net/article/details/102425336