Android线程池详解

android中经常会用到多线程，因为安卓中如果5S中没有响应就会出现ANR，因此耗时的任务必须放在子线程中使用。这就涉及到UI线程(main线程)和子线程的交互。其二者之间的交互涉及到Handler,Looper,message。
每次创建线程都有系统资源的开销，不可能无限的创建线程，线程过多最终会带来系统的反应速度下降，因此就必须控制线程数量，控制线程的最好办法就是设计线程池，让线程可以重复利用。
下面将会通过三种方式来创建安卓的线程池。
1、通过静态列表缓存10个子线程，创建一个主线程，每个线程中创建唯一Handler，放在子线程的代码。
2、自定义线程池中还是设计一个主线程(UI线程)，同时缓存10个子线程，当然这里创建的子线程采用android提供的HandlerThread来代替上面自定义的线程。采用HandlerThread会更加简便，后续会通过代码进行说明。
3、通过系统提供的ThreadPoolExecutor来设计线程池。

一、自定义Thread来创建线程池。

public class ThreadExtractors {    public class WorkThead extends Thread {        private boolean mIsQuiting = false;        private boolean mIsLoopEnd = false;        Handler myHandler = null;        private final String mThreadId;        public WorkThead(String threadId){            mThreadId = threadId;        }        @Override        public void run() {            //Looper.prepare() 和 Looper.loop()成对存在，创建Handler必须指定looper否则会抛异常            //需要通过synchronized来保证线程安全            Looper.prepare();            synchronized (this){                myHandler = new Handler();                //myHandler创建成功通知所有等待的线程                notifyAll();            }            Looper.loop();        }        public Handler getHandler(){            synchronized (this) {                while (null == myHandler) {                    try {                        //如果myHandler没创建成功，就需要等待，直到myHandler被创建成功                        wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }            return myHandler;        }        public void  quit(){            //退出时需要清除句柄，避免内存泄露            if (mIsQuiting)                return;            mIsQuiting = true;            if (null != myHandler){                //清除message队列及其回调                myHandler.removeCallbacksAndMessages(null);                myHandler.post(new Runnable() {                    @Override                    public void run() {                        Looper.myLooper().quit();                        mIsLoopEnd = true;                    }                });            }        }        public boolean isQuiting(){            return mIsQuiting;        }        public boolean isLoopEnd(){            return this.mIsLoopEnd;        }    }    //最大线程数量    private static final int MAX_TREAD_COUNT = 10;    private static final int minThreadCount = 5;    //当前线程数    private static int currentThreadCount = 0;    //保留的线程数    private static int RETENTION_THREAD_COUNT = 10;    private WorkThead[] retentionThreads;    private static ThreadExtractors THREAD_POOL = null;    private static Handler mainHandler = null;    private ThreadExtractors(){        mainHandler = new Handler(Looper.getMainLooper());        //子线程数目为10个        retentionThreads = new WorkThead[RETENTION_THREAD_COUNT];        for(int i = 0; i < RETENTION_THREAD_COUNT; i ++){            retentionThreads[i] = newThread();        }    }    private WorkThead newThread(){        String threadId = UUID.randomUUID().toString();        WorkThead workThead = new WorkThead(threadId);        workThead.start();        return workThead;    }    public void OnDestroy(){        if (null == retentionThreads)            return;        for (int i = 0, length = retentionThreads.length; i < length; i++){            retentionThreads[i].quit();        }        mainHandler.removeCallbacksAndMessages(null);        retentionThreads = null;        THREAD_POOL = null;    }    public static void extractMainThread(Runnable runnable){        THREAD_POOL.extractMainThread(runnable, 0);    }    public synchronized static void extractMainThread(Runnable runnable, int delayTime){        if (null == THREAD_POOL)            THREAD_POOL = new ThreadExtractors();        THREAD_POOL.mainHandler.postDelayed(runnable, delayTime);    }    public static void extractInThread(Runnable runnable){        THREAD_POOL.extractThread(runnable, 0);    }    public synchronized static void extractThread(Runnable runnable, int delayTime){        if (null == THREAD_POOL)            THREAD_POOL = new ThreadExtractors();        currentThreadCount++;        if(currentThreadCount >= MAX_TREAD_COUNT)            currentThreadCount = 0;        THREAD_POOL.retentionThreads[currentThreadCount].getHandler().postDelayed(runnable, delayTime);    }    private HandlerThread newHandlerThread(){        HandlerThread handlerThread = new CusmHandlerThread(UUID.randomUUID().toString());        handlerThread.start();        return handlerThread;    }    /** HandlerThread内部中已经封装好了线程安全，因此不必担心多线程问题     *     */    public class CusmHandlerThread extends  HandlerThread{        private Handler mMyHandler = null;        public CusmHandlerThread(String name) {            super(name);            mMyHandler = new Handler(this.getLooper());        }        public void setHandler(Handler handler){            mMyHandler = handler;        }        public Handler getHandler(){            return this.mMyHandler;        }    }}

对以上线程池代码进行讲解：
1、从66行 -75行可以看出，本线程池定义了1个主线程，10个子线程。
2、110行 extractMainThread(Runnable runnable, int delayTime)方法中加上同步关键字synchronized，是为了避免多线程安全问题。
3、需要注意子线程类WorkThead的定义，本线程只会创建Handler，创建Handler的时候请注意，每个Handler必须制定唯一的looper，因此如果需要自己创建非主线程的Handler,则必须将其创建放在Looper.prepare() 和 Looper.loop()之间，直到创建完成为止。
4、注意23行的getHandler()加了synchronized，是因为避免获取的时候其还没创建成功。
5、注意37行的quit()函数，退出的时候需要清理资源，避免内存泄露。

有没发现自定义线程WorkThead的实现相对来说比较繁琐，有没有更简便的方法呢？当然是有的，这就需要用到安卓封装的HandlerThread。
1、请查看129行~152行的HandlerThread定义，其功能完全可以代替WorkThead的功能，并且不用理会线程安全及其清理工作， HandlerThread内部会自动的去处理。当然HandlerThread内部也实现了线程安全问题。

下面看看以上设计的线程怎样调用：

        ThreadExtractors.extractMainThread(() ->{            System.out.println("这里的代码是在UI线程执行的，本消息会在主线程的Handler的消息队列中排队处理");        });        ThreadExtractors.extractInThread(() -> {            System.out.println("这里的代码是在非主线程中执行的，本消息会在非主线程的Handler的消息队列中排队处理");        });

本代码中采用了JAVA8中的新特性拉姆表达式，不熟悉的谷歌一下。
需要在主线程或者子线程执行，直接套用以上方法即可，当然每个线程post的messge会在当前线程的handler中进行排队，并且是顺序执行的。