Android线程池总结

最新推荐文章于 2023-12-05 10:52:29 发布

-Sloth-

最新推荐文章于 2023-12-05 10:52:29 发布

阅读量312

点赞数

分类专栏： Android进阶面试_Java

本文链接：https://blog.csdn.net/qq_29882585/article/details/74202408

版权

Android进阶同时被 2 个专栏收录

35 篇文章 1 订阅

订阅专栏

面试_Java

14 篇文章 3 订阅

订阅专栏

什么是线程池：

java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。

假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

如果：T1 + T3 远大于 T2，则可以采用线程池，以提高性能。

一个线程池包括以下四个基本组成部分：

1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；
2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；
3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；
4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

使用线程池的好处：

1.重用已经创建的好的线程，避免频繁创建进而导致的频繁GC
2.控制线程并发数，合理使用系统资源，提高应用性能
3.可以有效的控制线程的执行，比如定时执行，取消执行等

线程池的构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                    BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

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

workQueue是一个BlockingQueue类型，BlockingQueue它是一个特殊的队列，当我们从BlockingQueue中取数据时，如果BlockingQueue是空的，则取数据的操作会进入到阻塞状态，当BlockingQueue中有了新数据时，这个取数据的操作又会被重新唤醒。同理，如果BlockingQueue中的数据已经满了，往BlockingQueue中存数据的操作又会进入阻塞状态，直到BlockingQueue中又有新的空间，存数据的操作又会被冲洗唤醒。BlockingQueue有多种不同的实现类，下面举几个例子：

1.ArrayBlockingQueue：这个表示一个规定了大小的BlockingQueue，ArrayBlockingQueue的构造函数接受一个int类型的数据，该数据表示BlockingQueue的大小，存储在ArrayBlockingQueue中的元素按照FIFO（先进先出）的方式来进行存取。

2.LinkedBlockingQueue：这个表示一个大小不确定的BlockingQueue，在LinkedBlockingQueue的构造方法中可以传一个int类型的数据，这样创建出来的LinkedBlockingQueue是有大小的，也可以不传，不传的话，LinkedBlockingQueue的大小就为Integer.MAX_VALUE，源码：

    /** 
     * Creates a {@code LinkedBlockingQueue} with a capacity of 
     * {@link Integer#MAX_VALUE}. 
     */  
    public LinkedBlockingQueue() {  
        this(Integer.MAX_VALUE);  
    }  
      
    /** 
     * Creates a {@code LinkedBlockingQueue} with the given (fixed) capacity. 
     * 
     * @param capacity the capacity of this queue 
     * @throws IllegalArgumentException if {@code capacity} is not greater 
     *         than zero 
     */  
    public LinkedBlockingQueue(int capacity) {  
        if (capacity <= 0) throw new IllegalArgumentException();  
        this.capacity = capacity;  
        last = head = new Node<E>(null);  
    }

3.PriorityBlockingQueue：这个队列和LinkedBlockingQueue类似，不同的是PriorityBlockingQueue中的元素不是按照FIFO来排序的，而是按照元素的Comparator来决定存取顺序的（这个功能也反映了存入PriorityBlockingQueue中的数据必须实现了Comparator接口）。

4.SynchronousQueue：这个是同步Queue，属于线程安全的BlockingQueue的一种，在SynchronousQueue中，生产者线程的插入操作必须要等待消费者线程的移除操作，Synchronous内部没有数据缓存空间，因此我们无法对SynchronousQueue进行读取或者遍历其中的数据，元素只有在你试图取走的时候才有可能存在。我们可以理解为生产者和消费者互相等待，等到对方之后然后再一起离开。

这是ThreadPoolExecutor的构造方法参数的解释，我们的线程提交到线程池之后又是按照什么样的规则去运行呢？它们遵循如下规则：
1.execute一个线程之后，如果线程池中的线程数未达到核心线程数，则会立马启用一个核心线程去执行

2.execute一个线程之后，如果线程池中的线程数已经达到核心线程数，且workQueue未满，则将新线程放入workQueue中等待执行

3.execute一个线程之后，如果线程池中的线程数已经达到核心线程数但未超过非核心线程数，且workQueue已满，则开启一个非核心线程来执行任务

4.execute一个线程之后，如果线程池中的线程数已经超过非核心线程数，则拒绝执行该任务。

线程池的分类：

1.FixedThreadPool

创建方式：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {  
        return new ThreadPoolExecutor(nThreads, nThreads,  
                                      0L, TimeUnit.MILLISECONDS,  
                                      new LinkedBlockingQueue<Runnable>());  
    }

从源码中

核心线程数和最大线程数一样，说明在FixedThreadPool中没有非核心线程，所有的线程都是核心线程，且线程的超时时间为0，说明核心线程即使在没有任务可执行的时候也不会被销毁（这样可让FixedThreadPool更快速的响应请求），最后的线程队列是一个LinkedBlockingQueue，但是LinkedBlockingQueue却没有参数，这说明线程队列的大小为Integer.MAX_VALUE（2的31次方减1），OK，看完参数，我们大概也就知道了FixedThreadPool的工作特点了，当所有的核心线程都在执行任务的时候，新的任务只能进入线程队列中进行等待，直到有线程被空闲出来。

例如：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);  
        for (int i = 0; i < 20; i++) {  
            final int a = i;  
            Runnable runnable = new Runnable(){  
                @Override  
                public void run() {  
                    SystemClock.sleep(2000);  
                    Log.d("id", "id: "+ a);  
                }  
            };  
            fixedThreadPool.execute(runnable);  
        }

2.SingleThreadExecutor

源码：

    public static ExecutorService newSingleThreadExecutor() {  
        return new FinalizableDelegatedExecutorService  
            (new ThreadPoolExecutor(1, 1,  
                                    0L, TimeUnit.MILLISECONDS,  
                                    new LinkedBlockingQueue<Runnable>()));  
    }

这类线程池内部只有一个核心线程,它确保所有的任务都在同一个线程中按顺序执行.
SingleThreadExecutor的意义在于统一外界所有任务到一个线程,这使得这些任务之间不需要处理线程同步的问题.

例如：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
        for (int i = 0; i < 20; i++) {  
            final int a = i;  
            Runnable runnable = new Runnable() {  
                @Override  
                public void run() {  
                    Log.d("id", "id " +a);  
                    SystemClock.sleep(2000);  
                }  
            };  
            singleThreadExecutor.execute(runnable);  
        }

3.CachedTreadPool

源码：

public static ExecutorService newCachedThreadPool() {  
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
                                      60L, TimeUnit.SECONDS,  
                                      new SynchronousQueue<Runnable>());  
    }

它是一种线程数量不定的线程池,它只有非核心线程，没有核心线程,并且其最大线程数为Integer.MAX_VALUE(也就相当于线程池的线程数量可以无限大).

当线程池中所有线程都处于活动的状态时,线程池会创建新的线程来处理新任务,否则就会复用空闲线程来处理.

值得注意的是,这个线程池中储存任务的队列是SynchronousQueue队列,这个队列可以理解为无法储存的队列,只有在可以取出的情况下,才会向其内添加任务.

从整个CacheThreadPool的特性来看:

(1)比较适合执行大量的耗时较少的任务.

(2)当整个线程都处于闲置状态时,线程池中的线程都会超时而被停止,这时候的CacheThreadPool几乎不占任何系统资源的.

例如：

xecutorService cachedThreadPool = Executors.newCachedThreadPool();  
        for (int i = 0; i < 30; i++) {  
            final int finalI = i;  
            Runnable runnable = new Runnable(){  
                @Override  
                public void run() {  
                    Log.d("google_lenve_fb", "run: " + Thread.currentThread().getName() + "----" + finalI);  
                }  
            };  
            cachedThreadPool.execute(runnable);  
            SystemClock.sleep(2000);  
        }

4.ScheduledThreadPool

源码：

    public ScheduledThreadPoolExecutor(int corePoolSize) {  
        super(corePoolSize, Integer.MAX_VALUE,  
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,  
              new DelayedWorkQueue());  
    }

它的核心线程数量是固定的,而非核心线程数是没有限制的,并且当非核心线程闲置时会被立即回收.

ScheduThreadPool这类线程池主要用于执行定时任务和具有固定周期的重复任务.

而DelayedWorkQueue这个队列就是包装过的DelayedQueue,这个类的特点是在存入时会有一个Delay对象一起存入,代表需要过多少时间才能取出,相当于一个延时队列.

（1）延迟启动任务：

public ScheduledFuture<?> schedule(Runnable command,  
                                   long delay, TimeUnit unit);

例如：

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);  
            Runnable runnable = new Runnable(){  
                @Override  
                public void run() {  
                    Log.d("thread", "haha");  
                }  
            };  
        scheduledExecutorService.schedule(runnable, 1, TimeUnit.SECONDS);

(2)延迟定时执行任务：

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,  
                                              long initialDelay,  
                                              long period,  
                                              TimeUnit unit);

例如：

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);  
            Runnable runnable = new Runnable(){  
                @Override  
                public void run() {  
                    Log.d("thread", "haha");  
                }  
            };  
        scheduledExecutorService.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.SECONDS);

(3)延迟执行任务

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,  
                                                 long initialDelay,  
                                                 long delay,  
                                                 TimeUnit unit);

例如：

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);  
            Runnable runnable = new Runnable(){  
                @Override  
                public void run() {  
                    Log.d("google_lenve_fb", "run: ----");  
                }  
            };  
        scheduledExecutorService.scheduleWithFixedDelay(runnable, 1, 1, TimeUnit.SECONDS);

第一次延迟initialDelay秒，以后每次延迟delay秒执行一个任务

线程池的其他功能：

1.shutDown() 关闭线程池，不影响已经提交的任务

2.shutDownNow() 关闭线程池，并尝试去终止正在执行的线程

3.allowCoreThreadTimeOut(boolean value) 允许核心线程闲置超时时被回收

4.submit 一般情况下我们使用execute来提交任务，但是有时候可能也会用到submit，使用submit的好处是submit有返回值。

例如：

    public void submit(View view) {  
        List<Student<String>> students= new ArrayList<>();  
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 5, 1,  
                TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());  
        for (int i = 0; i < 10; i++) {  
            Student<String> taskStudent = threadPoolExecutor.submit(new MyTask(i));  
            //将每一个任务的执行结果保存起来  
            student.add(taskStudent);  
        }  
        try {  
            //遍历所有任务的执行结果  
            for (Student<String> student : students) {  
                Log.d("submit", "submit: " + student.get());  
            }  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } catch (ExecutionException e) {  
            e.printStackTrace();  
        }  
    }  
      
    class MyTask implements Callable<String> {  
      
        private int taskId;  
      
        public MyTask(int taskId) {  
            this.taskId = taskId;  
        }  
      
        @Override  
        public String call() throws Exception {  
            SystemClock.sleep(1000);  
            //返回每一个任务的执行结果  
            return "call调用的" + taskId;  
        }  
    }

自定义线程池：

1、因为线程池是固定不变的，所以使用了单例模式
2、定义了两个线程池，长的与短的，分别用于不同的地方。因为使用了单例模式，所以定义两个。
3、定义了两个方法，执行的与取消的

public class ThreadManager {
    private ThreadManager(){};
    private static ThreadManager instance= new ThreadManager();
    private ThreadPoolProxy longPoolProxy;
    private ThreadPoolProxy shortPoolProxy;
    public static ThreadManager getInstance(){
        return instance;
    }
    /**
     * 长线程池
     * @return
     */
    public synchronized ThreadPoolProxy createLongPool(){
        if (longPoolProxy == null) {
            //(int corePoolSize 线程池大小, int maximumPoolSize 最大值, long keepAliveTime 存活时间)
            longPoolProxy = new ThreadPoolProxy(5, 5, 5000);
        }
        return longPoolProxy;
    }
    /**
     * 短线程池
     * @return
     */
    public synchronized ThreadPoolProxy createShortPool(){
        if (shortPoolProxy == null) {
            shortPoolProxy = new ThreadPoolProxy(2, 3, 5000);
        }
        return shortPoolProxy;
    }

    public class ThreadPoolProxy{
        private ThreadPoolExecutor pool;
        private int corePoolSize; //线程数
        private int maximumPoolSize; //线程满了后额外开的线程窗口
        private long keepAliveTime;//没有线程执行时存活时间
        public ThreadPoolProxy(int corePoolSize,int maximumPoolSize, long keepAliveTime){
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.keepAliveTime = keepAliveTime;
        }

        /**
         * 执行线程
         * @param runnable
         */
        public void execute(Runnable runnable){
            if (pool == null) {
                //最多可有多少个线程排队
                BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(10);
                pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, workQueue);
            }
            pool.execute(runnable);
        }
        /**
         * 取消线程
         * @param runnable
         */
        public void cancel(Runnable runnable){
            if (pool != null) {
                pool.remove(runnable);
            }
        }
    }
}

使用方法：

ThreadManager.getInstance().createLongPool().execute(new Runnable() {
            @Override
            public void run() {
                //SystemClock.sleep(2000);
                final LoadResult result = loadFromServer();
                if (result != null) {
                    Util.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            currentState = result.getValue();
                            showPages();
                        }
                    });
                }
            }
        });

问题：Executors存在什么问题？

在阿里巴巴Java开发手册中提到，使用Executors创建线程池可能会导致OOM(OutOfMemory ,内存溢出)，但是并没有说明为什么，那么接下来我们就来看一下到底为什么不允许使用Executors？

我们先来一个简单的例子，模拟一下使用Executors导致OOM的情况

public class ExecutorsDemo {
    private static ExecutorService executor = Executors.newFixedThreadPool(15);
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {

            executor.execute(new SubThread());
        }
    }
}


class SubThread implements Runnable {
    @Override
    public void run() {
        try {

            Thread.sleep(10000);

        } catch (InterruptedException e) {

            //do nothing
        }
    }
}

通过指定JVM参数：-Xmx8m -Xms8m 运行以上代码，会抛出OOM:

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
at com.hollis.ExecutorsDemo.main(ExecutorsDemo.java:16)

以上代码指出，ExecutorsDemo.java的第16行，就是代码中的executor.execute(new SubThread());。

Executors为什么存在缺陷
通过上面的例子，我们知道了Executors创建的线程池存在OOM的风险，那么到底是什么原因导致的呢？我们需要深入Executors的源码来分析一下。

其实，在上面的报错信息中，我们是可以看出蛛丝马迹的，在以上的代码中其实已经说了，真正的导致OOM的其实是LinkedBlockingQueue.offer方法。

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
at com.hollis.ExecutorsDemo.main(ExecutorsDemo.java:16)

翻看代码的话，也可以发现，其实底层确实是通过LinkedBlockingQueue实现的：

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());

如果读者对Java中的阻塞队列有所了解的话，看到这里或许就能够明白原因了。Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。

这里的问题就出在：**不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。**也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。

而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。

上面提到的问题主要体现在newFixedThreadPool和newSingleThreadExecutor两个工厂方法上，并不是说newCachedThreadPool和newScheduledThreadPool这两个方法就安全了，这两种方式创建的最大线程数可能是Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致OOM。

创建线程池的正确姿势
避免使用Executors创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用ThreadPoolExecutor的构造函数来自己创建线程池。在创建的同时，给BlockQueue指定容量就可以了。

private static ExecutorService executor = new ThreadPoolExecutor(10, 10,
        60L, TimeUnit.SECONDS,
        new ArrayBlockingQueue(10));

这种情况下，一旦提交的线程数超过当前可用线程数时，就会抛出java.util.concurrent.RejectedExecutionException，这是因为当前线程池使用的队列是有边界队列，队列已经满了便无法继续处理新的请求。但是异常（Exception）总比发生错误（Error）要好。

除了自己定义ThreadPoolExecutor外。还有其他方法。这个时候第一时间就应该想到开源类库，如apache和guava等。

作者推荐使用guava提供的ThreadFactoryBuilder来创建线程池。

public class ExecutorsDemo {

    private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()

        .setNameFormat("demo-pool-%d").build();

    private static ExecutorService pool = new ThreadPoolExecutor(5, 200,

        0L, TimeUnit.MILLISECONDS,

        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {

        for (int i = 0; i < Integer.MAX_VALUE; i++) {

            pool.execute(new SubThread());
        }
    }