一、简介 
线程池类为
java.util.concurrent.ThreadPoolExecutor,常用构造方法为:

ThreadPoolExecutor(int
corePoolSize, int maximumPoolSize, 
long
keepAliveTime, TimeUnit unit, 
BlockingQueue
workQueue, 
RejectedExecutionHandler
handler) 
corePoolSize:
线程池维护线程的最少数量 
maximumPoolSize:线程池维护线程的最大数量 
keepAliveTime:
线程池维护线程所允许的空闲时间 
unit:
线程池维护线程所允许的空闲时间的单位 
workQueue:
线程池所使用的缓冲队列 
handler:
线程池对拒绝任务的处理策略

一个任务通过
execute(Runnable)方法被添加到线程池,任务就是一个 Runnable类型的对象,任务的执行方法就是
Runnable类型对象的run()方法。

当一个任务通过execute(Runnable)方法欲添加到线程池时:

如果此时线程池中的数量小于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。 
如果此时线程池中的数量等于
corePoolSize,但是缓冲队列 workQueue未满,那么任务被放入缓冲队列。 
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量小于maximumPoolSize,建新的线程来处理被添加的任务。 
如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过
handler所指定的策略来处理此任务。

也就是:处理任务的优先级为: 
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。

当线程池中的线程数量大于
corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。

unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性: 
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我常用的是:java.util.concurrent.ArrayBlockingQueue

handler有四个选择: 
ThreadPoolExecutor.AbortPolicy() 
抛出java.util.concurrent.RejectedExecutionException异常 
ThreadPoolExecutor.CallerRunsPolicy() 
重试添加当前的任务,他会自动重复调用execute()方法 
ThreadPoolExecutor.DiscardOldestPolicy() 
抛弃旧的任务 
ThreadPoolExecutor.DiscardPolicy() 
抛弃当前的任务

二、一般用法举例

  1. package
    demo;
  2. import java.io.Serializable;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;
  6. public class TestThreadPool2
  7. {
  8. private static int
    produceTaskSleepTime = 2;
  9. private static int
    produceTaskMaxNumber = 10;
  10. public static void
    main(String[] args)
  11. {
  12. // 构造一个线程池
  13. ThreadPoolExecutor threadPool
    = new
    ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(3),
  14. new ThreadPoolExecutor.DiscardOldestPolicy());
  15. for (int i = 1; i <=
    produceTaskMaxNumber; i++)
  16. {
  17. try
  18. {
  19. //
    产生一个任务,并将其加入到线程池
  20. String task = "task@ "
    + i;
  21. System.out.println("put " +
    task);
  22. threadPool.execute(new ThreadPoolTask(task));
  23. // 便于观察,等待一段时间
  24. Thread.sleep(produceTaskSleepTime);
  25. }
  26. catch (Exception
    e)
  27. {
  28. e.printStackTrace();
  29. }
  30. }
  31. }
  32. }
  33. /**
  34. * 线程池执行的任务
  35. */
  36. class ThreadPoolTask implements Runnable,
    Serializable
  37. {
  38. private static final
    long serialVersionUID = 0;
  39. private static int
    consumeTaskSleepTime = 2000;
  40. // 保存任务所需要的数据
  41. private Object threadPoolTaskData;
  42. ThreadPoolTask(Object tasks)
  43. {
  44. this.threadPoolTaskData = tasks;
  45. }
  46. public void run()
  47. {
  48. //
    处理一个任务,这里的处理方式太简单了,仅仅是一个打印语句
  49. System.out.println(Thread.currentThread().getName());
  50. System.out.println("start .." +
    threadPoolTaskData);
  51. try
  52. {
  53. // //便于观察,等待一段时间
  54. Thread.sleep(consumeTaskSleepTime);
  55. }
  56. catch (Exception
    e)
  57. {
  58. e.printStackTrace();
  59. }
  60. threadPoolTaskData = null;
  61. }
  62. public Object getTask()
  63. {
  64. return this.threadPoolTaskData;
  65. }
  66. }

另一个例子:

  1. package
    demo;
  2. import java.util.Queue;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;
  6. public class ThreadPoolExecutorTest
  7. {
  8. private static int
    queueDeep = 4;
  9. public void createThreadPool()
  10. {
  11. /*
  12. * 创建线程池,最小线程数为2,最大线程数为4,线程池维护线程的空闲时间为3秒,
  13. * 使用队列深度为4的有界队列,如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,
  14. * 然后重试执行程序(如果再次失败,则重复此过程),里面已经根据队列深度对任务加载进行了控制。
  15. */
  16. ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(queueDeep),
  17. new ThreadPoolExecutor.DiscardOldestPolicy());
  18. // 向线程池中添加 10 个任务
  19. for (int i = 0; i < 10;
    i++)
  20. {
  21. try
  22. {
  23. Thread.sleep(1);
  24. }
  25. catch (InterruptedException e)
  26. {
  27. e.printStackTrace();
  28. }
  29. while (getQueueSize(tpe.getQueue()) >=
    queueDeep)
  30. {
  31. System.out.println("队列已满,等3秒再添加任务");
  32. try
  33. {
  34. Thread.sleep(3000);
  35. }
  36. catch (InterruptedException e)
  37. {
  38. e.printStackTrace();
  39. }
  40. }
  41. TaskThreadPool ttp = new TaskThreadPool(i);
  42. System.out.println("put i:" +
    i);
  43. tpe.execute(ttp);
  44. }
  45. tpe.shutdown();
  46. }
  47. private synchronized int getQueueSize(Queue queue)
  48. {
  49. return queue.size();
  50. }
  51. public static void
    main(String[] args)
  52. {
  53. ThreadPoolExecutorTest test =
    new ThreadPoolExecutorTest();
  54. test.createThreadPool();
  55. }
  56. class TaskThreadPool implements Runnable
  57. {
  58. private int index;
  59. public TaskThreadPool(int
    index)
  60. {
  61. this.index =
    index;
  62. }
  63. public void run()
  64. {
  65. System.out.println(Thread.currentThread() + " index:"
    + index);
  66. try
  67. {
  68. Thread.sleep(3000);
  69. }
  70. catch (InterruptedException e)
  71. {
  72. e.printStackTrace();
  73. }
  74. }
  75. }
  76. }

ThreadPoolExecutor线程池进阶使用的更多相关文章

  1. Java线程池进阶

    线程池是日常开发中常用的技术,使用也非常简单,不过想使用好线程池也不是件容易的事,开发者需要不断探索底层的实现原理,才能在不同的场景中选择合适的策略,最大程度发挥线程池的作用以及避免踩坑. 一.线程池 ...

  2. 13.ThreadPoolExecutor线程池之submit方法

    jdk1.7.0_79  在上一篇<ThreadPoolExecutor线程池原理及其execute方法>中提到了线程池ThreadPoolExecutor的原理以及它的execute方法 ...

  3. ThreadPoolExecutor 线程池的源码解析

    1.背景介绍 上一篇从整体上介绍了Executor接口,从上一篇我们知道了Executor框架的最顶层实现是ThreadPoolExecutor类,Executors工厂类中提供的newSchedul ...

  4. j.u.c系列(01) ---初探ThreadPoolExecutor线程池

    写在前面 之前探索tomcat7启动的过程中,使用了线程池(ThreadPoolExecutor)的技术 public void createExecutor() { internalExecutor ...

  5. Java并发——ThreadPoolExecutor线程池解析及Executor创建线程常见四种方式

    前言: 在刚学Java并发的时候基本上第一个demo都会写new Thread来创建线程.但是随着学的深入之后发现基本上都是使用线程池来直接获取线程.那么为什么会有这样的情况发生呢? new Thre ...

  6. ThreadPoolExecutor 线程池

    TestThreadPoolExecutorMain package core.test.threadpool; import java.util.concurrent.ArrayBlockingQu ...

  7. 十、自定义ThreadPoolExecutor线程池

    自定义ThreadPoolExecutor线程池 自定义线程池需要遵循的规则 [1]线程池大小的设置 1.计算密集型: 顾名思义就是应用需要非常多的CPU计算资源,在多核CPU时代,我们要让每一个CP ...

  8. Executors、ThreadPoolExecutor线程池讲解

    官方+白话讲解Executors.ThreadPoolExecutor线程池使用 Executors:JDK给提供的线程工具类,静态方法构建线程池服务ExecutorService,也就是Thread ...

  9. SpringBoot项目框架下ThreadPoolExecutor线程池+Queue缓冲队列实现高并发中进行下单业务

    主要是自己在项目中(中小型项目) 有支付下单业务(只是办理VIP,没有涉及到商品库存),目前用户量还没有上来,目前没有出现问题,但是想到如果用户量变大,下单并发量变大,可能会出现一系列的问题,趁着空闲 ...

随机推荐

  1. 【C语言学习】封装和模块化思想

    刚学习完C后,做的关于C的课程设计是在一个源文件里放了几百行代码,并且各个功能之间都是相互依赖的,这样就会非常麻烦. 由于当我要改动某个地方的时候,就会牵连着要改动喝多的地方.而在实际的程序设计中.这 ...

  2. 【Python】继承

    子类的方法__init__() 创建子类的实例时,Python首先需要完成的任务是给父类所有属性赋值,为此,子类的方法__init__()需要父类施以援手. class Car(): '''模拟汽车' ...

  3. java导出excel不须要额外jar包

    眼下我知道的在java中导出Excel能够用poi或在jsp的文件头改变输出流. 以下再介绍一种就用java基础包导出的Excel.导出的格式形如: 源代码例如以下: package csvExcel ...

  4. iOS - 贝塞尔曲线,折线,曲线,波浪线

    watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvZHlsYW5fbHdiXw==/font/5a6L5L2T/fontsize/400/fill/I0JBQk ...

  5. Cloudera Manager 和 CDH 4 终极安装

    转载请注明出处:http://www.cnblogs.com/thinkCoding/p/3567408.html 系统环境 操作系统:CentOS 6.5 Cloudera Manager 版本:4 ...

  6. Angular+Angular-Ui实现分页(代码更加简单,更加容易懂哦)

    前面写了个分页,但是个人认为只能玩玩,实际业务上的话代码太繁杂(笔者想走代码.性能精简化之路[不知道哪天才能成为高手~·YY一下无伤大雅]),逻辑上有点混乱.那么今天我们来看看另外一种只实现分页没有查 ...

  7. Android Camera API2中采用CameraMetadata用于从APP到HAL的参数交互

    前沿: 在全新的Camera API2架构下,常常会有人疑问再也看不到熟悉的SetParameter/Paramters等相关的身影,取而代之的是一种全新的CameraMetadata结构的出现,他不 ...

  8. GenericServlet 、Servlet和httpServler他们之间的关系

    1.GenericServlet类是所有Servlet类的祖先类. 2.HttpServlet类继承了GenericServlet类. 3.Servlet有两个非常重要的的对象,可以说是java we ...

  9. Android错误之Location of the Android SDK has not been setup in the preferences

    解决的方法:打开Help-Install new software,更新文件就可以,这时国内的朋友就须要FQ了,详细有代理,能够网上自行搜索.

  10. 【SQLServer2008】之改变主键当为null时也不会报错,可以入数据库。

    在SqlServer红框中设置主键,右键会有添加主键选项,并且设置不能为null. 当我们插入主键数据如果为null时,会插不进去,这时候我们需要修改一下,如下图: “标识规范”中选择“是”,就可以了 ...