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

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

  • 根据接口编写对应的实现类
  1. 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";
    }
}

  1. 对应的第二个实现类
public class SecService implements BaseInterFace{

    @Override
    public String run() {
        System.out.println("执行Sec");
        try{
            Thread.sleep(2000);
        }catch (Exception e){
            e.printStackTrace();
        }
        return "Sec";
    }

}
  1. 第三个实现类
public class ThirdService implements BaseInterFace {

    @Override
    public String run() {
        System.out.println("执行Third");
        try{
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "Third";
    }
}

  1. 下面是一个类型与实现映射的策略类
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<String,RunContext> 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);
    }
}

  1. 上面的代码中RunContext类是具体的执行类,ExecuteService是策略类,业务代码可通过策略类获取可执行的业务类型实现,最终通过RunContext实现多线程调用
  2. 测试,可以看到上面三个业务实现类都有一个Thread.sleep(2000),下面通过根据类型,实现多线程并行调用,
  3. 测试代码
    @Test
    public void test() {
        List<String> sd=new ArrayList<>();
        sd.add("AAA");
        sd.add("BBB");
        run(sd);
    }


    public void run(List<String> sd) {
        log.info("开始");
        long l=System.currentTimeMillis();
        //注意此处应该通过配置的方式来获取线程池不可直接手动创建,示例中为了简单直接   
        //省略掉了
        ExecutorService executorService=Executors.newFixedThreadPool(3);
        List<Future<String>> list=new ArrayList<>();
        for (String s : sd) {
            Future<String> submit=executorService.submit(ExecuteService.execute(s));
            list.add(submit);
        }
        try{
            for (Future<String> 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);

    }
  1. 最终执行结果,预想结果应该是调用第一个实现类与第二个实现类,业务并行执行,执行时间在2S左右

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

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

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

相关推荐
©️2020 CSDN 皮肤主题: 技术工厂 设计师:CSDN官方博客 返回首页