1. 为什么要引入线程池？

---

• 如果有100个下载任务，每次 new Thread()，很耗性能；
• new多个线程也缺乏管理，线程过多之间会相互竞争，占用资源多，导致系统瘫痪；

所以就引入线程池；

2. 线程池好处？

---

• 解决了线程反复的创建和销毁，做到线程可以反复使用；

3. ExecutorService介绍？

---

• ExecutorService是线程池，是一个接口，继承自Executor接口；

4. Executors工厂类

---

Executors工厂类提供四种线程池：newSingleThreadExecutor、newScheduledThreadPool、newCacheThreadPool、newFixedThreadPool；

1>：newSingleThreadExecutor用法

• 创建一个单线程的线程池，它只用这一个线程来完成20个任务，保证所有任务按照指定顺序执行；

代码如下：

    /**
     * 单线程的线程池：
     *          只会用一个线程来执行任务，保证所有任务按照指定顺序执行
     */
    private void newSingleThreadExecutor() {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= number; i++) {
            final int index = i;
            singleThreadPool.execute(new Runnable() {
                @SuppressLint("LongLogTag")
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.e("TAG", "线程："+threadName+",正在执行第" + index + "个任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

• 运行结果如下：

  
  图片.png
• 可以看到：
  总共只创建一个线程，第一个执行完之后再去执行第二个，第二个执行完再去执行第三个...；

2>：newScheduledThreadPool用法

• 创建一个定长线程，可以执行定时的、周期性的任务；

代码如下：

    /**
     *  每次创建一个定长的线程：
     *              可执行定时的、周期性的任务
     */
    private void newScheduledThreadPool() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟2秒后执行该任务
        scheduledThreadPool.schedule(new Runnable() {
            @SuppressLint("LongLogTag")
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                Log.e("TAG", "线程：" + threadName + ",正在执行");
            }
        }, 2, TimeUnit.SECONDS);
        //延迟1秒后，每隔2秒执行一次该任务
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                String threadName = Thread.currentThread().getName();
                Log.e("TAG", "线程：" + threadName + ",正在执行");
            }
        }, 1, 2, TimeUnit.SECONDS);
    }

• 运行结果如下：

  
  图片.png
• 可以看到：
  每次只是创建一个线程，每隔2秒执行一次；

3>：newCacheThreadPool：

创建一个可缓存的线程池，如果线程池长度超过处理需要，可以回收空闲的线程；

代码如下：

    /**
     * 可缓存的线程池：
     *          如果线程池超过处理需要，可回收空闲线程
     */
    private void newCachedThreadPool() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= number; i++) {
            final int index = i;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.e("TAG", "线程：" + threadName + ",正在执行第" + index + "个任务");
                    try {
                        long time = index * 500;
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

• 运行结果如下：

  
  图片.png

• 可以看到：
  a：缓存线程池大小不固定，可以创建多个线程；
  b：在使用缓存线程池时候，先查看线程池中是否有以前创建的线程，如果有，就复用；如果没有，就创建线程，然后添加到线程池中；
  c：缓存的线程池通常用于执行生存期比较短的异步任务；

4>：newFixedThreadPool用法

• 创建一个可重用的、固定的线程数的线程池；

代码如下：

    /**
     * 可重用的、固定的线程数的线程池
     *              固定的线程数是5
     */
    private void newFixedThreadPool() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        for (int i = 1; i <= number; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.e("TAG", "线程："+threadName+",正在执行第" + index + "个任务");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

• 运行结果如下：

  
  图片.png
• 可以看到：
  a：只会创建5个线程来执行任务，其余的任务都添加在 缓存队列中，当线程池中的线程执行完之后，再从 缓存队列中取任务继续执行；