`

线程池

    博客分类：
  • 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后，就会把到达的任务放到缓存队列当中; ...

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

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

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

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

    线程池 　

    VC实现线程池

    易语言真正的线程池简易实现

    易语言简易线程池的实现。 ——V雪落有声V原创。转载请保留。前文：。为了能充分理解本篇文章的内容，需要了解的知识如下：。1.事件对象的使用：http://baike.baidu.com/view/751499.htm。2.信号量的使用：...

    Java简单线程池 线程池中文文档

    简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类

    Windows下一个比较完美的线程池实现和示例

    Windows下一个比较完美的线程池实现和示例 本线程池提供了如下功能： 1.能根据任务个数和当前线程的多少在最小/最大线程个数之间自动调整(Vista后的系统有 SetThreadpoolThreadMaximum 等函数有类似功能)； 2.能方便...

    C#管理线程池的类ThreadManager

    C#管理线程池的类 /* How to use Thread Classs * * ============== * public ELMService() { InitializeComponent(); etm.ClalThreadPool("EmailThreads", (uint)ApplicationInfo.EmailParsingThreads); ...

    线程池.zip，互斥锁+条件变量+队列，实现线程池，包括线程池的创建，塞任务，和销毁线程池

    线程池

    易语言线程池操作例程（解决内存不断升高的问题）

     因为本人是个小白，多线程经常用，但是线程池并没有用过，（一听到线程池，总感觉高大上）。但是近期写彩票软件的时候发现，多线程长期操作会导致内容不断的升高直至报错，遂想起了线程池，完善后发现不是一般的叼...

    一个通用的Java线程池类

    2.然后根据提示运行java命令执行示例程序，观看线程池的运行结果 目标：Java中多线程技术是一个难点，但是也是一个核心技术。因为Java本身就是一个多线程语言。本人目前在给46班讲授Swing的网络编程--使用Swing来...

    VC简单的线程池使用实例

    1.线程池管理器（ThreadPoolManager）:用于创建并管理线程池 2.工作线程（WorkThread）: 线程池中线程 3.任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。 4.任务队列:用于存放没有处理的...

    如何使用线程池

    以下示例显示如何使用线程池。首先创建 ManualResetEvent 对象，此对象使程序能够知道线程池何时运行完所有的工作项。接着，尝试向线程池添加一个线程。如果添加成功，则添加其余的线程（本例中为 4 个）。然后...

    linux线程池创建c实现

    linux线程池创建c实现 linux线程池创建c实现 linux线程池创建c实现 linux线程池创建c实现 linux线程池创建c实现 linux线程池创建c实现

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

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

    Linux下通用线程池的构建

    什么是线程池？简单点说，线程池就是有一堆已经创建好了的线程，初始它们都处于空闲等待状态，当有新的任务需要处理的时候，就从这个池子里面取一个空闲等待的线程来处理该任务，当处理完成了就再次把该线程放回池中...

    一个简单线程池的实现

    这是一个简单线程池的实现，虽然有很多bug，但是能够简单地实现线程池。

    Java 自己实现线程池

    Java开发，Android开发，自己实现线程池，明白线程池的实现机制

    jdbc线程池演示demo

    本实例采用c3p0作为线程池工具包，讲解了jdbc基本用法，同时给出了Oracle以及mysql增（单插入、批量插入）、删、查、改等功能，可以直接复制使用。

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