`

线程池

    博客分类：
  • java
 
阅读更多

转自http://blog.csdn.net/vking_wang/article/details/9619137

 

 

示例

 

[java] view plaincopyprint?
  1. import java.util.concurrent.ExecutorService;  
  2. import java.util.concurrent.Executors;  
  3. import java.util.concurrent.ScheduledExecutorService;  
  4.   
  5. public class Ch09_Executor {  
  6.       
  7.    private static void run(ExecutorService threadPool) {  
  8.     for(int i = 1; i < 5; i++) {    
  9.             final int taskID = i;    
  10.             threadPool.execute(new Runnable() {    
  11.                 @Override  
  12.         public void run() {    
  13.                     for(int i = 1; i < 5; i++) {    
  14.                         try {    
  15.                             Thread.sleep(20);// 为了测试出效果，让每次任务执行都需要一定时间     
  16.                         } catch (InterruptedException e) {    
  17.                             e.printStackTrace();    
  18.                         }    
  19.                         System.out.println("第" + taskID + "次任务的第" + i + "次执行");    
  20.                     }    
  21.                 }    
  22.             });    
  23.         }    
  24.         threadPool.shutdown();// 任务执行完毕，关闭线程池     
  25.    }  
  26.       
  27.     public static void main(String[] args) {  
  28.         // 创建可以容纳3个线程的线程池   
  29.         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  30.           
  31.         // 线程池的大小会根据执行的任务数动态分配   
  32.         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  33.           
  34.             // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务     
  35.         ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();  
  36.           
  37.         // 效果类似于Timer定时器   
  38.         ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);  
  39.           
  40.         run(fixedThreadPool);  
  41. //      run(cachedThreadPool);   
  42. //      run(singleThreadPool);   
  43. //      run(scheduledThreadPool);   
  44.     }  
  45.   
  46. }  
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class Ch09_Executor {
	
   private static void run(ExecutorService threadPool) {
	for(int i = 1; i < 5; i++) {  
            final int taskID = i;  
            threadPool.execute(new Runnable() {  
                @Override
		public void run() {  
                    for(int i = 1; i < 5; i++) {  
                        try {  
                            Thread.sleep(20);// 为了测试出效果，让每次任务执行都需要一定时间  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                        System.out.println("第" + taskID + "次任务的第" + i + "次执行");  
                    }  
                }  
            });  
        }  
        threadPool.shutdown();// 任务执行完毕，关闭线程池  
   }
	
    public static void main(String[] args) {
	    // 创建可以容纳3个线程的线程池
	    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		
	    // 线程池的大小会根据执行的任务数动态分配
	    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		
            // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务  
	    ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
		
	    // 效果类似于Timer定时器
	    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
	    
	    run(fixedThreadPool);
//	    run(cachedThreadPool);
//	    run(singleThreadPool);
//	    run(scheduledThreadPool);
    }

}


 

 

CachedThreadPool

 

CachedThreadPool会创建一个缓存区，将初始化的线程缓存起来。会终止并且从缓存中移除已有60秒未被使用的线程。

如果线程有可用的，就使用之前创建好的线程，

如果线程没有可用的，就新创建线程。

 

  • 重用：缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse；如果没有，就建一个新的线程加入池中
  • 使用场景：缓存型池子通常用于执行一些生存期很短的异步型任务，因此在一些面向连接的daemon型SERVER中用得不多。
  • 超时：能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s，超过这个IDLE时长，线程实例将被终止及移出池。
  • 结束：注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。

 

[java] view plaincopyprint?
  1. // 线程池的大小会根据执行的任务数动态分配   
  2. ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  3.   
  4. public static ExecutorService newCachedThreadPool() {  
  5.     return new ThreadPoolExecutor(0,                 //core pool size   
  6.                                   Integer.MAX_VALUE, //maximum pool size   
  7.                                   60L,               //keep alive time   
  8.                                   TimeUnit.SECONDS,  
  9.                                   new SynchronousQueue<Runnable>());  
  10. }  
    // 线程池的大小会根据执行的任务数动态分配
    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0,                 //core pool size
                                      Integer.MAX_VALUE, //maximum pool size
                                      60L,               //keep alive time
                                      TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }


执行结果：

 

 

[plain] view plaincopyprint?
  1. 第1次任务的第1次执行  
  2. 第4次任务的第1次执行  
  3. 第3次任务的第1次执行  
  4. 第2次任务的第1次执行  
  5. 第3次任务的第2次执行  
  6. 第4次任务的第2次执行  
  7. 第2次任务的第2次执行  
  8. 第1次任务的第2次执行  
  9. 第2次任务的第3次执行  
  10. 第4次任务的第3次执行  
  11. 第3次任务的第3次执行  
  12. 第1次任务的第3次执行  
  13. 第2次任务的第4次执行  
  14. 第1次任务的第4次执行  
  15. 第3次任务的第4次执行  
  16. 第4次任务的第4次执行  
第1次任务的第1次执行
第4次任务的第1次执行
第3次任务的第1次执行
第2次任务的第1次执行
第3次任务的第2次执行
第4次任务的第2次执行
第2次任务的第2次执行
第1次任务的第2次执行
第2次任务的第3次执行
第4次任务的第3次执行
第3次任务的第3次执行
第1次任务的第3次执行
第2次任务的第4次执行
第1次任务的第4次执行
第3次任务的第4次执行
第4次任务的第4次执行


4个任务是交替执行的。

 

 

FixedThreadPool

 

在FixedThreadPool中，有一个固定大小的池。

如果当前需要执行的任务超过池大小，那么多出的任务处于等待状态，直到有空闲下来的线程执行任务，

如果当前需要执行的任务小于池大小，空闲的线程也不会去销毁。

 

  • 重用：fixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程
  • 固定数目：其独特之处在于，任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子
  • 超时：和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），
  • 使用场景：所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器
  • 源码分析：从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同：
    fixed池线程数固定，并且是0秒IDLE（无IDLE）
    cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE

 

[java] view plaincopyprint?
  1. // 创建可以容纳3个线程的线程池   
  2. ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  3.   
  4. public static ExecutorService newFixedThreadPool(int nThreads) {  
  5.         return new ThreadPoolExecutor(nThreads, //core pool size   
  6.                                       nThreads, //maximum pool size   
  7.                                       0L,       //keep alive time   
  8.                                       TimeUnit.MILLISECONDS,  
  9.                                       new LinkedBlockingQueue<Runnable>());  
  10. }  
// 创建可以容纳3个线程的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, //core pool size
                                      nThreads, //maximum pool size
                                      0L,       //keep alive time
                                      TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}


 

 

执行结果：

[plain] view plaincopyprint?
  1. 第1次任务的第1次执行  
  2. 第3次任务的第1次执行  
  3. 第2次任务的第1次执行  
  4. 第3次任务的第2次执行  
  5. 第2次任务的第2次执行  
  6. 第1次任务的第2次执行  
  7. 第3次任务的第3次执行  
  8. 第1次任务的第3次执行  
  9. 第2次任务的第3次执行  
  10. 第3次任务的第4次执行  
  11. 第1次任务的第4次执行  
  12. 第2次任务的第4次执行  
  13. 第4次任务的第1次执行  
  14. 第4次任务的第2次执行  
  15. 第4次任务的第3次执行  
  16. 第4次任务的第4次执行  
第1次任务的第1次执行
第3次任务的第1次执行
第2次任务的第1次执行
第3次任务的第2次执行
第2次任务的第2次执行
第1次任务的第2次执行
第3次任务的第3次执行
第1次任务的第3次执行
第2次任务的第3次执行
第3次任务的第4次执行
第1次任务的第4次执行
第2次任务的第4次执行
第4次任务的第1次执行
第4次任务的第2次执行
第4次任务的第3次执行
第4次任务的第4次执行


创建了一个固定大小的线程池，容量为3，然后循环执行了4个任务。由输出结果可以看到，前3个任务首先执行完，然后空闲下来的线程去执行第4个任务。

 

SingleThreadExecutor

SingleThreadExecutor得到的是一个单个的线程，这个线程会保证你的任务执行完成。

如果当前线程意外终止，会创建一个新线程继续执行任务，这和我们直接创建线程不同，也和newFixedThreadPool(1)不同。

 

[java] view plaincopyprint?
  1. // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务     
  2. ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();  
  3.   
  4. public static ExecutorService newSingleThreadExecutor() {  
  5.         return new FinalizableDelegatedExecutorService  
  6.             (new ThreadPoolExecutor(1,  //core pool size   
  7.                                     1,  //maximum pool size   
  8.                                     0L, //keep alive time   
  9.                                     TimeUnit.MILLISECONDS,  
  10.                                     new LinkedBlockingQueue<Runnable>()));  
  11. }  
// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务  
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1,  //core pool size
                                    1,  //maximum pool size
                                    0L, //keep alive time
                                    TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}


 

 

执行结果：

 

[plain] view plaincopyprint?
  1. 第1次任务的第1次执行  
  2. 第1次任务的第2次执行  
  3. 第1次任务的第3次执行  
  4. 第1次任务的第4次执行  
  5. 第2次任务的第1次执行  
  6. 第2次任务的第2次执行  
  7. 第2次任务的第3次执行  
  8. 第2次任务的第4次执行  
  9. 第3次任务的第1次执行  
  10. 第3次任务的第2次执行  
  11. 第3次任务的第3次执行  
  12. 第3次任务的第4次执行  
  13. 第4次任务的第1次执行  
  14. 第4次任务的第2次执行  
  15. 第4次任务的第3次执行  
  16. 第4次任务的第4次执行  
第1次任务的第1次执行
第1次任务的第2次执行
第1次任务的第3次执行
第1次任务的第4次执行
第2次任务的第1次执行
第2次任务的第2次执行
第2次任务的第3次执行
第2次任务的第4次执行
第3次任务的第1次执行
第3次任务的第2次执行
第3次任务的第3次执行
第3次任务的第4次执行
第4次任务的第1次执行
第4次任务的第2次执行
第4次任务的第3次执行
第4次任务的第4次执行


4个任务是顺序执行的。


 

ScheduledThreadPool

ScheduledThreadPool是一个固定大小的线程池，与FixedThreadPool类似，执行的任务是定时执行。

 

[java] view plaincopyprint?
  1. // 效果类似于Timer定时器   
  2. ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);  
  3.   
  4. public ScheduledThreadPoolExecutor(int corePoolSize) {  
  5.         super(corePoolSize,      //core pool size   
  6.               Integer.MAX_VALUE, //maximum pool size   
  7.               0,                 //keep alive time   
  8.               TimeUnit.NANOSECONDS,  
  9.               new DelayedWorkQueue());  
  10. }  
// 效果类似于Timer定时器
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize,      //core pool size
              Integer.MAX_VALUE, //maximum pool size
              0,                 //keep alive time
              TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
}


执行结果：

 

 

[plain] view plaincopyprint?
  1. 第1次任务的第1次执行  
  2. 第2次任务的第1次执行  
  3. 第3次任务的第1次执行  
  4. 第2次任务的第2次执行  
  5. 第1次任务的第2次执行  
  6. 第3次任务的第2次执行  
  7. 第2次任务的第3次执行  
  8. 第1次任务的第3次执行  
  9. 第3次任务的第3次执行  
  10. 第2次任务的第4次执行  
  11. 第1次任务的第4次执行  
  12. 第3次任务的第4次执行  
  13. 第4次任务的第1次执行  
  14. 第4次任务的第2次执行  
  15. 第4次任务的第3次执行  
  16. 第4次任务的第4次执行  
第1次任务的第1次执行
第2次任务的第1次执行
第3次任务的第1次执行
第2次任务的第2次执行
第1次任务的第2次执行
第3次任务的第2次执行
第2次任务的第3次执行
第1次任务的第3次执行
第3次任务的第3次执行
第2次任务的第4次执行
第1次任务的第4次执行
第3次任务的第4次执行
第4次任务的第1次执行
第4次任务的第2次执行
第4次任务的第3次执行
第4次任务的第4次执行


——与FixedThreadPool的区别？

 


 

分享到：
linux 下JDK jre 安装
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    线程池 　

    线程池是一种多线程处理形式，通过预先创建一定数量的线程并管理它们，以提高系统的效率和响应性。在计算机科学中，特别是在软件开发领域，线程池是操作系统或者编程语言中的一种资源管理技术。它允许程序预先启动一...

    java线程池概念.txt

    corePoolSize：核心池的大小，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中; ...

    阻塞线程池 阻塞线程池 阻塞线程池

    阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池阻塞线程池...

    C++实现线程池详解（基于boost源码以及封装等线程池）

    一、要实现高效的线程池，可以考虑以下几点 二、实现线程池可以按照以下步骤进行 三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、...

    线程池原理及创建（C++实现）

    ### 线程池原理及创建（C++实现） #### 一、线程池的重要性 在现代计算环境中，网络服务器面临着处理大量并发请求的挑战，其中包括但不限于Web服务器、电子邮件服务器和数据库服务器。这类服务器通常需要在短时间...

    java线程池使用后到底要关闭吗

    java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...

    Django异步任务线程池实现原理

    文章通过实例展示了如何创建一个全局线程池类，该类中封装了线程池对象，并提供了向线程池提交任务、检查任务是否在运行等方法。全局线程池的生命周期与Django主线程的生命周期一致，确保了线程资源的合理释放。 5....

    windows线程池,使用Windows自带的线程池api功能,比你写的线程池性能好得多

    线程池是多线程编程中的一个重要概念，它是一种线程使用模式，通过预先创建一组线程并维护一个线程集合来处理并发任务。在Windows操作系统中，内建的线程池API（Thread Pool API）提供了高效且灵活的线程管理机制，...

    一个简单线程池的实现

    线程池是一种在多线程编程中非常重要的概念，它能有效地管理和调度系统中的线程资源，从而提高系统的效率和响应速度。在这个简单的线程池实现中，我们可以通过`pthread_pool.cpp`、`MainFunctionForTest.cpp`、`...

    VC++ 线程池(ThreadPool)实现

    在编程领域，线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池在C++中是提高程序效率和资源管理的重要工具，尤其在处理大量并发操作时。本文将深入探讨VC++中...

    Java8并行流中自定义线程池操作示例

    Java8并行流中自定义线程池操作示例 Java8并行流中自定义线程池操作示例主要介绍了Java8并行流中自定义线程池操作，结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧。 1. 概览 Java8引入了...

    linux线程池创建c实现

    Linux 线程池创建 C 实现 线程池是一种常用的并发编程技术，它可以提高应用程序的性能和响应速度。在 Linux 系统中，使用 C 语言创建线程池可以实现高效的并发处理。 什么时候需要创建线程池呢？简单的说，如果一...

    DELPHI的ThreadPool的线程池DEMO

    DELPHI的线程池（ThreadPool）是一种高效管理并发任务的技术，它允许程序在需要时创建线程，而不是每次需要执行任务时都手动创建。线程池通过预先创建一组线程，然后根据需要分配任务，减少了线程创建和销毁的开销，...

    多线程写法（精易模块线程池和鱼刺模块线程池）

    本篇文章将重点探讨两种线程池实现：精易模块线程池和鱼刺模块线程池，并通过源码分析来展示它们的特点和用法。 首先，精易模块（SanYe Module）是由中国程序员SanYe开发的一系列开源模块，其中包含了线程池的实现...

    Linux线程池目录拷贝

    在Linux系统中，线程池是一种高效的进程管理方式，它允许多个任务并行执行，同时限制了系统中并发线程的数量，以优化资源分配和调度。本项目实现了利用线程池进行目录拷贝的功能，这涉及到多个重要的编程概念和技术...

    仿ACE线程池机制实现的线程池类

    线程池是一种优化资源管理的机制，通过预先创建并维护一组可重用的线程，避免频繁地创建和销毁线程带来的性能开销。在Java、C++等编程语言中，线程池广泛应用于并发处理，提高系统效率，降低系统的资源消耗。本项目...

    Python 使用threading+Queue实现线程池示例

    一、线程池 1、为什么需要使用线程池 1.1 创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。 记创建线程消耗时间T1，执行任务消耗时间T2，销毁线程消耗时间T3，如果T1+T3&gt;T2，那...

    线程池管理多线程上传

    线程池管理和多线程上传是并发编程中的一个重要实践，特别是在大数据传输和网络服务中。在Java等编程语言中，线程池通过有效地管理和复用线程资源，避免了频繁创建和销毁线程带来的开销，提升了系统性能。下面将详细...

    c++ 多线程线程池 demo

    线程池是多线程编程中一个重要的概念，它能够优化系统资源的使用，提高系统的响应速度和效率。本篇文章将深入探讨C++中的线程池实现，并通过名为“OEasyPool-1.0”的示例来展示其工作原理。 线程池是预先创建并维护...

    C#线程池 所有线程运行完毕

    在C#编程中，线程池（ThreadPool）是一种高效的线程管理机制，它允许开发者创建并管理多个线程，而无需直接操作线程对象。线程池中的线程可以复用，减少了创建和销毁线程的开销。当我们需要执行大量短生命周期的任务...

Magicbox
Global site tag (gtag.js) - Google Analytics