Android中线程池的原理和应用

线程池原理

• 要了解线程池原理，不如自己动手写个线程池吧

public class ThreadPool {
            int maxCount = 3;//限制线程最大数目
            AtomicInteger count =new AtomicInteger(0);// 当前开的线程数  count=0，为了线程同步
            LinkedList<Runnable> runnables = new LinkedList<Runnable>();//Runnable泛型集合存放Runnable对象
        /**
        *1.将要执行任务添加到list缓存
        *2、当前开的线程数（原子变量）++
        *3、判断当前开的线程数小于等于最大数目，则创建新线程
        *count.incrementAndGet():increment是++;Get拿到当前count值
        */
            public void execute(Runnable runnable) {
                runnables.add(runnable);//任务添加到list缓存
                if(count.incrementAndGet()<=3){
                    createThread();
                }
            }
        /**
        *要开启的线程内情况：
        *1、判断Runnable集合大小，不为空，取出来那个异步任务
        *2、任务不为空，就放在线程内执行
        *3、任务集合为空，即任务都执行完了，此时线程等待
        */
            private void createThread() {
                new Thread() {
                    @Override
                    public void run() {
                        super.run();
                        while (true) {
                            // 取出来一个异步任务
                            if (runnables.size() > 0) {
                                Runnable remove = runnables.remove(0);
                                if (remove != null) {
                                    remove.run();
                                }
                            }else{
                                //  等待状态   wake();
                            }
                        }
                    }
                }.start();
            }
        }

线程池应用

- 写个工具类ThreadManager

/**
 * 管理线程池
 *
 * @author stephen
 *
 */
public class ThreadManager {
    private ThreadManager() {

    }

    private static ThreadManager instance = new ThreadManager();
    private ThreadPoolProxy longPool;
    private ThreadPoolProxy shortPool;

    public static ThreadManager getInstance() {
        return instance;
    }

    // 联网比较耗时
    // cpu的核数*2+1
    public synchronized ThreadPoolProxy createLongPool() {
        if (longPool == null) {
            longPool = new ThreadPoolProxy(5, 5, 5000L);
        }
        return longPool;
    }
    // 操作本地文件
    public synchronized ThreadPoolProxy createShortPool() {
        if(shortPool==null){
            shortPool = new ThreadPoolProxy(3, 3, 5000L);
        }
        return shortPool;
    }

    public class ThreadPoolProxy {
        private ThreadPoolExecutor pool;
        private int corePoolSize;
        private int maximumPoolSize;
        private long time;

        public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.time = time;

        }
        /**
         * 执行任务
         * @param runnable
         */
        public void execute(Runnable runnable) {
            if (pool == null) {
                // 创建线程池
                /*
                 * 1. 线程池里面管理多少个线程2. 如果排队满了, 额外的开的线程数3. 如果线程池没有要执行的任务 存活多久4.
                 * 时间的单位 5 如果 线程池里管理的线程都已经用了,剩下的任务 临时存到LinkedBlockingQueue对象中 排队
                 */
                pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
                        time, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>(10));
            }
            pool.execute(runnable); // 调用线程池 执行异步任务
        }
        /**
         * 取消任务
         * @param runnable
         */
        public void cancel(Runnable runnable) {
            if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
                pool.remove(runnable); // 取消异步任务
            }
        }
    }
}

- 在其他类中应用线程池执行异步任务

ThreadManager.getInstance().createLongPool().execute(new Runnable() {

            @Override
            public void run() {
            //要处理的任务细节
            }
}）；