线程池常见方法解读

对于记性不好的同学写笔记很重要，有问题欢迎大家留言交流，sam出品。

线程池

用线程池解决的问题：

  • 创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。
  • 线程并发数量过多，抢占系统资源从而导致阻塞。
  • 对线程进行一些简单的管理

ThreadPoolExecutor类

  • java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。
ThreadPoolExecutor类核心4个人构造方法
                      public ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue)

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

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

                       public ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler)
corePoolSize ：该线程池中核心线程数最大值，注意：allowCoreThreadTimeOut，可以干掉核心线程。

maximumPoolSize： 该线程池中线程总数最大值、线程总数 = 核心线程数 + 非核心线程数。

这里有人会问corePoolSize和maximumPoolSize关系，这里我解答打个比喻，corePoolSize铁打的营 盘，maximumPoolSize流水的兵，营盘在，兵可以销毁，核心线程会保存，其余的线程不用时销毁。

keepAliveTime： 该线程池中非核心线程闲置超时时长。

TimeUnit unit：keepAliveTime的单位，TimeUnit是一个枚举类型，其包括：
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 = 1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ： 秒
MINUTES ： 分
HOURS ： 小时
DAYS ： 天

  常用的workQueue类型：
  
  * SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
  
  * LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
  
  * ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
  
  * DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
  
  * threadFactory：线程工厂，主要用来创建线程；DefaultThreadFactory 
  * handler：表示当拒绝处理任务时的策略，有以下四种取值：
  
   ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
   ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
   ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
   ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。那么主线程会自己去执行该任务，不会等待线程池中的线程去执行

Executors提供的四种线程池：

newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

        代码实例
        import java.util.concurrent.ExecutorService;  
        import java.util.concurrent.Executors;  
        public class ThreadPoolExecutorTest {  
        public static void main(String[] args) {  
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
              for (int i = 0; i < 10; i++) {  
                  final int index = i;  
                  try {  
                      Thread.sleep(index * 1000);  
                    } catch (InterruptedException e) {  
                      e.printStackTrace();  
                    }  
                    cachedThreadPool.execute(new Runnable() {  
                      public void run() {  
                        System.out.println(index);  
                      }  
                      });  
                    }  
                  }  
                }

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
它比较适合处理执行时间比较小的任务。

  • 它是一个可以无限扩大的线程池；它比较适合处理执行时间比较小的任务；
  • corePoolSize为0，maximumPoolSize为无限大，意味着线程数量可以无限大；
  • keepAliveTime为60S，意味着线程空闲时间超过60S就会被杀死；
  • 采用SynchronousQueue装等待的任务，这个阻塞队列没有存储空间，这意味着只要有请求到来，就必须要找到一条工作线程处理他，如果当前没有空闲的线程，那么就会再创建一条新的线程。

newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

  import java.util.concurrent.ExecutorService;  
  import java.util.concurrent.Executors;  

  public class ThreadPoolExecutorTest {  
  public static void main(String[] args) {  
      ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
      for (int i = 0; i < 10; i++) {  
          final int index = i;  
          fixedThreadPool.execute(new Runnable() {  
            public void run() {  
              try {  
                System.out.println(index);  
                Thread.sleep(2000);  
                } catch (InterruptedException e) {  
                  e.printStackTrace();  
                }  
              }  
              });  
            }  
          }  
        }
  • 它是一种固定大小的线程池；corePoolSize和maximunPoolSize都为用户设定的线程数量nThreads；
  • keepAliveTime为0，意味着一旦有多余的空闲线程，就会被立即停止掉；
  • 阻塞队列采用了LinkedBlockingQueue，它是一个无界队列；由于阻塞队列是一个无界队列，因此永远不可能拒绝任务；由于采用了无界队列，实际线程数量将永远维持在nThreads。

newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。

  import java.util.concurrent.Executors;  
  import java.util.concurrent.ScheduledExecutorService;  
  import java.util.concurrent.TimeUnit;  
  public class ThreadPoolExecutorTest {  
  public static void main(String[] args) {  
      ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
      scheduledThreadPool.schedule(new Runnable() {  
        public void run() {  
          System.out.println("delay 5 seconds");  
        }  
        }, 5, TimeUnit.SECONDS);  
      }  
  }

newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
public static void main(String[] args) {  
    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
    for (int i = 0; i < 10; i++) {  
      final int index = i;  
      singleThreadExecutor.execute(new Runnable() {  
        public void run() {  
          try {  
            System.out.println(index);  
            Thread.sleep(2000);  
            } catch (InterruptedException e) {  
              e.printStackTrace();  
            }  
          }  
          });  
        }  
      }  
    }
  • 结果依次输出，相当于顺序执行各个任务。
  • 它只会创建一条工作线程处理任务；
  • 采用的阻塞队列为LinkedBlockingQueue；
  • BlockingQueue<Runnable> workQueue

该线程池中的任务队列：维护着等待执行的Runnable对象

当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务

  • execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

  • submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果（Future相关内容将在下一篇讲述）。

  • shutdown()和shutdownNow()是用来关闭线程池的。

BlockingQueue

  • offer: 将指定元素插入此队列中（如果立即可行且不会违反容量限制），成功时返回 true，如果当前没有可用的空间，则返回 false。
  • put:将指定元素插入此队列中，将等待可用的空间。
  • take: 获取并移除此队列的头部，在元素变得可用之前一直等待。
  • add:插入，没可用空间抛异常。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • JAVA 线程
    【JAVA 线程】 线程 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者...
    Rtia阅读 2,788评论 2赞 20
  • 聊聊Java进阶之并发基础技术—线程池剖析
    文章摘要：在业务系统中，线程池框架技术一直是用来解决多线程并发的一种有效方法。 在JDK中，J.U.C并发包下的T...
    癫狂侠阅读 2,162评论 2赞 21
  • 周六的早晨
    昨天周五，阳光挺好的。想出去走走，无非就还是那个公园，找一处小山丘坐着晒太阳。去的路上大概会买一瓶芒果饮料，奢侈点...
    自平衡阅读 197评论 0赞 0
  • 我与吃货男盆友的日常
    程先生是一枚资深吃货。 该怎么形容这个吃货呢，大概就是当美食在舌尖绽放的那一霎那，整个世界都充满了花开的声音。 程...
    饭十七阅读 322评论 0赞 0
  • 时光中的我们
    “#本文参加‘青春’大赛，本人保证本文为本人原创，如有问题则与主办方无关，自愿放弃评优评奖资格” 姓名:李颖 联系...
    残花人阅读 155评论 0赞 0