线程池_线程池csdn-CSDN博客

本文链接：https://blog.csdn.net/Demo006/article/details/78622180

学之广在于不倦，不倦在于固志。 ——晋·葛洪

（学问的渊博在于学习时不知道厌倦，而学习不知厌倦在于有坚定的目标）

拉两篇学习：

第一篇：分析及实战

第二篇：源码分析及实战

创建线程的问题：

1.针对每一个item都创建一个新线程，这样会导致频繁的创建线程，线程执行完之后又被回收，又会导致频繁的GC

2.这么多线程缺乏统一管理，各线程之间互相竞争，降低程序的运行效率，手机页面卡顿，甚至会导致程序崩溃

3.如果一个item滑出页面，则要停止该item上图片的加载，但是如果使用这种方式来创建线程，则无法实现线程停止执行

线程池的好处：

1.重用已经创建的好的线程，避免频繁创建进而导致的频繁GC

2.控制线程并发数，合理使用系统资源，提高应用性能

3.可以有效的控制线程的执行，比如定时执行，取消执行等

建议使用线程池执行耗时操作

阿里规范关于线程和线程池的解释：

        避免Random实例被多线程使用，虽然共享该实例是线程安全的，但会因竞争同一seed 导致的性能下降。说明：Random实例包括java.util.Random 的实例或者 Math.random()的方式。
说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问

下面封装一篇<推荐使用这种方式>：

/**
 * Created by Okamiy on 2017/11/24.
 * 封装线程池:懒汉式
 */

public class ThreadPoolManager {

    private static ThreadPoolManager instance;
    /**
     * 线程池中核心线程的数量
     */
    private int corePoolSize;
    /**
     * 线程池中最大线程数量
     */
    private int maximumPoolSize;
    /**
     * 非核心线程的超时时长，当系统中非核心线程闲置时间超过keepAliveTime之后，则会被回收。如果
     * ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true，则该参数也表示核心线程的超时时长
     */
    private long keepAliveTime;
    /**
     * 第三个参数的单位，有纳秒、微秒、毫秒、秒、分、时、天等
     */
    private TimeUnit unit;
    /**
     * 线程池中的任务队列，该队列主要用来存储已经被提交但是尚未执行的任务。存储在这里的任务是由
     * ThreadPoolExecutor的execute方法提交来的
     */
    private BlockingQueue<Runnable> workQueue;
    /**
     * 为线程池提供创建新线程的功能，这个我们一般使用默认即可
     */
    private ThreadFactory threadFactory;
    /**
     * 拒绝策略，当线程无法执行新任务时（一般是由于线程池中的线程数量已经达到最大数或者线程
     * 池关闭导致的），默认情况下，当线程池无法处理新线程时，会抛出一个RejectedExecutionException
     */
    private RejectedExecutionHandler handler;

    private ThreadPoolExecutor executor;

    private ThreadPoolManager() {
        /**
         * 给corePoolSize赋值：当前设备可用处理器核心数*2 + 1,能够让cpu的效率得到最大程度执行（有研究论证的）
         * 当某个核心任务执行完毕，会依次从缓冲队列中取出等待任务
         */
        corePoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1;

        //虽然maximumPoolSize用不到，但是需要赋值，否则报错
        maximumPoolSize = corePoolSize;

        keepAliveTime = 0;

        unit = TimeUnit.MILLISECONDS;

        workQueue = new LinkedBlockingDeque<Runnable>(1024);

        //创建线程的工厂,借助阿里的，指定线程名称，方便查找错误
        threadFactory = new ThreadFactoryBuilder().setNameFormat("okamiy_thread").build();

        handler = new ThreadPoolExecutor.AbortPolicy();

        executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, threadFactory, handler);
    }

    /**
     * 单例模式
     *
     * @return
     */
    public static ThreadPoolManager getInstance() {
        if (null == instance) {
            synchronized (ThreadPoolManager.class) {
                if (null == instance) {
                    instance = new ThreadPoolManager();
                }
            }
        }
        return instance;
    }

    /**
     * 执行任务
     */
    public void execute(Runnable runnable) {
        if (runnable == null) {
            return;
        }
        executor.execute(runnable);
    }

    /**
     * 从线程池中移除任务
     */
    public void remove(Runnable runnable) {
        if (runnable == null) {
            return;
        }        executor.getQueue().remove(runnable);
    }}

项目实战：

/**
 * 使用线程池模拟下载
 */
public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        testThread();

    }

    private void testThread() {
        //模拟执行下载任务
        int task = 30;
        for (int i = 0; i < task; i++) {
            ThreadPoolManager.getInstance().execute(new MyRunable(i));
        }
    }

    /**
     * 模拟下载，实现Runable接口
     */
    private class MyRunable implements Runnable {

        private final int taskNum;

        public MyRunable(int taskNum) {
            super();
            this.taskNum = taskNum;
            Log.i(TAG, "task - " + taskNum + "等待中...");
        }

        @Override
        public void run() {
            try {
                Log.i(TAG, ":Thread name:" + Thread.currentThread().getName() + ",task - " + taskNum + " 开始执行了...");
                //模拟下载
                Thread.sleep(3000);
                Log.i(TAG, ":Thread name:" + Thread.currentThread().getName() + ", task - " + taskNum + " 结束了...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}