自定义带返回参数和没有返回参数的线程池

自定义带返回参数和没有返回参数的两种线程池

1. 自定义线程池的名称

/**
 * 自定义现场池的名称时有四种方式：
 *  1：Spring 框架提供的 CustomizableThreadFactory
 *      private ThreadFactory springThreadFactory = new CustomizableThreadFactory("springThread-pool-");
 *  2：Google guava 工具类 提供的 ThreadFactoryBuilder ,使用链式方法创建
 *      private ThreadFactory guavaThreadFactory = new ThreadFactoryBuilder().setNameFormat("retryClient-pool-").build();
 *  3：Apache commons-lang3 提供的 BasicThreadFactory
 *      private ThreadFactory basicThreadFactory = new BasicThreadFactory.Builder().namingPattern("basicThreadFactory-").build();
 *  4：自定义一个ThreadFactory。方法如下
 *
 * ----------------------------------------------
 */
public class NamesThreadFactory implements ThreadFactory {
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public NamesThreadFactory(String name){
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        if (null == name || name.isEmpty()) {
            name = "my-pool";
        }
        namePrefix = name + "-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

2. 自定义线程基础类（使用 implements Callable来实现带有返回参数的线程池）

public class CustomizedThreadPool extends ThreadPoolExecutor{

    private ExecutorService executorService;

    public CustomizedThreadPool(int corePoolSize,
                                int maximumPoolSize,
                                long keepAliveTime,
                                TimeUnit unit,
                                BlockingQueue<Runnable> workQueue,
                                ThreadFactory threadFactory,  //new NamesThreadFactory("myself-test")
                                RejectedExecutionHandler handler
                                ) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit,workQueue, threadFactory, handler);
        executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
    }
	//调用实现Callable<Boolean> callable 接口的有返回参数的线程方法
    public Future<Boolean> submits(Callable<Boolean> callable) {
        return executorService.submit(callable);
    }
    //调用实现 Runnable 接口的有返回参数的线程方法
    public Future<?> submit(Runnable runnable) {
        return executorService.submit(runnable);
    }
}

3. 自定义线程池

/**
* new NamesThreadFactory("mytestThread"),这个参数是用来自定义线程池的，也可以使用上面代码片段来实现快速自定义线程池。
*/
public class ExecuteThreadTest {
 	private CustomizedThreadPool customizedThreadPool = new CustomizedThreadPool(
             50,100,600,TimeUnit.SECONDS,
             new LinkedBlockingQueue<>(),new NamesThreadFactory("mytestThread"),new ThreadPoolExecutor.CallerRunsPolicy()
    );
}

public class MyDefineThreadPool implements Callable<Boolean> {
        private String code;
        private String name;
        public MyDefineThreadPool(String code,String name){
            this.code= code;
            this.name= name;
        }
        @Override
        public Boolean call() throws Exception {
            try {
                System.out.println("====执行业务逻辑====start====");
                System.out.println("code: " + code+ "name: " + name);
                System.out.println("线程名称为：" +Thread.currentThread().getName());
                System.out.println("====执行业务逻辑====end====");
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
            return true;
        }
    }

/**
* 将线程任务提交到线程池
*/
public void execute(){
        List<Future<Boolean>> futures = new LinkedList();
        Future<Boolean> future;
        //手动提交10个任务给线程池，这里可以用自己的业务逻辑来替代
         for(int i =0;i<=9 ;i++){
            future = customizedThreadPool.submits(new MyDefineThreadPool("test", "测试"));
            futures.add(future);
         //调用Runnable实现的无返回参数的线程池
		 //customizedThreadPool.submit(new MyRunnableThreadPool("testService", "测试"));

        }
         boolean computeSucceed = Boolean.TRUE;
         try {
             // 判断线程返回结果中是否存储执行异常的结果
             for (Future<Boolean> resultFuture : futures) {
                 Boolean threadResult = resultFuture.get();
                 if (!threadResult ) {
                     computeSucceed = Boolean.FALSE;
                     break;
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         if(!computeSucceed){
             System.out.println("线程执行存在异常了===========");
         }

     }

4. 直接可以使用main方法去调用execute方法来测试了。
5. 1-4中使用的是使用implements Callable来实现了带有返回参数的线程池，同时也可以使用Runnable来实现不带返回参数的线程池。

/**
     * 使用Runnable来实现线程池
     * 没有返回参数
     */
    public class MyRunnableThreadPool implements Runnable{
        private String code;
        private String name;
        public MyRunnableThreadPool(String code,String name){
            this.code= code;
            this.name= name;
        }
        @Override
        public void run() {
            try {
                System.out.println("====执行业务逻辑===Runnable =start====");
                System.out.println("code: " + code + "name: " + name);
                System.out.println("线程名称为：" +Thread.currentThread().getName());
                System.out.println("====执行业务逻辑===Runnable =end====");
            } catch (Exception e) {
                e.printStackTrace();
             }
         }
    }