Callable日常使用

Callable日常使用

前言 之前在项目中有个多线程校验导入数据的额需求，就想到了callable，既有返回值又可以抛出异常，岂不美哉！工作之余总结下callable的使用，方便后期CV。

一、自定义callable的实现类，实现自己的业务

import java.util.concurrent.Callable;

/**
 * 自定义callable逻辑
 */
public class MyCallable implements Callable<String> {
    //超时时间
    Integer sleepTime;
    //含参构造
    public  MyCallable(Integer sleepTime){
        this.sleepTime =sleepTime;
    }
    //重写call方法
    @Override
    public String call() throws Exception {
        //模拟线程执行时所需时间
        Thread.sleep(sleepTime);
        System.out.println(Thread.currentThread().getName()+"启动了==================================");
        //返回结果
        return Thread.currentThread().getName()+"  ";
    }
}

二、测试类，callable正常使用的情况

import javax.swing.*;
import javax.swing.plaf.metal.MetalIconFactory;
import java.lang.reflect.Executable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 测试callable线程
 */
public class CallableTest {

   /*
    * callable正常使用的情况
    */
    private static String callTest() throws Exception {
        //用于接受callable的返回参数
        StringBuffer stringBuffer = new StringBuffer();
        //模拟一个用时100ms的代码逻辑
        FutureTask futureTask1 = new FutureTask(new MyCallable(100));
        //模拟一个用时200ms的代码逻辑
        FutureTask futureTask2 = new FutureTask(new MyCallable(200));
        //创建两个线程同时处理
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        try {
            thread1.start();
            thread2.start();
            //分别获取结果
            stringBuffer.append(futureTask1.get());
            stringBuffer.append(futureTask2.get());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭线程
            thread1.interrupt();
            thread2.interrupt();
        }

        return new String(stringBuffer);
    }
    
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        try {
            System.out.println(callTest());
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("项目用时：" + (endTime - startTime));
    }
}

运行结果： 正常需要运行300多ms的代码只用了200多ms，是用时最多的线程执行结束后执行剩余代码的所用时长!

三、测试类，加强callable在for循环下使用

import javax.swing.*;
import javax.swing.plaf.metal.MetalIconFactory;
import java.lang.reflect.Executable;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 测试callable线程
 */
public class CallableTest {

    /*
     * for 循环中callable的使用
     */
    private static String callTest1() throws Exception {
        //用于接受callable的返回参数
        StringBuffer stringBuffer = new StringBuffer();
        //创建一个大小为10的固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //用于存放执行的callable
        List<Future<String>> futureList = new ArrayList<>();
        //模拟循环20次业务逻辑
        for (int i = 0; i < 20; i++) {
            //每次业务逻辑的用时为100ms
            futureList.add(executorService.submit(new MyCallable(100)));
        }
        //从futureList获取callable的结果
        for (int j = 0; j < futureList.size(); j++) {
            stringBuffer.append(futureList.get(j).get());
        }
        //返回结果
        return new String(stringBuffer);
    }



    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        try {
            System.out.println(callTest1());
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("项目用时：" + (endTime - startTime));
    }
}

运行结果： 正常需要运行2000多ms的代码只用了200多ms，将20个逻辑分10个线程处理!

四、测试类，加强callable在for循环下使用（自定义线程池版）

import javax.swing.*;
        import javax.swing.plaf.metal.MetalIconFactory;
        import java.lang.reflect.Executable;
        import java.util.ArrayList;
        import java.util.List;
        import java.util.concurrent.*;

/**
 * 测试callable线程
 */
public class CallableTest {

    /*
     * for 循环中callable的使用（自定义线程池版）
     */
    private static String callTest2() throws Exception {
        //用于接受callable的返回参数
        StringBuffer stringBuffer = new StringBuffer();
        //自定义线程池
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(
                        4,//核心线程数
                        6,//最大线程数
                        3,//线程空闲时间
                        TimeUnit.SECONDS, //单位（我设置的是秒）
                        new ArrayBlockingQueue<>(6),//工作队列（我设置的是有界队列）
                        Executors.defaultThreadFactory(),//线程的工厂
                        new ThreadPoolExecutor.CallerRunsPolicy());//拒绝策略（只用调用者所在线程来运行任务）
        //用于存放执行的callable
        List<Future<String>> futureList = new ArrayList<>();
        //模拟循环20次业务逻辑
        for (int i = 0; i < 20; i++) {
            //每次业务逻辑的用时为100ms
            futureList.add(threadPoolExecutor.submit(new MyCallable(100)));
        }
        //从futureList获取callable的结果
        for (int j = 0; j < futureList.size(); j++) {
            stringBuffer.append(futureList.get(j).get());
        }
        //返回结果
        return new String(stringBuffer);
    }

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        try {
            System.out.println(callTest2());
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("项目用时：" + (endTime - startTime));
    }
}

运行结果：

五、总结

使用线程要注意：
1、用完要记得关闭线程
2、自定义线程池时要查看cpu和硬盘配置再定核心线程数量