一、简介 
线程池类为
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. jquery:after append appendTo三个函数的区别

    1.查找元素节点      var $li = $(“ul li:eq(0)”);//获取ul标记下的第一个li,也可以写成 $(“#ulID li:eq(0)”);    2.查找元素属性 利用jq ...

  2. 1BIT,1BYTE,1KB,1MB,1GB,1TB等计量单位换算

    http://iask.sina.com.cn/b/8961090.html知识   在数字世界里没有电影.没有杂志.没有一首首的乐曲,只有一个个的数字“1”和“0”.以前人们对于数字世界中的这两个数 ...

  3. link标签的rel属性

    <link>标签定义了当前文档与 Web 集合中其他文档的关系.link 元素是一个空元素,它仅包含属性.此元素只能存在于 head 部分,不过它可出现任何次数.在 HTML 中,< ...

  4. 一条长l的笔直的街道上有n个路灯,若这条街的起点为0,终点为l,第i个路灯坐标为ai,每盏灯可以覆盖到的最远距离为d,为了照明需求,所有灯的灯光必须覆盖整条街,但是为了省电,要是这个d最小,请找到这个最小的d。

    // ConsoleApplication3.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include<iostream> ...

  5. C#里类的get和set方法编写和调用

    using System; class Date { int day; int month; int year; public int Day{ get { return day; } set { d ...

  6. erlang的timer定时器浅析

    timer作为其计时器: erlang的计时器timer是通过一个唯一的timer进程实现的,该进程是一个gen_server,用户通过timer:send_after和timer:apply_aft ...

  7. Ubuntu64位安装Adobe Reader 9.5.5

    Aodbe Reader在Linux下的效果比Foxit Reader(福昕阅读器)要好一些,尤其对于中文文档而言.本文介绍Adobe Reader在Ubuntu下的安装,文章<Ubuntu12 ...

  8. 跟着实例学习设计模式(6)-生成器模式builder(创建型)

    生成器模式是创建型设计模式. 设计意图:将一个复杂的类表示与其构造相分离,使得同样的构建过程可以得出不同的表示. 实例类图: IVehicleBuilder:抽象建造者.为创建一个Vehicle对象并 ...

  9. zookeeper启动流程简单梳理

    等着測试童鞋完工,顺便里了下zookeeper的启动流程 zk3.4.6 启动脚本里面 nohup "$JAVA" "-Dzookeeper.log.dir=${ZOO_ ...

  10. 基于zookeeper或redis实现分布式锁

    前言 在分布式系统中,分布式锁是为了解决多实例之间的同步问题.例如master选举,能够获取分布式锁的就是master,获取失败的就是slave.又或者能够获取锁的实例能够完成特定的操作. 目前比较常 ...