Android线程优化之线程池的详解

使用线程来进行异步任务，这对于大多数人而言还是轻车熟路的，而且使用起来比较简单，只需要通过new Thread() 之后 start 即可，当任务完成之后则会销毁，但是这里有一个弊端，就是如果一个高度任务，比如说定时处理异步事件，如果你每次执行都new Thread的话，这将导致线程频繁的创建与销毁，这样会导致占用大量的资源，这已经就十分的不友好了，而且所有创建的子线程都没有一个统一的管理，如果要优化，也应该从这里下手了，所以，我们，我们就更应该来了解一下线程池的使用了，使用线程池可以复用创建的子线程，不会反复创建和销毁，并且使用起来也不算太难。

ThreadPoolExecutor

我们要理解ThreadPoolExecutor，因为Android中其他几个线程池都是他延伸出来的，相当于他就是个爸爸，所以你要先了解ThreadPoolExecutor的前世今生，首先来看下他的构造函数的几个参数：

• int corePoolSize

• 核心线程数量

• int maximumPoolSize

• 最大线程数量

• long keepAliveTime,

• 超时时长

• TimeUnit unit,

• 时间枚举

• BlockingQueue<Runnable> workQueue,

• 任务队列

• ThreadFactory threadFactory

• 线程工厂接口

• RejectedExecutionHandler handler

• 拒绝执行的Handler

  
  

这里要注意，正常情况下，corePoolSize是一直存在的，并且当corePoolSize >= maximumPoolSize的时候，线程会被阻塞等待任务完成，keepAliveTime触发的时候非核心线程都会被回收掉。

ThreadPoolExecutor还是有很多可讲的，但是我选择的还是着重讲解Android中的四个线程池，网上对ThreadPoolExecutor的例子太多了，也比较杂，大家可以去看看。

Android中的线程池的概念来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为ThreadPoolExecutor,其中所实现的四个线程池每一个的作用都是不一样的，我们一起来看下：

FixThreadPool

FixThreadPool通过如下代码实现：

ExecutorService service = Executors.newFixedThreadPool(5);

Runnable r = new Runnable() {

   @Override

   public void run() {

       Log.i(TAG, "newFixedThreadPool");

   }

};

service.execute(r);

队列线程池，因为核心线程池是固定的，所以不管你如何execute，都会一个个来执行完成，因为直接创建使用，没有回收，所以他的优势是响应速度很快，效率更高。

这里我们可以模拟一下：

ExecutorService service = Executors.newFixedThreadPool(2);

for (int i = 0; i < 10; i++) {

   final int finalI = i;

   service.execute(new Runnable() {

       @Override

       public void run() {

           try {

               Thread.sleep(2000);

               Log.i(TAG, "newFixedThreadPool:" + finalI );

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

       }

   });

}

这里指定核心线程数为2，然后执行10个任务，得到的结果：

             

可以看出，首先他是无序的，其次他每隔两秒钟打印两个，也就验证了刚才的说法，他线程数满了之后需要等待，就是排队打饭一样。

SingleThreadPool

顾名思义，这个都不需要指定核心线程数，代码如下：

ExecutorService service = Executors.newSingleThreadExecutor();

Runnable r = new Runnable() {

   @Override

   public void run() {

       Log.i(TAG, "newSingleThreadExecutor");

   }

};

service.execute(r);

这个其实和newFixedThreadPool(1)是一样的，SingleThreadPool主要还是为了线程同步而来的，newFixedThreadPool可以同时执行多任务，所以肯定不是同步的，如果什么场景需要线程同步，那SingleThreadPool再合适不过了。

如果我们把上面的例子改成SingleThreadPool：

ExecutorService service = Executors.newSingleThreadExecutor();

for (int i = 0; i < 10; i++) {

   final int finalI = i;

   service.execute(new Runnable() {

       @Override

       public void run() {

           try {

               Thread.sleep(2000);

               Log.i(TAG, "newSingleThreadExecutor:" + finalI );

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

       }

   });

}

可以得到的结论：首先他是有序的，其次他每隔两秒则打印一次，而Log的输出也刚好验证了我的结论：

            

CachedThreadPool

CachedThreadPool还是比较多使用的，他不需要指定线程数，因为他的线程数很大，但是不存在核心线程，这也就意味着经常被回收，他的回收思路是，执行任务，任务结束后，保留60s，在60s来了新任务则继续使用刚才的线程，如果60s内无任务则回收线程，有点类似吃饭，你去盛饭没关系，但是你吃完走了我就要收盘子，间隙就在60s

ExecutorService service = Executors.newCachedThreadPool();

Runnable r = new Runnable() {

   @Override

   public void run() {

       Log.i(TAG, "newCachedThreadPool");

   }

};

service.execute(r);

我们继续改造我们的示例代码：

ExecutorService service = Executors.newCachedThreadPool();

for (int i = 0; i < 10; i++) {

   final int finalI = i;

   service.execute(new Runnable() {

       @Override

       public void run() {

           try {

               Thread.sleep(2000);

               Log.i(TAG, "newCachedThreadPool:" + finalI );

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

       }

   });

}

这段代码在前面两个线程池都使用到了，就是用来告诉你他们的区别，我们使用newCachedThreadPool执行后得到的结果：

            

看Log，我们得到的结论是：首先他也是无序的，并且他因为子线程够多，所以sleep两秒后直接全部打印出来了。

ScheduledThreadPool

这是一个可操作性较强的线程池，也是唯一一个可循环的线程池，便于一些重复性的工作使用

ScheduledExecutorService service = Executors. newScheduledThreadPool (5);

Runnable r = new Runnable() {

   @Override

   public void run() {

       Log.i(TAG, "newScheduledThreadPool");

   }

};

Log.i(TAG,"start");

service.scheduleAtFixedRate(r, 1000, 2000, TimeUnit.MILLISECONDS);

scheduleAtFixedRate中有四个参数，第一个是任务，第二个是延时时长，第三个是循环时长，第四个是单位，也就是说，当启动scheduleAtFixedRate之后，在1s后才开始执行这个间隔2s的任务不断循环，可以这样理解，启动任务后，这里延时1s，然后才开始执行任务，以后每隔2s重复执行

我们拿着示例继续改造：

ScheduledExecutorService service = Executors.newScheduledThreadPool(2);

for (int i = 0; i < 10; i++) {

   final int finalI = i;

   service.scheduleAtFixedRate(new Runnable() {

       @Override

       public void run() {

           try {

               Thread.sleep(2000);

               Log.i(TAG, "newCachedThreadPool:" + finalI );

           } catch (InterruptedException e) {

               e.printStackTrace();

           }

       }

   },1000,2000,TimeUnit.MILLISECONDS);

}

这段代码比上面的复杂一些，我们看打印：

            

这里得到的是什么结论呢？比较多，首先，他是无序的，其次他间隔2s无限重复，并且启动这个县城需要3s,也就是延迟的1s + sleep的3s。

到这里我相信大家还是比较清晰的认知线程池，但是线程池是结合实战的，不然的话也都是纸上谈兵，但是一般线程池也只是替换new Thread的操作，所以示例的话，大家可以自行寻找一下，后续的实战项目文章，我再带领大家学习线程池。

大家有兴趣可以加入我的星球，任何问题都能得到解答，还有专门的视频辅佐，快速进阶。