Android多线程操作——线程池管理综述

1 前言

android开发，大家最熟悉的肯定是主线程，也就是ui线程，也都知道在非ui线程更新界面会报错提示不允许在子线程更新ui。但是耗时操作还是需要使用子线程，如：

new Thread(new Runnable() {
    @Override
    public void run() {
        // 耗时任务
    }
}).start();

这种写法感觉简单便捷，但是在存在很大的弊端

1 如果某个地方需要开启大量的线程。创建线程和销毁线程是需要时间的，这样会导致性能不足
2 线程无法管理，相互竞争导致卡顿或者oom
3 功能太过单一

 2 线程池

针对以上问题，提出线程池

1 重用存在的线程，减少对象创建、消亡的开销，性能佳
2 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
3 提供定时执行、定期执行、单线程、并发数控制等功能

3 官方提供了几种默认的线程池

        //该线程池默认创建了3 个线程
        ExecutorService lExecutorService = Executors.newFixedThreadPool(3);
        //添加10个任务
        for (int lI = 0; lI < 10; lI++) {
            lExecutorService.execute(new Runnable() {
                @Override
                public void run() {
                    //异步任务
                }
            });
        }

        
        ScheduledExecutorService lExecutorService = Executors.newSingleThreadScheduledExecutor();
        //延迟1秒后执行第一次任务，之后每隔1秒执行一次
        lExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                //异步任务
            }
        },1,2,TimeUnit.SECONDS);

        ScheduledExecutorService lExecutorService = Executors.newSingleThreadScheduledExecutor();
        for (int lI = 0; lI < 10; lI++) {
            //每个任务被延迟1秒执行一次
            lExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    //异步任务
                }
            }, 1, TimeUnit.SECONDS);
        }
    }

4 自定义线程池 

public class CustomExpanThreadPool extends ThreadPoolExecutor {
 
    private CustomExpanThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
 
    public static CustomExpanThreadPool getInstance() {

        //获取CPU数量
        int processors = Runtime.getRuntime().availableProcessors();
        //核心线程数量
        int corePoolSize = processors + 1;
        //最大线程数量
        int maximumPoolSize = processors * 2 + 1;
        //空闲有效时间
        long keepAliveTime = 60;
        //创建自定义线程池
        return new CustomExpanThreadPool(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, new PriorityBlockingQueue());
 
    }
 
    /**
     * 用于控制线程开始与停止执行的方法
     */
    private boolean isPaused;
    private ReentrantLock pauseLock = new ReentrantLock();
    private Condition unpaused = pauseLock.newCondition();
 
 
    /**
     * 任务执行前要执行的方法
     *
     * @param t
     * @param r
     */
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        System.out.println(Thread.currentThread().getName() + "  任务执行开始 ");
        pauseLock.lock();
        try {
            while (isPaused) unpaused.await();
        } catch (InterruptedException ie) {
            t.interrupt();
        } finally {
        }
    }
 
    /**
     * 任务执行后要执行的方法
     *
     * @param r
     * @param t
     */
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        System.out.println(Thread.currentThread().getName() + "  任务执行over ");
    }
 
    /**
     * 线程池关闭后要执行的方法
     */
    @Override
    protected void terminated() {
        super.terminated();
    }
 
    /**
     * 暂停执行任务的方法
     */
    public void pause() {
        pauseLock.lock();
        try {
            isPaused = true;
        } finally {
            pauseLock.unlock();
        }
    }
 
    /**
     * 恢复执行任务的方法
     */
    public void resume() {
        pauseLock.lock();
        try {
            isPaused = false;
            unpaused.signalAll();
        } finally {
            pauseLock.unlock();
        }
    }
}

5 自定义Runnable 

此Runnable可设置优先级

 public abstract class CustomRunnable implements Runnable,Comparable<CustomRunnable> {
        private int priority;
 
        public CustomRunnable(int priority) {
            if (priority<0)
            throw new IllegalArgumentException();
            this.priority = priority;
        }
 
        @Override
        public int compareTo(CustomRunnable another) {
            int my = this.getPriority();
            int other = another.getPriority();
            if (my>other){
                return  -1;
            }else{
                return 0;
            }
 
        }
 
 
 
        @Override
        public void run() {
            doRun();
        }
 
        public abstract void doRun();
 
        public int getPriority() {
            return priority;
        }
    }

6 结合使用

 private void customThreadFunction2() {
 
        CustomExpanThreadPool threadPoolExecutor = CustomExpanThreadPool.getInstance();
 
        /**
         * 添加执行任务
         */
        for (int i=1;i<=20;i++){
            final int prites = i;
            threadPoolExecutor.execute(new CustomRunnable(prites){
 
                @Override
                public void doRun() {
 
                    String name = Thread.currentThread().getName();
                    System.out.println("curentThread name is "+name +"and prites is "+prites);
                    SystemClock.sleep(1000);
 
                }
            });
        }
    }