线程池学习总结

Posted 技术从心

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线程池学习总结相关的知识，希望对你有一定的参考价值。


一、为什么要用线程池？

   线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

   1.1、线程池的简要工作模型线程池学习总结 

   线程池的工作模型主要两部分组成，一部分是运行Runnable的Thread对象，另一部分就是阻塞队列。由线程池创建的Thread对象其内部的run方法会通过阻塞队列的take方法获取一个Runnable对象，然后执行这个Runnable对象的run方法（即，在Thread的run方法中调用Runnable对象的run方法）。当Runnable对象的run方法执行完毕以后，Thread中的run方法又循环的从阻塞队列中获取下一个Runnable对象继续执行。这样就实现了Thread对象的重复利用，也就减少了创建线程和销毁线程所消耗的资源。当需要向线程池提交任务时会调用阻塞队列的offer方法向队列的尾部添加任务。提交的任务实际上就是是Runnable对象或Callable对象。

   1.2、创建线程池的核心类继承关系？

  线程池学习总结

   创建线程池需要配置的几个参数？

  corePoolSize

   核心线程数，核心线程会一直存活，即使没有任务需要处理。当线程数小于核心线程数时，即使现有的线程空闲，线程池也会优先创建新线程来处理任务，而不是直接交给现有的线程处理。 核心线程在allowCoreThreadTimeout被设置为true时会超时退出，默认情况下不会退出。

   maxPoolSize

    当线程数大于或等于核心线程，且任务队列已满时，线程池会创建新的线程，直到线程数量达到maxPoolSize。如果线程数已等于maxPoolSize，且任务队列已满，则已超出线程池的处理能力，线程池会拒绝处理任务而抛出异常

    keepAliveTime

    当线程空闲时间达到keepAliveTime，该线程会退出，直到线程数量等于corePoolSize。如果allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。

   allowCoreThreadTimeout

     是否允许核心线程空闲退出，默认值为false

    queueCapacity

    任务队列容量。从maxPoolSize的描述上可以看出，任务队列的容量会影响到线程的变化，因此任务队列的长度也需要恰当的设置。

   线程池的主要处理流程？线程池学习总结

   1.3、线程池的种类

   newFixedThreadPool创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

 
   
   
 
    
  
    
    
  
  1. package test;
    2. 
  
    
    
  
  2. import java.util.concurrent.ExecutorService;
    3. 
  
    
    
  
  3. import java.util.concurrent.Executors;
    4. 
  
    
    
  
  4. public class ThreadPoolExecutorTest {
    5. 
  
    
    
  
  5.  public static void main(String[] args) {
    6. 
  
    
    
  
  6.  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    7. 
  
    
    
  
  7.  for (int i = 0; i < 10; i++) {
    8. 
  
    
    
  
  8.  final int index = i;
    9. 
  
    
    
  
  9.  fixedThreadPool.execute(new Runnable() {
    10. 
  
    
    
  
  10.  public void run() {
    11. 
  
    
    
  
  11.  try {
    12. 
  
    
    
  
  12.  System.out.println(index);
    13. 
  
    
    
  
  13.  Thread.sleep(2000);
    14. 
  
    
    
  
  14.  } catch (InterruptedException e) {
    15. 
  
    
    
  
  15.  e.printStackTrace();
    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  });
    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21. }
    22.

   newCachedThreadPool创建一个可缓存的线程池。这种类型的线程池特点是： 

    1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。 

    2).如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。

 
   
   
 
    
  
    
    
  
  1. package test;
    2. 
  
    
    
  
  2. import java.util.concurrent.ExecutorService;
    3. 
  
    
    
  
  3. import java.util.concurrent.Executors;
    4. 
  
    
    
  
  4. public class ThreadPoolExecutorTest {
    5. 
  
    
    
  
  5.  public static void main(String[] args) {
    6. 
  
    
    
  
  6.  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    7. 
  
    
    
  
  7.  for (int i = 0; i < 10; i++) {
    8. 
  
    
    
  
  8.  final int index = i;
    9. 
  
    
    
  
  9.  try {
    10. 
  
    
    
  
  10.  Thread.sleep(index * 1000);
    11. 
  
    
    
  
  11.  } catch (InterruptedException e) {
    12. 
  
    
    
  
  12.  e.printStackTrace();
    13. 
  
    
    
  
  13.  }
    14. 
  
    
    
  
  14.  cachedThreadPool.execute(new Runnable() {
    15. 
  
    
    
  
  15.  public void run() {
    16. 
  
    
    
  
  16.  System.out.println(index);
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  });
    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21. }
    22.

newScheduleThreadPool创建一个定长的线程池，而且支持定时的以及周期性的任务执行，类似于Timer。

 
   
   
 
    
  
    
    
  
  1. package test;
    2. 
  
    
    
  
  2. import java.util.concurrent.Executors;
    3. 
  
    
    
  
  3. import java.util.concurrent.ScheduledExecutorService;
    4. 
  
    
    
  
  4. import java.util.concurrent.TimeUnit;
    5. 
  
    
    
  
  5. public class ThreadPoolExecutorTest {
    6. 
  
    
    
  
  6.  public static void main(String[] args) {
    7. 
  
    
    
  
  7.  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    8. 
  
    
    
  
  8.  scheduledThreadPool.schedule(new Runnable() {
    9. 
  
    
    
  
  9.  public void run() {
    10. 
  
    
    
  
  10.  System.out.println("delay 3 seconds");
    11. 
  
    
    
  
  11.  }
    12. 
  
    
    
  
  12.  }, 3, TimeUnit.SECONDS);
    13. 
  
    
    
  
  13.  }
    14. 
  
    
    
  
  14. }
    15.

newSingleThreadExecutor创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，如果这个线程异常结束，会有另一个取代它，保证顺序执行(我觉得这点是它的特色)。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的 。

 
   
   
 
    
  
    
    
  
  1. package test;
    2. 
  
    
    
  
  2. import java.util.concurrent.ExecutorService;
    3. 
  
    
    
  
  3. import java.util.concurrent.Executors;
    4. 
  
    
    
  
  4. public class ThreadPoolExecutorTest {
    5. 
  
    
    
  
  5.  public static void main(String[] args) {
    6. 
  
    
    
  
  6.  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    7. 
  
    
    
  
  7.  for (int i = 0; i < 10; i++) {
    8. 
  
    
    
  
  8.  final int index = i;
    9. 
  
    
    
  
  9.  singleThreadExecutor.execute(new Runnable() {
    10. 
  
    
    
  
  10.  public void run() {
    11. 
  
    
    
  
  11.  try {
    12. 
  
    
    
  
  12.  System.out.println(index);
    13. 
  
    
    
  
  13.  Thread.sleep(2000);
    14. 
  
    
    
  
  14.  } catch (InterruptedException e) {
    15. 
  
    
    
  
  15.  e.printStackTrace();
    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  });
    19. 
  
    
    
  
  19.  }
    20. 
  
    
    
  
  20.  }
    21. 
  
    
    
  
  21. }
    22.

总结： 

   一.FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

   二．CachedThreadPool的特点就是在线程池空闲时，即线程池中没有可运行任务时，它会释放工作线程，从而释放工作线程所占用的资源。但是，但当出现新任务时，又要创建一新的工作线程，又要一定的系统开销。并且，在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

小结

   在我们项目中正确使用合适的线程池可以很大程度上提高我们系统的性能，在我们选择线程池的种类的时候，需要我们了解这些线程池的工作原理和一些优劣，小编在本篇博客中总结了一些核心的东西，希望对您有帮助！

原文：https://blog.csdn.net/hao134838

线程池学习总结

好看、转发和辣条会提升颜值哦~


关注我

每天进步一点点

万水千山总是情，点个 “ 在看” 行不行

以上是关于线程池学习总结的主要内容，如果未能解决你的问题，请参考以下文章

4月27日 python学习总结 GIL进程池线程池同步异步阻塞非阻塞

Java线程池学习总结

java中的进程，线程，线程池总结

多线程学习总结之 线程池

Java线程池学习总结

线程池学习总结