android-线程池-最顺手的写法

引子

关于线程池，在这里写出几种最顺手的写法，至于原理以及各种细节。放后面再填；

经过查证，凡是 以前new Thread（）的地方，貌似都可以用线程池来执行，优化内存消耗。

代码

系统提供的4种预设线程池类：

　　　　 Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Log.d("atm", "假装有执行过程·");
            }
        };

        //第一类
        // 全部由核心线程去实现，并不会被回收，没有超时限制和任务队列的限制，会创建一个定长线程池，
        // 可控制线程最大并发数，超出的线程会在队列中等待
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        fixedThreadPool.execute(runnable);

        //第二类
        //该模式下线程数量不定的线程池，只有非核心线程，最大值为Integer.MAX_VALUE，会创建一个可缓存线程池，
        // 如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        cachedThreadPool.execute(runnable);

        //第三类
        //该模式下核心线程是固定的，非核心线程没有限制，非核心线程闲置时会被回收。
        // 会创建一个定长线程池，执行定时任务和固定周期的任务
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        scheduledThreadPool.schedule(runnable, 2000, TimeUnit.SECONDS);//2000ms后执行。
        scheduledThreadPool.scheduleAtFixedRate(runnable, 10, 1000, TimeUnit.MILLISECONDS);//延迟10ms后，每隔1000ms执行一次

        //第四类,
        //该模式下线程池内部只有一个线程，所有的任务都在一个线程中执行，会创建一个单线程化的线程池，
        // 它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        singleThreadExecutor.execute(runnable);

不用系统的，而是自己定义各种参数：

import android.support.annotation.NonNull;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 */
public class CustomThreadPool {

    private static final int CORE_POOL_SIZE = 3;//核心线程数目
    private static final int MAX_POOL_SIZE = 20;//最大线程数，除了核心线程就是非核心线程
    private static final int ALIVE_TIME = 5;//非核心线程允许闲置的最大时长

    private static final CustomThreadPool instance;

    private final ThreadPoolExecutor pool;

    static {
        instance = new CustomThreadPool();
    }

    private CustomThreadPool() {
        //参数逐个解析
        /**
         * @param 核心线程的数目，即使他们是闲置状态，也不会被回收，除非你设置 allowCoreThreadTimeOut，让核心线程也有超时时间（不过一般不这么做）
         * @param 线程池的最大容量，可以容纳核心线程和非核心线程
         * @param 当线程数目大于核心线程数，这个值是被回收的最大闲置时间，超出则会被回收
         * @param 超时时间的单位（一般用秒，或者毫秒）
         * @param 等待队列，当核心线程都在工作，而又有新的任务需要执行，这些任务则会先进入等待队列（但是如果进不去，或者队列满了，就会尝试用非核心线程）
         * @param 生成线程的工厂(一般都会自己new 一个类继承ThreadFactory)
         * @throws IllegalArgumentException 参数异常
         *         可能抛出的异常，
         *         比如，你把核心线程数设置为负数；
         *         或者超时时间设置为负数
         *         或者最大线程数是非正数；
         *         或者最大线程数小于 核心线程数
         * @throws NullPointerException
         *         当 工作队列是空，或者 线程工厂，对象是空，就会报空指针
         */
        pool = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, ALIVE_TIME, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(), new MyThreadFactory());
    }

    public static CustomThreadPool getInstance() {
        return instance;
    }

    /**
     * 执行，无返回值
     *
     * @param r
     */
    public void execute(Runnable r) {
        pool.execute(r);
    }

    /**
     * 提交，有返回值
     *
     * @param r
     * @return
     */
    public Future<String> submit(Runnable r, String s) {
        return pool.submit(r, s);
    }

    public Future<String> submit(Callable<String> callable) {
        return pool.submit(callable);
    }

    private class MyThreadFactory implements ThreadFactory {

        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(@NonNull Runnable r) {
            Thread thread = new Thread(r, "GWThreadPool-" + mCount.getAndIncrement());
            thread.setPriority(Thread.NORM_PRIORITY - 1);
            thread.setDaemon(false);
            return thread;
        }
    }

}

带返回值的执行，以及不带返回值的执行；

 private void test2() {
        //如果你想执行一个带返回值的任务，任务执行完成之后，返回结果，用下面的代码
        try {
            Callable<String> callable = new Callable<String>() {// 注意这里不是Runnable，而是Callable，
                @Override
                public String call() {
                    return "哈哈哈";
                }
            };

            //````如果你想执行任务，并且要取执行完成之后的返回值，用submit吧
            Future<String> s = CustomThreadPool.getInstance().submit(callable);//执行,submit 有返回值
            //下面有5个API可供调用
            /**
             *  尝试取消任务的执行。这种尝试将会失败，当任务已经完成，已经被取消，或者因为某种原因不能被取消。
             *  如果成功取消，这个任务还没开始的话，那这个任务将永远不会执行，
             *  如果任务已经开始，那就要 mayInterruptIfRunning 参数值将会决定是否要尝试去终止任务；（true，尝试终止，false，不去尝试;至于为什么这里是尝试，而不是一定终止，参照本段开头；）
             *  当这个方法返回，后来的调用isDone将会永远返回true，也就是说，取消也算做是完成？
             *  后来的调用isCanceled   将会永远返回true，如果这个方法返回true的话。
             * @param mayInterruptIfRunning  是否执行这个任务线程的线程能够被中断；true能够中断，false，将会继续执行直到完成；
             * @return 返回值，false，如果这个任务不能被取消，典型的就是这个任务已经完成了·· 其他情况，返回true；
             */
            s.cancel(true);// 取消任务，参数的意思是:是否允许在执行过程中中断； 如果true，不管是不是已经开始任务，都让他终止；false，如果已经开始了，就不终止了；
            s.isDone();//是否已完成
            s.isCancelled();// 是否已经被取消

            String result = s.get();// 获取执行的结果，如果任务尚未执行完成，有可能会阻塞一段时间
            String result2 = s.get(3, TimeUnit.SECONDS);//最多等待3秒，get的重载方法，因为有可能会阻塞，阻塞的时长不定，所以提供一个重载方法，指定阻塞的最大时间；

            //````如果你只是想执行任务，不想要返回值，那么，用execute
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    Log.d("hahaha", "假装这里有代码");
                }
            };
            CustomThreadPool.getInstance().execute(runnable);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }