ThreadPoolExecutor实际线程池管理线程

线程池的目的防止线程的随意创建，无法管理，将我们执行的线程放入线程池中执行，实际同时执行的线程数量依赖CPU几核；

1.线程池常用管理处理

并行执行：

threadPool = ThreadPoolManager.getInstance().addParallelTask(new Runnable() {});

串行执行：

threadPool = ThreadPoolManager.getInstance().addSerialTask(new Runnable() {});

package net.sourceforge.simcpux;

import android.util.Log;

import java.util.ArrayDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 线程管理器
 */
public class ThreadPoolManager {
    private static final String LOG_TAG = ThreadPoolManager.class.getSimpleName();
    //CPU的数量
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    /**
     * 在核心线程池至少有2个线程，最多有4线程，比CPU数量少1个避免后台任务使CPU饱和
     */
    private static final int CORE_POOL_SIZE = Math.max(2,Math.min(CPU_COUNT-1,4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT*2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

    /**
     * 线程工厂
     */
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {

        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "ThreadPoolManager #"+mCount.getAndIncrement());
        }
    };

    /**
     * 线程池的工作队列
     */
    private BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

    /**
     * 一个被使用去执行并发任务的线程池
     */
    private ThreadPoolExecutor THREAD_POOL_EXECUTOR;

    /**
     * 线程池以串行顺序一次执行一个任务。此序列化是特定进程的全局序列化。
     */
    private Executor SERIAL_EXECUTOR;

    private volatile Executor sDefaultExecutor;

    private static ThreadPoolManager threadPoolManager;

    private ThreadPoolManager(){
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE_SECONDS,TimeUnit.SECONDS,
                sPoolWorkQueue,sThreadFactory
        );
        //当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;

        SERIAL_EXECUTOR = new SerialExecutor();
        sDefaultExecutor = SERIAL_EXECUTOR;
    }

    public static ThreadPoolManager getInstance(){
        if(threadPoolManager == null){
            synchronized (ThreadPoolManager.class){
                if(threadPoolManager == null){
                    threadPoolManager = new ThreadPoolManager();
                }
            }
        }
        return threadPoolManager;
    }

    /**
     * 串行执行线程任务
     */
    private class SerialExecutor implements Executor{

        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        //当前执行的线程
        Runnable mActive;

        /**
         * ArrayDeque 非线程安全的
         * @param r
         */
        @Override
        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                @Override
                public void run() {
                    try{
                        r.run();
                    }finally {
                        scheduleNext();
                    }
                }
            });
            if(mActive == null){
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext(){
            if((mActive = mTasks.poll()) != null){
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    /**
     * 串行执行
     * @param runnable
     */
    public void addSerialTask(Runnable runnable){
        if(runnable == null){
            throw new NullPointerException("addTask(Runnable runnable)传入参数为空");
        }
        Log.i(LOG_TAG,"目前有"+THREAD_POOL_EXECUTOR.getActiveCount()+"个线程正在进行中,有"+sPoolWorkQueue.size()+"个任务正在排队");
        sDefaultExecutor.execute(runnable);
    }

    /**
     * 并发执行
     * @param runnable
     */
    public void addParallelTask(Runnable runnable){
        if(runnable == null){
            throw new NullPointerException("addTask(Runnable runnable)传入参数为空");
        }
        Log.i(LOG_TAG,"目前有"+THREAD_POOL_EXECUTOR.getActiveCount()+"个线程正在进行中,有"+sPoolWorkQueue.size()+"个任务正在排队");
        THREAD_POOL_EXECUTOR.execute(runnable);
    }

    /**
     * 关闭线程池
     */
    public void stopThreadPool(){
        if(THREAD_POOL_EXECUTOR != null){
            THREAD_POOL_EXECUTOR.shutdown();
            THREAD_POOL_EXECUTOR = null;
        }

        sDefaultExecutor = null;
        threadPoolManager = null;
    }
}

2.线程池工厂类

/**
 * 线程工厂类
 */
public class ThreadFactoryBuilder implements ThreadFactory {
    private String name;
    private AtomicInteger mCount;
//    private int counter;

    public ThreadFactoryBuilder(String name){
        this.name = name;
//        counter = 1;
        mCount = new AtomicInteger(1);
    }


    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r, name);
        thread.setName("ThreadFactoryBuilder_" + name + "_" + mCount.getAndIncrement());
        return thread;
    }
}

Thread线程的状态：

public enum State {
        /**
         * 新建一个线程对象，线程没有调用start()方法之前的状态
         */
        NEW,

        /**
         * Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
         * 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可        
         * 运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状 
         * 态的线程在获得CPU时间片后变为运行中状态（running）。
         */
        RUNNABLE,

        /**
         * 在调用Object.wait()以后等待获取锁synchronized block/method或者重新进入 
         * synchronized  block/method的阻塞状态
         */
        BLOCKED,

        /**
         * 进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
         */
        WAITING,

        /**
         * 该状态不同于WAITING，它可以在指定的时间后自行返回。
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * 表示该线程已经执行完毕;
         */
        TERMINATED;
    }