设计模式 · 2021年5月12日 0

策略设计模式加多线程并行处理数据

  • 策略设计模式:基于给定的接口,来进行实现开发,在进行调用时,根据给定的类型进行调用,业务调用方不用关心具体的代码实现,只需关注类型本身即可;
  • 以下是根据真实代码开发缩小的具体案例,来演示设计模式加多线程实现的方式
  • 根据接口编写对应的实现类
  1. 首先给定一个接口,一个run()接口,返回值是String

    public interface BaseInterFace {
        String run();
    }
  2. FirstService是第一个实现接口

    
    public class FirstService implements BaseInterFace {
    
        @Override
        public String run() {
        System.out.println("执行FIRST");
        try{
        Thread.sleep(2000);
        } catch (Exception e) {
        e.printStackTrace();
        }
        return "First";
        }
    }
  3. 对应的第二个实现类

    
    public class SecService implements BaseInterFace{
    
    @Override
    public String run() {
        System.out.println("执行Sec");
        try{
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        return "Sec";
    }
    }
  4. 第三个实现类

    
    public class ThirdService implements BaseInterFace {
    
    @Override
    public String run() {
        System.out.println("执行Third");
        try{
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "Third";
    }
    }
  5. 下面是一个类型与实现映射的策略类

    
    public class RunContext implements Callable {
    private BaseInterFace baseInterFace;
    
    public RunContext(BaseInterFace baseInterFace) {
        this.baseInterFace=baseInterFace;
    }
    @Override
    public Object call() throws Exception {
        System.out.println("con");
        return this.baseInterFace.run();
    }
    }
    
    public class ExecuteService {
    
    private static final Map baseCore=new ConcurrentHashMap<>();
    static {
        //AAA类型代表第一个实现类
        baseCore.put("AAA",new RunContext(new FirstService()));
        //BBB类型代表第二个实现类
        baseCore.put("BBB",new RunContext(new SecService()));
        //CCC类型代表第三个实现类
        baseCore.put("CCC",new RunContext(new ThirdService()));
    }
    public static RunContext execute(String code) {
        return baseCore.get(code);
    }
    }
  6. 上面的代码中RunContext类是具体的执行类,ExecuteService是策略类,业务代码可通过策略类获取可执行的业务类型实现,最终通过RunContext实现多线程调用;

  7. 测试,可以看到上面三个业务实现类都有一个Thread.sleep(2000),下面通过根据类型,实现多线程并行调用,

  8. 测试代码

    
    @Test
    public void test() {
        List sd=new ArrayList<>();
        sd.add("AAA");
        sd.add("BBB");
        run(sd);
    }
    
    public void run(List sd) {
        log.info("开始");
        long l=System.currentTimeMillis();
        //注意此处应该通过配置的方式来获取线程池不可直接手动创建,示例中为了简单直接省略掉了
        ExecutorService executorService=Executors.newFixedThreadPool(3);
        List> list=new ArrayList<>();
        for (String s : sd) {
            Future submit=executorService.submit(ExecuteService.execute(s));
            list.add(submit);
        }
        try{
            for (Future future : list) {
                while (true) {
                    if (future.isDone() && !future.isCancelled()) {
                        String result=future.get();
                        System.out.println(result);
                        break;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("结束,耗时:[{}]",System.currentTimeMillis() - l);
    
    }
  9. 最终执行结果,预想结果应该是调用第一个实现类与第二个实现类,业务并行执行,执行时间在2S左右

  10. 执行结果
    在这里插入图片描述

  11. 加入CCC后
    在这里插入图片描述

    1. 以上就是代码示例,希望对你们有帮助