程序博客网 > cs1.5百度软件

Java 7之多线程线程池 - 线程池原理（1）

来源：互联网 发布：cs1.5百度软件 编辑：程序博客网 时间：2024/05/01 16:12

来看一下线程池的框架图，如下：


1、Executor任务提交接口与Executors工具类

Executor框架同java.util.concurrent.Executor 接口在Java 5中被引入。Executor框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架。Executor存在的目的是提供一种将"任务提交"与"任务如何运行"分离开来的机制。定义如下：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public interface Executor {  
  2.     void execute(Runnable command);  
  3. }  

虽然只有一个方法，但是却为灵活且强大的异步任务执行框架提供了基础。它提供了一种标准的方法将任务的提交过程与执行过程解耦开来，并用Runnable来表示任务。那么我们怎么得到Executor对象呢？这就是接下来要介绍的Exectors了。

Executors为Executor，ExecutorService，ScheduledExecutorService，ThreadFactory和Callable类提供了一些工具方法，类似于集合中的Collections类的功能。Executors方便的创建线程池。

　　1>newCachedThreadPool ：该线程池比较适合没有固定大小并且比较快速就能完成的小任务，它将为每个任务创建一个线程。那这样子它与直接创建线程对象（new Thread()）有什么区别呢？看到它的第三个参数60L和第四个参数TimeUnit.SECONDS了吗？好处就在于60秒内能够重用已创建的线程。下面是Executors中的newCachedThreadPool()的源代码：　　

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public static ExecutorService newCachedThreadPool() {  
  2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());  
  3.     }  

　　2> newFixedThreadPool使用的Thread对象的数量是有限的,如果提交的任务数量大于限制的最大线程数，那么这些任务讲排队，然后当有一个线程的任务结束之后，将会根据调度策略继续等待执行下一个任务。下面是Executors中的newFixedThreadPool()的源代码：　　

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public static ExecutorService newFixedThreadPool(int nThreads) {  
  2.       return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());  
  3.   }  

　　3>newSingleThreadExecutor就是线程数量为1的FixedThreadPool,如果提交了多个任务，那么这些任务将会排队，每个任务都会在下一个任务开始之前运行结束，所有的任务将会使用相同的线程。下面是Executors中的newSingleThreadExecutor()的源代码：　　

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public static ExecutorService newSingleThreadExecutor() {  
  2.         return new FinalizableDelegatedExecutorService  
  3.             (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));  
  4.     }  

     4>newScheduledThreadPool创建一个固定长度的线程池，而且以延迟或定时的方式来执行任务。

通过如上配置的线程池的创建方法源代码，我们可以发现：

　　1> 除了CachedThreadPool使用的是直接提交策略的缓冲队列以外，其余两个用的采用的都是无界缓冲队列，也就说，FixedThreadPool和SingleThreadExecutor创建的线程数量就不会超过 corePoolSize。

　   2> 我们可以再来看看三个线程池采用的ThreadPoolExecutor构造方法都是同一个，使用的都是默认的ThreadFactory和handler:

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1.  private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();  
  2.    
  3.  public ThreadPoolExecutor(int corePoolSize,  
  4.                      int maximumPoolSize,  
  5.                      long keepAliveTime,  
  6.                      TimeUnit unit,  
  7.                      BlockingQueue<Runnable> workQueue) {  
  8.     this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,  
  9.         Executors.defaultThreadFactory(), defaultHandler);  
  10. }  
　也就说三个线程池创建的线程对象都是同组，优先权等级为正常的Thread.NORM_PRIORITY（5）的非守护线程，使用的被拒绝任务处理方式是直接抛出异常的AbortPolicy策略（前面有介绍）。


2、ExecutorService任务周期管理接口

Executor的实现通常都会创建线程来执行任务，但是使用异步方式来执行任务时，由于之前提交任务的状态不是立即可见的，所以如果要关闭应用程序时，就需要将受影响的任务状态反馈给应用程序。

为了解决执行服务的生命周期问题，Executor扩展了EecutorService接口，添加了一些用于生命周期管理的方法。如下：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public interface ExecutorService extends Executor {  
  2.     void shutdown();  
  3.     List<Runnable> shutdownNow();  
  4.     boolean isShutdown();  
  5.     boolean isTerminated();  
  6.     boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;  
  7.     // 省略部分方法  
  8. }  


3、ThreadPoolExecutor线程池实现类

先来看一下这个类中定义的重要变量，如下：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. private final BlockingQueue<Runnable> workQueue;              // 阻塞队列  
  2. private final ReentrantLock mainLock = new ReentrantLock();   // 互斥锁  
  3. private final HashSet<Worker> workers = new HashSet<Worker>();// 线程集合.一个Worker对应一个线程  
  4. private final Condition termination = mainLock.newCondition();// 终止条件  
  5. private int largestPoolSize;           // 线程池中线程数量曾经达到过的最大值。  
  6. private long completedTaskCount;       // 已完成任务数量  
  7. private volatile ThreadFactory threadFactory;     // ThreadFactory对象，用于创建线程。  
  8. private volatile RejectedExecutionHandler handler;// 拒绝策略的处理句柄  
  9. private volatile long keepAliveTime;   // 线程池维护线程所允许的空闲时间  
  10. private volatile boolean allowCoreThreadTimeOut;  
  11. private volatile int corePoolSize;     // 线程池维护线程的最小数量，哪怕是空闲的  
  12. private volatile int maximumPoolSize;  // 线程池维护的最大线程数量  
其中有几个重要的规则需要说明一下：

1> corePoolSize与maximumPoolSize  由于ThreadPoolExecutor 将根据 corePoolSize和 maximumPoolSize设置的边界自动调整池大小，当新任务在方法 execute(java.lang.Runnable) 中提交时：

  1.        如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的；
  2. 　　如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池是大小固定的，如果运行的线程与corePoolSize相同，当有新请求过来时，若workQueue未满，则将请求放入workQueue中，等待有空闲的线程去从workQueue中取任务并处理
  3. 　　如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程才创建新的线程去处理请求；
  4. 　　如果运行的线程多于corePoolSize 并且等于maximumPoolSize，若队列已经满了，则通过handler所指定的策略来处理新请求；
  5. 　　如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务

也就是说，处理任务的优先级为： 

  • 1. 核心线程corePoolSize > 任务队列workQueue > 最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
  • 2. 当池中的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁。
2> workQueue 线程池所使用的缓冲队列，该缓冲队列的长度决定了能够缓冲的最大数量，缓冲队列有三种通用策略：

　　1) 直接提交。工作队列的默认选项是 SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;

 　　2) 无界队列。使用无界队列（例如，不具有预定义容量的 LinkedBlockingQueue）将导致在所有 corePoolSize 线程都忙时新任务在队列中等待。这样，创建的线程就不会超过 corePoolSize。（因此，maximumPoolSize 的值也就无效了。）当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性;

 　　3) 有界队列。当使用有限的 maximumPoolSizes 时，有界队列（如 ArrayBlockingQueue）有助于防止资源耗尽，但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷：使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销，但是可能导致人工降低吞吐量。如果任务频繁阻塞（例如，如果它们是 I/O 边界），则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小，CPU 使用率较高，但是可能遇到不可接受的调度开销，这样也会降低吞吐量.

3>ThreadFactory   使用 ThreadFactory 创建新线程。如果没有另外说明，则在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态等等。如果从 newThread 返回 null 时 ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public interface ThreadFactory {  
  2.     Thread newThread(Runnable r);  
  3. }  
而构造方法中的threadFactory对象，是通过 Executors.defaultThreadFactory()返回的。Executors.java中的defaultThreadFactory()源码如下：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public static ThreadFactory defaultThreadFactory() {  
  2.      return new DefaultThreadFactory();  
  3.  }  
在DefaultThreadFactory类中实现了ThreadFactory接口并对其中定义的方法进行了实现，如下：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. static class DefaultThreadFactory implements ThreadFactory {  
  2.     private static final AtomicInteger poolNumber = new AtomicInteger(1);  
  3.     private final ThreadGroup group;  
  4.     private final AtomicInteger threadNumber = new AtomicInteger(1);  
  5.     private final String namePrefix;  
  6.   
  7.     DefaultThreadFactory() {  
  8.         SecurityManager s = System.getSecurityManager();  
  9.         group = (s != null) ? s.getThreadGroup() :  Thread.currentThread().getThreadGroup();  
  10.         namePrefix = "pool-" +  poolNumber.getAndIncrement() +  "-thread-";  
  11.     }  
  12.     // 为线程池创建新的任务执行线程  
  13.     public Thread newThread(Runnable r) {  
  14.         // 线程对应的任务是Runnable对象r  
  15.         Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(), 0);  
  16.         // 设为非守护线程  
  17.         if (t.isDaemon())  
  18.             t.setDaemon(false);  
  19.         // 将优先级设为Thread.NORM_PRIORITY  
  20.         if (t.getPriority() != Thread.NORM_PRIORITY)  
  21.             t.setPriority(Thread.NORM_PRIORITY);  
  22.         return t;  
  23.     }  
  24. }  

4>RejectedExecutionHandler

    当Executor已经关闭（即执行了executorService.shutdown()方法后），并且Executor将有限边界用于最大线程和工作队列容量，且已经饱和时，在方法execute()中提交的新任务将被拒绝.

　 在以上述情况下，execute 方法将调用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四种预定义的处理程序策略：

　　　　1) 在默认的 ThreadPoolExecutor.AbortPolicy      处理程序遭到拒绝将抛出运行时 RejectedExecutionException;
　　　　2) 在 ThreadPoolExecutor.CallerRunsPolicy        线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度

　　　　3) 在 ThreadPoolExecutor.DiscardPolicy             不能执行的任务将被删除;

　　　　4) 在 ThreadPoolExecutor.DiscardOldestPolicy    如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

线程池默认会采用的是defaultHandler策略。首先看defaultHandler的定义：

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); // 使用默认的拒绝策略  
[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public static class AbortPolicy implements RejectedExecutionHandler {  
  2.     public AbortPolicy() { }  
  3.     // 抛出异常  
  4.     public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {  
  5.         throw new RejectedExecutionException("Task " + r.toString() +  " rejected from " +  e.toString());  
  6.     }  
  7. }  

看一下其他拒绝策略的具体实现。

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. class MyRunnable implements Runnable {  
  2.     private String name;  
  3.     public MyRunnable(String name) {  
  4.         this.name = name;  
  5.     }  
  6.     @Override  
  7.     public void run() {  
  8.         try {  
  9.             System.out.println(this.name + " is running.");  
  10.             Thread.sleep(100);  
  11.         } catch (Exception e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15. }  
如上是一个测试任务的例子，下面编写4个测试用例来测试。

1. DiscardPolicy 示例

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class DiscardPolicyDemo {  
  2.   
  3.     private static final int THREADS_SIZE = 1;  
  4.     private static final int CAPACITY = 1;  
  5.   
  6.     public static void main(String[] args) throws Exception {  
  7.   
  8.         // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  
  9.         ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));  
  10.         // 设置线程池的拒绝策略为"丢弃"  
  11.         pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());  
  12.   
  13.         // 新建10个任务，并将它们添加到线程池中。  
  14.         for (int i = 0; i < 10; i++) {  
  15.             Runnable myrun = new MyRunnable("task-"+i);  
  16.             pool.execute(myrun);  
  17.         }  
  18.         // 关闭线程池  
  19.         pool.shutdown();  
  20.     }  
  21. }  
线程池pool的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，这意味着"线程池能同时运行的任务数量最大只能是1"。
线程池pool的阻塞队列是ArrayBlockingQueue，ArrayBlockingQueue是一个有界的阻塞队列，ArrayBlockingQueue的容量为1。这也意味着线程池的阻塞队列只能有一个线程池阻塞等待。
根据""中分析的execute()代码可知：线程池中共运行了2个任务。第1个任务直接放到Worker中，通过线程去执行；第2个任务放到阻塞队列中等待。其他的任务都被丢弃了！

2. DiscardOldestPolicy 示例

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class DiscardOldestPolicyDemo {  
  2.   
  3.     private static final int THREADS_SIZE = 1;  
  4.     private static final int CAPACITY = 1;  
  5.   
  6.     public static void main(String[] args) throws Exception {  
  7.   
  8.         // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  
  9.         ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
  10.                 new ArrayBlockingQueue<Runnable>(CAPACITY));  
  11.         // 设置线程池的拒绝策略为"DiscardOldestPolicy"  
  12.         pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());  
  13.   
  14.         // 新建10个任务，并将它们添加到线程池中。  
  15.         for (int i = 0; i < 10; i++) {  
  16.             Runnable myrun = new MyRunnable("task-"+i);  
  17.             pool.execute(myrun);  
  18.         }  
  19.         // 关闭线程池  
  20.         pool.shutdown();  
  21.     }  
  22. }  

运行结果：

task-0 is running.task-9 is running.

将"线程池的拒绝策略"由DiscardPolicy修改为DiscardOldestPolicy之后，当有任务添加到线程池被拒绝时，线程池会丢弃阻塞队列中末尾的任务，然后将被拒绝的任务添加到末尾。

3. AbortPolicy 示例

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class AbortPolicyDemo {  
  2.   
  3.     private static final int THREADS_SIZE = 1;  
  4.     private static final int CAPACITY = 1;  
  5.   
  6.     public static void main(String[] args) throws Exception {  
  7.   
  8.         // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  
  9.         ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
  10.                 new ArrayBlockingQueue<Runnable>(CAPACITY));  
  11.         // 设置线程池的拒绝策略为"抛出异常"  
  12.         pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());  
  13.   
  14.         try {  
  15.   
  16.             // 新建10个任务，并将它们添加到线程池中。  
  17.             for (int i = 0; i < 10; i++) {  
  18.                 Runnable myrun = new MyRunnable("task-"+i);  
  19.                 pool.execute(myrun);  
  20.             }  
  21.         } catch (RejectedExecutionException e) {  
  22.             e.printStackTrace();  
  23.             // 关闭线程池  
  24.             pool.shutdown();  
  25.         }  
  26.     }  
  27. }  

(某一次)运行结果：

java.util.concurrent.RejectedExecutionException
    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1774)    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:768)    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:656)    at AbortPolicyDemo.main(AbortPolicyDemo.java:27)task-0 is running.task-1 is running.

将"线程池的拒绝策略"由DiscardPolicy修改为AbortPolicy之后，当有任务添加到线程池被拒绝时，会抛出RejectedExecutionException。

4. CallerRunsPolicy 示例

[java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
  1. public class CallerRunsPolicyDemo {  
  2.   
  3.     private static final int THREADS_SIZE = 1;  
  4.     private static final int CAPACITY = 1;  
  5.   
  6.     public static void main(String[] args) throws Exception {  
  7.   
  8.         // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。  
  9.         ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,  
  10.                 new ArrayBlockingQueue<Runnable>(CAPACITY));  
  11.         // 设置线程池的拒绝策略为"CallerRunsPolicy"  
  12.         pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
  13.   
  14.         // 新建10个任务，并将它们添加到线程池中。  
  15.         for (int i = 0; i < 10; i++) {  
  16.             Runnable myrun = new MyRunnable("task-"+i);  
  17.             pool.execute(myrun);  
  18.         }  
  19.   
  20.         // 关闭线程池  
  21.         pool.shutdown();  
  22.     }  
  23. }  

(某一次)运行结果：

task-2 is running.
task-3 is running.task-4 is running.task-5 is running.task-6 is running.task-7 is running.task-8 is running.task-9 is running.task-0 is running.task-1 is running.

将"线程池的拒绝策略"由DiscardPolicy修改为CallerRunsPolicy之后，当有任务添加到线程池被拒绝时，线程池会将被拒绝的任务添加到"线程池正在运行的线程"中取运行。

0 0
cs1.5百度软件 cs1.5百度软件
原创粉丝点击
热门IT博客
淘宝卖什么利润高淘宝卖什么利润高
免费商城制作软件免费商城制作软件
数据库开发软件
2k16捏脸数据 詹姆斯
单片机电子琴汇编程序
广告拦截软件安卓版
队列在哪删除数据
电视大师直播软件
怎么才能让淘宝店铺排名靠前
笔记本电脑选购 知乎
手机怎样修改淘宝地址
国家大数据项目
c#高级编程第10版 pdf
手机播放软件下载
vb虚拟机桥接模式设置
js里的on是什么意思
广电网络转型升级之路
章鱼直播助手mac
w10计算机缺少网络协议
python time 时间戳
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 惹火999次 乔爷坏完结 惹火九九九次乔爷坏 乔宝儿君之牧 乔宝儿君之牧免费阅读大结局 乔宝儿君之牧免费阅读完整片 乔宝儿君之牧全文免费阅读 乔瑟夫 乔瓦尼 乔的笑 乔省长和他的女儿们 乔染纪寒骁免费阅读 乔染纪寒骁全文免费阅读 纪寒骁乔染全集目录 纪寒骁和乔染免费阅读 乔染纪寒骁全文 乔染纪寒骁493章 乔裕纪思璇番外新春合家欢 乔裕纪思璇番外孩子 乔裕纪思璇婚后续写 乔裕纪思璇婚后生活 乔科尔 乔立夫 乔立夫本人图片 乔立夫简介 乔立夫与邵苗苗的照片 乔紫荷 乔纳金 乔组词 乔维安作品 乔维安 空荡荡的爱 乔维安 京洛再无佳人 乔维安 我的私人劳家卓 乔维安 京洛再无佳人2 乔维安 乔致庸 乔致庸简介 乔致庸家谱 乔致庸家产 乔致庸放现代有多少钱 乔若熙 萧晨乔雪

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里