工具篇——ThreadPoolUtil（用于进行线程的管理，防止重复创建、杀死线程）

代码如下：

package com.wy.test.other;

import android.support.annotation.NonNull;

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.AtomicInteger;

/**

* 线程池的工具类

* 用于进行线程的管理，防止重复创建、杀死线程。

* 


* 多线程运行期间，如果系统不断的创建、杀死新线程，

* 会产生过度消耗系统资源，以及过度切换线程的问题，甚至可能导致系统资源的崩溃。

* 因此需要线程池，对线程进行管理。

*/

public class ThreadPoolUtil {

    private String TAG = getClass().getName();

    private static volatile ThreadPoolUtil mInstance;

    //核心线程池的数量，同时能够执行的线程数量

    private int corePoolSize;

    //最大线程池数量，表示当缓冲队列满的时候能继续容纳的等待任务的数量

    private int maxPoolSize;

    //存活时间

    private long keepAliveTime = 1;

    private TimeUnit unit = TimeUnit.HOURS;

    private ThreadPoolExecutor executor;

    private ThreadPoolUtil() {

        //给corePoolSize赋值：当前设备可用处理器核心数*2 + 1,能够让cpu的效率得到最大程度执行（有研究论证的）

        corePoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1;

        maxPoolSize = corePoolSize;

        executor = new ThreadPoolExecutor(

                //当某个核心任务执行完毕，会依次从缓冲队列中取出等待任务

                corePoolSize,

                // 然后new LinkedBlockingQueue(),然后maximumPoolSize,但是它的数量是包含了corePoolSize的

                maxPoolSize,

                //表示的是maximumPoolSize当中等待任务的存活时间

                keepAliveTime,

                unit,

                //缓冲队列，用于存放等待任务，Linked的先进先出

                new LinkedBlockingQueue(),

                new DefaultThreadFactory(Thread.NORM_PRIORITY, "thread-pool-"),

                new ThreadPoolExecutor.AbortPolicy()

        );

    }

    public static ThreadPoolUtil getInstance() {

        if (mInstance == null) {

            synchronized (ThreadPoolUtil.class) {

                if (mInstance == null) {

                    mInstance = new ThreadPoolUtil();

                }

            }

        }

        return mInstance;

    }

    /**

     * 执行任务

     *

     * @param runnable

     */

    public void execute(Runnable runnable) {

        if (executor == null) {

            executor = new ThreadPoolExecutor(

                    corePoolSize,

                    maxPoolSize,

                    keepAliveTime,

                    TimeUnit.SECONDS,

                    new LinkedBlockingQueue(),

                    new DefaultThreadFactory(Thread.NORM_PRIORITY, "thread-pool-"),

                    new ThreadPoolExecutor.AbortPolicy());

        }

        if (runnable != null) {

            executor.execute(runnable);

        }

    }

    /**

     * 移除任务

     *

     * @param runnable

     */

    public void remove(Runnable runnable) {

        if (runnable != null) {

            executor.remove(runnable);

        }

    }

    private static class DefaultThreadFactory implements ThreadFactory {

        //线程池的计数

        private static final AtomicInteger poolNumber = new AtomicInteger(1);

        //线程的计数

        private final AtomicInteger threadNumber = new AtomicInteger(1);

        private final ThreadGroup group;

        private final String namePrefix;

        private final int threadPriority;

        DefaultThreadFactory(int threadPriority, String threadNamePrefix) {

            this.threadPriority = threadPriority;

            this.group = Thread.currentThread().getThreadGroup();

            this.namePrefix = threadNamePrefix + poolNumber.getAndIncrement() + "-thread-";

        }

        @Override

        public Thread newThread(@NonNull Runnable r) {

            Thread thread = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);

            // 返回True该线程就是守护线程

            // 守护线程应该永远不去访问固有资源，如：数据库、文件等。因为它会在任何时候甚至在一个操作的中间发生中断。

            if (thread.isDaemon()) {

                thread.setDaemon(false);

            }

            thread.setPriority(threadPriority);

            return thread;

        }

    }

}

在项目中的应用：

//使用线程池工具处理耗时操作

ThreadPoolUtil.getInstance().execute(new Runnable() {

    @Override

    public void run() {

        //在此执行耗时操作

        //例如：文件下载、数据库存取、音频格式转换等

    }

});

---

早计划，早准备，早完成。 欢迎关注！交流！Star！

GitHub：https://github.com/wangyang0313

微信公众号：一个灵活的胖子MrWang

CSDN：https://blog.csdn.net/qq941263013

20200430145304899.jpg