Java主线程等待线程池所有任务完成--线程池的封装

来源：互联网发布：淘宝能买到阿普唑仑吗编辑：程序博客网时间：2024/05/16 16:11

用线程池编写多线程程序时，当所有任务完成时，要做一些统计的工作。而统计工作必须要在所有任务完成才能做。所以要让主线程等待所有任务完成。可以使用ThreadPoolExecutor.awaitTermination(long timeout, TimeUnit unit)。

封装的线程池

public interface BaseExecutor {    /**     * @Title: initial     * @Description: 初始化组件     * @return: void     */    void initial();    /**     * @Title: shutdown     * @Description: 关机     * @return: void     */    void shutdown();    /**     *      * @Title: startup     * @Description: 开启线程池     * @return: void     */    void startup();    /**     * @Title: execute     * @param callable     * @throws Exception     * @return: void     */    void execute(Callable<T> callable) throws Exception;    /**     *      * @Title: setThreadSize     * @Description: 设置线程池里面核心线程的大小     * @param thread_size     * @return: void     */    public void setThreadSize(int thread_size);}

计算线程池的实现

public class ComputerExecutor implements BaseExecutor {    private ThreadPoolExecutor executor = null;    private int DEFAULT_CORE_SIZE = 8; // 默认核心线程数    private final int MAXIMUMPOOLSIZE = 50; // 默认最大线程数    private long keepAliveTime = 30000; // 当线程池中的线程数量大于                                        // corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。    @Override    public void initial() {        executor = new ThreadPoolExecutor(DEFAULT_CORE_SIZE, MAXIMUMPOOLSIZE, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());    }    @Override    public void shutdown() {        executor.shutdown();        try {            // 当线程池中的所有任务执行完毕时,就会关闭线程池            while (!executor.awaitTermination(2, TimeUnit.SECONDS))                ;        } catch (InterruptedException e) {            e.printStackTrace();        }    }    @Override    public void startup() {        this.initial();    }    @Override    public void execute(Callable<T> callable) throws Exception {        process(callable);    }    private void process(Callable<T> callable) {        FutureTask<T> future = new FutureTask<T>((Callable<T>) callable);        executor.execute(future);    }    public void setThreadSize(int thread_size) {        this.DEFAULT_CORE_SIZE = thread_size;    }}

计算任务的封装

public class CustomizeIndicatorComputerCallable<T> implements Callable<T>{    @Autowired    private CorplutionIndicatorReportFacade corplutionIndicatorReportFacade;    private static Logger logger = Logger.getLogger(CustomizeIndicatorComputerCallable.class);    private int bound_size = 10; //信号量--并发队列大小     private Semaphore semaphore = null;    private Object[] args;    public CustomizeIndicatorComputerCallable(            int bound, Semaphore semaphore,  Object ...args) {        this.bound_size = bound;        this.semaphore = semaphore;        this.args = args;        @SuppressWarnings("resource")        ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:/META-INF/spring/*.xml");        corplutionIndicatorReportFacade = (CorplutionIndicatorReportFacade)context.getBean("corplutionIndicatorReportFacade");    }    public T call() throws Exception {        semaphore.acquire();        try {            logger.info("线程 ["+Thread.currentThread().getId()+"]线进入, 当前并发数 ["+ (bound_size - semaphore.availablePermits()) +"]");            CorplutionIndicatorReportDO corplutionIndicatorReportDO = (CorplutionIndicatorReportDO)args[0];            CorplutionCostomizeIndicator costomizeIndicator = (CorplutionCostomizeIndicator)args[1];            corplutionIndicatorReportFacade.computerCustomizeIndicator(corplutionIndicatorReportDO , costomizeIndicator);        } catch (Exception e) {            logger.info("线程池处理失败", e);            throw e;        }        finally{            semaphore.release();            logger.info("线程  ["+Thread.currentThread().getId()+"] 离开,当前并发数 [ "+ (bound_size - semaphore.availablePermits()) +"]");        }        return null;    }}

阅读全文

1 0