android自定义线程池

清疚 2021-09-20 11:24 453阅读 0赞

使用环境：

开启子线程的时候

使用方法：

import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.RejectedExecutionHandler;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Created by sensyang.
     * on 2018/10/9 0009.
     */
    
    public class BHThreadPool {
    
        ThreadPoolExecutor threadPoolExecutor;
        int corePoolSize;
        int maximumPollSize;
        long keepAliveTime;
        public static BHThreadPool instance;
    
        public static BHThreadPool getInstance() {
            if (instance == null) {
                instance = new BHThreadPool(1,1,1000);
            }
            return instance;
        }
    
        public BHThreadPool(int corePoolSize, int maximumPollSize, long keepAliveTime){
            this.corePoolSize = corePoolSize;
            this.maximumPollSize = maximumPollSize;
            this.keepAliveTime = keepAliveTime;
        }
    
        public ThreadPoolExecutor initExecutor(){
            if (threadPoolExecutor == null) {
                synchronized (BHThreadPool.class){
                    TimeUnit unit =  TimeUnit.MILLISECONDS;
                    ThreadFactory threadFactory = Executors.defaultThreadFactory();
                    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
                    LinkedBlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
    
                    threadPoolExecutor = new ThreadPoolExecutor(
                            //核心线程数
                            corePoolSize,
                            //最大线程数
                            maximumPollSize,
                            //保持时间
                            keepAliveTime,
                            //保持时间对应的单位
                            unit,
                            workQueue,
                            threadFactory,
                            handler
                    );
                }
            }
            return threadPoolExecutor;
        }
    
        /**
         * 执行任务
         */
        public void executeTask(Runnable runnable){
            initExecutor();
            threadPoolExecutor.execute(runnable);
        }
    
        /**
         * 提交任务
         */
        public Future<?> commitTask(Runnable runnable){
            initExecutor();
            return threadPoolExecutor.submit(runnable);
        }
    
        /**
         * 删除任务
         * removeTask（）方法起作用有一个必要的前提，就是这个任务还没有开始执行，
         * 如果已经开始执行了，就停止不了该任务了，这个方法就不会起作用
         */
        public void removeTask(Runnable runnable){
            initExecutor();
            threadPoolExecutor.remove(runnable);
        }
    
        /**
         * 关闭线程池操作的方法
         */
        public void closeThread(){
            threadPoolExecutor.shutdownNow();
        }
    
        /**
         * 线程池用法
         * 1 BHThreadPool 线程池对象
         * 2 runnable
         * 3 将runnable添加到BHThreadPool线程池中去
         */
    
        //    BHThreadPool BHThreadPool = new BHThreadPool(1,1,1000);
        //    Runnable runnable = new Runnable() {
        //        @Override
        //        public void run() {
        //    可执行发动handler操作
        //            Log.e("log", "子线程操作");
        //        }
        //    };
        //
        //    BHThreadPool.executeTask(runnable);
    
    
    
    }

线程池常用四种，怎么用看自己的选择，这里只是做一个记录罢了。