Java线程(六):线程池

转载 2015年07月10日 10:02:51

 自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、Struts1.3的对象池等等,池的最终目的都是节约资源,以更小的开销做更多的事情,从而提高性能。

        我们的web项目都是部署在服务器上,浏览器端的每一个request就是一个线程,那么服务器需要并发的处理多个请求,就需要线程池技术,下面来看一下Java并发包下如何创建线程池。

        1.  创建一个可重用固定线程集合的线程池,以共享的无界队列方式来运行这些线程。

  1. ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池  
        2. 创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。

  1. ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配  
        3. 创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。

  1. ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池,如果当前线程在执行任务时突然中断,则会创建一个新的线程替代它继续执行任务  

        4. 创建一个可安排在给定延迟后运行命令或者定期地执行的线程池。

  1. ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器  
        每种线程池都有不同的使用场景,下面看一下这四种线程池使用起来有什么不同。

        1. FixedThreadPool

  1. import java.util.concurrent.ExecutorService;  
  2. import java.util.concurrent.Executors;  
  3. public class ThreadPoolTest {  
  4.     public static void main(String[] args) {  
  5.         ExecutorService threadPool = Executors.newFixedThreadPool(3);  
  6.         for(int i = 1; i < 5; i++) {  
  7.             final int taskID = i;  
  8.             threadPool.execute(new Runnable() {  
  9.                 public void run() {  
  10.                     for(int i = 1; i < 5; i++) {  
  11.                         try {  
  12.                             Thread.sleep(20);// 为了测试出效果,让每次任务执行都需要一定时间  
  13.                         } catch (InterruptedException e) {  
  14.                             e.printStackTrace();  
  15.                         }  
  16.                         System.out.println("第" + taskID + "次任务的第" + i + "次执行");  
  17.                     }  
  18.                 }  
  19.             });  
  20.         }  
  21.         threadPool.shutdown();// 任务执行完毕,关闭线程池  
  22.     }  
  23. }  
        输出结果:

  1. 1次任务的第1次执行  
  2. 2次任务的第1次执行  
  3. 3次任务的第1次执行  
  4. 2次任务的第2次执行  
  5. 3次任务的第2次执行  
  6. 1次任务的第2次执行  
  7. 3次任务的第3次执行  
  8. 1次任务的第3次执行  
  9. 2次任务的第3次执行  
  10. 3次任务的第4次执行  
  11. 2次任务的第4次执行  
  12. 1次任务的第4次执行  
  13. 4次任务的第1次执行  
  14. 4次任务的第2次执行  
  15. 4次任务的第3次执行  
  16. 4次任务的第4次执行  
        上段代码中,创建了一个固定大小的线程池,容量为3,然后循环执行了4个任务,由输出结果可以看到,前3个任务首先执行完,然后空闲下来的线程去执行第4个任务,在FixedThreadPool中,有一个固定大小的池,如果当前需要执行的任务超过了池大小,那么多于的任务等待状态,直到有空闲下来的线程执行任务,而当执行的任务小于池大小,空闲的线程也不会去销毁。
        2. CachedThreadPool

        上段代码其它地方不变,将newFixedThreadPool方法换成newCachedThreadPool方法。

        输出结果:

  1. 3次任务的第1次执行  
  2. 4次任务的第1次执行  
  3. 1次任务的第1次执行  
  4. 2次任务的第1次执行  
  5. 4次任务的第2次执行  
  6. 3次任务的第2次执行  
  7. 2次任务的第2次执行  
  8. 1次任务的第2次执行  
  9. 2次任务的第3次执行  
  10. 3次任务的第3次执行  
  11. 1次任务的第3次执行  
  12. 4次任务的第3次执行  
  13. 2次任务的第4次执行  
  14. 4次任务的第4次执行  
  15. 3次任务的第4次执行  
  16. 1次任务的第4次执行  
        可见,4个任务是交替执行的,CachedThreadPool会创建一个缓存区,将初始化的线程缓存起来,如果线程有可用的,就使用之前创建好的线程,如果没有可用的,就新创建线程,终止并且从缓存中移除已有60秒未被使用的线程。

        3. SingleThreadExecutor        

       上段代码其它地方不变,将newFixedThreadPool方法换成newSingleThreadExecutor方法。       

       输出结果:

  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次执行  
        4个任务是顺序执行的,SingleThreadExecutor得到的是一个单个的线程,这个线程会保证你的任务执行完成,如果当前线程意外终止,会创建一个新线程继续执行任务,这和我们直接创建线程不同,也和newFixedThreadPool(1)不同。

    4.ScheduledThreadPool    

  1. import java.util.concurrent.ScheduledExecutorService;  
  2. import java.util.concurrent.TimeUnit;  
  3. public class ThreadPoolTest {  
  4.     public static void main(String[] args) {  
  5.         ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(1);  
  6.         // 5秒后执行任务  
  7.         schedulePool.schedule(new Runnable() {  
  8.             public void run() {  
  9.                 System.out.println("爆炸");  
  10.             }  
  11.         }, 5, TimeUnit.SECONDS);  
  12.         // 5秒后执行任务,以后每2秒执行一次  
  13.         schedulePool.scheduleAtFixedRate(new Runnable() {  
  14.             @Override  
  15.             public void run() {  
  16.                 System.out.println("爆炸");  
  17.             }  
  18.         }, 52, TimeUnit.SECONDS);  
  19.     }  
  20. }  
        ScheduledThreadPool可以定时的或延时的执行任务。

        Java的并发包很强大,上面所说只是入门,随着学习深入,会有更多记录在博客里。

        本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/7443324,转载请注明。

浅谈Java并发编程系列(六) —— 线程池的使用

线程池的作用 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的资源浪费。 提高响应速度。当任务到达时,不需要等到线程创建就能立即执行。 方便管理线程。线程是稀缺资源,如果无限制地创建,不...
  • codershamo
  • codershamo
  • 2016年07月11日 21:13
  • 1022

[Java] 实验6参考代码

求1+1/2+1/3+……+1/n 1. 整数 / 整数 = 整数 2. 如何进行从1到n的循环: for (int i = 1; i ...
  • u014674776
  • u014674776
  • 2016年04月05日 10:21
  • 816

java实验六 接口与实现

实验一: 实验目的: 掌握怎么实现借口 interface ComputerAverage{ public double average(double x[]); } class Gymna...
  • Summer__show_
  • Summer__show_
  • 2017年01月02日 20:32
  • 457

Java线程(六):线程池

自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、St...
  • u012777182
  • u012777182
  • 2016年08月02日 16:34
  • 77

Java线程(六):线程的交互

一、线程交互的基础知识线程交互知识点需要从java.lang.Object的类的三个方法来学习:void notify() 唤醒在此对象监视器上等待的单个线程。 void no...
  • gusgao
  • gusgao
  • 2016年10月27日 13:21
  • 186

Java线程(六):线程池

版权声明:本文为博主原创文章,转载请注明出处http://blog.csdn.net/ghsau。         自JDK5之后,Java推出了一个并发包,java.util.concurre...
  • syc434432458
  • syc434432458
  • 2016年02月18日 13:23
  • 115

Java线程(六):线程池

自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、St...
  • xiaobaohan214
  • xiaobaohan214
  • 2014年11月12日 17:23
  • 133

Java线程(六):线程池

自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、St...
  • z69183787
  • z69183787
  • 2014年06月05日 16:55
  • 559

Java线程(六):线程池

自JDK5之后,Java推出了一个并发包,java.util.concurrent,在Java开发中,我们接触到了好多池的技术,String类的对象池、Integer的共享池、连接数据库的连接池、St...
  • linghu_java
  • linghu_java
  • 2015年02月03日 20:03
  • 415

Java线程(六):线程池

http://blog.csdn.net/ghsau/article/details/7443324        自JDK5之后,Java推出了一个并发包,java.util.concur...
  • amingas
  • amingas
  • 2014年08月16日 19:38
  • 133
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java线程(六):线程池
举报原因:
原因补充:

(最多只允许输入30个字)