多线程实现demo

多线程应用场景：报表导出，大批量数据同步等等吧。

同步100万条数据，单个线程假如需要2.5个小时，如果5个线程一起跑可能只需要0.5小时，10个线程一起跑可能只需要十五分钟。这样就大大提高了效率。那么我们如果让多个线程同时跑，而且又跑的是不重复的数据呢，可以按照id ，时间段进行分割。每一个线程跑20万条，或者按照时间顺序进行跑。我下面的例子是按照时间分割，进行多线程处理。

使用ExecutorService、Callable、Future实现有返回结果的多线程 应用demo

public static void main(String[] args) {
    ExecutorService pool= Executors.newFixedThreadPool(5);//5个线程一起跑
    CountDownLatch countDownLatch = new CountDownLatch(5);//计数器，每个线程跑完，减1 ，都跑完则为0
    Future t1 =  pool.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            String startTime = "2018-01-01 00:00:00";
            String endTime = "2018-05-01 00:00:00";
            //先按照时间进行拆分，然后
            String i = singleThreadExecutorTest.aa(startTime,endTime);
            countDownLatch.countDown();
            return i;
        }
    });//需要返回值
    Future t2 =  pool.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            String startTime = "2018-05-01 00:00:00";
            String endTime = "2018-07-01 00:00:00";
            //先按照时间进行拆分，然后
            String i = singleThreadExecutorTest.aa(startTime,endTime);
            countDownLatch.countDown();
            return i;
        }
    });//需要返回值
    Future t3=  pool.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            String startTime = "2018-07-01 00:00:00";
            String endTime = "2018-08-01 00:00:00";
            //先按照时间进行拆分，然后
            String i = singleThreadExecutorTest.aa(startTime,endTime);
            countDownLatch.countDown();
            return i;
        }
    });//需要返回值
    Future t4 =   pool.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            String startTime = "2018-08-01 00:00:00";
            String endTime = "2018-12-01 00:00:00";
            //先按照时间进行拆分，然后
            String i = singleThreadExecutorTest.aa(startTime,endTime);
            countDownLatch.countDown();
            return i;
        }
    });//需要返回值
    Future t5 = pool.submit(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            String startTime = "2018-12-01 00:00:00";
            String endTime = "2019-02-01 00:00:00";
            //先按照时间进行拆分，然后
            String i = singleThreadExecutorTest.aa(startTime,endTime);
            countDownLatch.countDown();
            return i;
        }
    });//需要返回值
    try {
        countDownLatch.await();
        System.out.println("t1:"+t1.get());
        System.out.println("t2:"+t2.get());
        System.out.println("t3:"+t3.get());
        System.out.println("t4:"+t4.get());
        System.out.println("t5:"+t5.get());
    }catch (Exception e){
        e.printStackTrace();
    }
    //关闭线程池

    pool.shutdown();

}
/**
 * 根据时间段查询 分页查询 处理业务业务
 * */
public static String aa(String startTime ,String endTime){
    //分页查询处理
    long time = 0l;
    try {
        Date dateTmp1 = new Date();
        Thread.sleep(1000*(int)(1+Math.random()*(10-1+1)));//1000 到10000 毫秒的随机数
        Date dateTmp2 = new Date();
         time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + Thread.currentThread().getName() + "任务终止"+"-------"+startTime+"===="+endTime);
    }catch (Exception e){
       e.printStackTrace();
    }
    return "任务返回运行结果,当前任务时间【" + time + "毫秒】";
}

 

返回结果：

>>>pool-1-thread-3任务终止-------2018-07-01 00:00:00====2018-08-01 00:00:00
>>>pool-1-thread-4任务终止-------2018-08-01 00:00:00====2018-12-01 00:00:00
>>>pool-1-thread-2任务终止-------2018-05-01 00:00:00====2018-07-01 00:00:00
>>>pool-1-thread-5任务终止-------2018-12-01 00:00:00====2019-02-01 00:00:00
>>>pool-1-thread-1任务终止-------2018-01-01 00:00:00====2018-05-01 00:00:00
t1:任务返回运行结果,当前任务时间【10008毫秒】
t2:任务返回运行结果,当前任务时间【7007毫秒】
t3:任务返回运行结果,当前任务时间【4007毫秒】
t4:任务返回运行结果,当前任务时间【7007毫秒】
t5:任务返回运行结果,当前任务时间【9008毫秒】