Executors提供四种线程池

JAVA并发编程——EXECUTORS

　　线程池的思想是一种对象池的思想，开放一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完毕，对象归还给池。这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

代码: http://www.cnblogs.com/chenjingjing/articles/1683745.html

一、固定大小的线程池 newFixedThreadPool 

二、单任务线程池 newSingleThreadExecutor 

对于以上两种连接池，大小都是固定的，当要加入的池的线程（或者任务）超过池最大尺寸时候，则进入此线程池需要排队等待。一旦池中有线程完毕，则排队等待的某个线程会入池执行。

三、 可变尺寸的线程池 newCachedThreadPool

四、延迟连接池 newScheduledThreadPool 

五、自定义线程池 ThreadPoolExecutor(一顿参数)

----------------------------------------------------------------------------

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

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

Java代码  

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

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
 
(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

Java代码  

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

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

Java代码  

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

表示延迟3秒执行。

定期执行示例代码如下：

Java代码  

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

表示延迟1秒后每3秒执行一次。

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

Java代码  

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

结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：
工具目录：C:\Program Files\Java\jdk1.6.0_06\bin\jconsole.exe
运行程序做稍微修改：

Java代码  

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

效果如下：

选择我们运行的程序：

监控运行状态

请您到ITEYE网站看 java小强 原创，谢谢！

http://cuisuqiang.iteye.com/ ！

---------------------------------------------------

时间： 2024-10-06 06:26:38

Executors提供四种线程池的相关文章

Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor

介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? Java new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 1 2 3 4 5 6 7 new Thread(new

Java四种线程池

Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor 时间:2015-10-20 22:37:40      阅读:8762      评论:0      收藏:0      [点我收藏+] 介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端执行一个异

Java四种线程池的使用

Java通过Executors提供四种线程池,分别为:newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程.newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待.newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行.newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有

JAVA四种线程池实例

1.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? Java 1 2 3 4 5 6 7 new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 那你就out太多了,new Thread的弊端如下: a. 每次new Thread新建对象性能差. b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及

Java四种线程池的学习与总结

在Java开发中,有时遇到多线程的开发时,直接使用Thread操作,对程序的性能和维护上都是一个问题,使用Java提供的线程池来操作可以很好的解决问题. 一.new Thread的弊端 执行一个异步任务你还只是如下new Thread吗? new Thread(new Runnable(){ @Override public void run(){ //TODO Auto-generatedmethod stub } } ).start(); 那你就out太多了,new Thread的弊端如下:

Java 四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor

原文:http://www.cnblogs.com/zhujiabin/p/5404771.html 介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用.本文是基础篇,后面会分享下线程池一些高级功能. 1.new Thread的弊端执行一个异步任务你还只是如下new Thread吗? new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stu

Java线程池原理及四种线程池的使用

 一.线程池简介: 多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间,增加处理器单元的吞吐能力. 假设一个服务器完成一项任务所需时间为:T1 创建线程时间,T2 在线程中执行任务的时间,T3 销毁线程时间. 如果:T1 + T3 远大于 T2,则可以采用线程池,以提高服务器性能. 一个线程池包括以下四个基本组成部分: 1.线程池管理器(ThreadPool):用于创建并管理线程池,包括 创建线程池,销毁线程池,添加新任务: 2.工作线程(PoolWorke

线程池是什么？Java四种线程池的使用介绍

使用线程池的好处有很多,比如节省系统资源的开销,节省创建和销毁线程的时间等,当我们需要处理的任务较多时,就可以使用线程池,可能还有很多用户不知道Java线程池如何使用?下面小编给大家分享Java四种线程池的使用方法. 线程池介绍: 线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务.线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使

Java ExecutorService四种线程池的简单使用

我们都知道创建一个线程可以继承Thread类或者实现Runnable接口,实际Thread类就是实现了Runnable接口. 到今天才明白后端线程的作用:我们可以开启线程去执行一些比较耗时的操作,类似于前台的ajax异步操作,比如说用户上传一个大的文件,我们可以获取到文件之后开启一个线程去操作该文件,但是可以提前将结果返回去,如果同步处理有可能太耗时,影响系统可用性. 1.new Thread的弊端 原生的开启线程执行异步任务的方式: new Thread(new Runnable() { @O