程序博客网 > 数控车床编程论文

Java线程池

来源：互联网 发布：数控车床编程论文 编辑：程序博客网 时间：2024/06/13 05:49

        在平时的项目开发之中，如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。在Java中可以通过线程池来处理这样的情况。

Java中的ThreadPoolExecutor类

ThreadPoolExecutor的源码：

public class ThreadPoolExecutor extends AbstractExecutorService {    .....    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue);     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);     public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);    ...}

下面解释下一下构造器中各个参数的含义：
  • corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
  • maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
  • keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
  • unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：
复制代码
复制代码
TimeUnit.DAYS;               //天TimeUnit.HOURS;             //小时TimeUnit.MINUTES;           //分钟TimeUnit.SECONDS;           //秒TimeUnit.MILLISECONDS;      //毫秒TimeUnit.MICROSECONDS;      //微妙TimeUnit.NANOSECONDS;       //纳秒
复制代码
复制代码
 
  • workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue;LinkedBlockingQueue;SynchronousQueue;
　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。
  • threadFactory：线程工厂，主要用来创建线程；
  • handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 
一个任务通过 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;

  3. import java.io.Serializable;
  4. import java.util.concurrent.ArrayBlockingQueue;
  5. import java.util.concurrent.ThreadPoolExecutor;
  6. import java.util.concurrent.TimeUnit;

  8. public class TestThreadPool2
  9. {
  10.     private static int produceTaskSleepTime = 2;
  11.     private static int produceTaskMaxNumber = 10;

  13.     public static void main(String[] args)
  14.     {
  15.         // 构造一个线程池
  16.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),
  17.                 new ThreadPoolExecutor.DiscardOldestPolicy());

  19.         for (int i = 1; i <= produceTaskMaxNumber; i++)
  20.         {
  21.             try
  22.             {
  23.                 // 产生一个任务，并将其加入到线程池
  24.                 String task = "task@ " + i;
  25.                 System.out.println("put " + task);
  26.                 threadPool.execute(new ThreadPoolTask(task));

  28.                 // 便于观察，等待一段时间
  29.                 Thread.sleep(produceTaskSleepTime);
  30.             }
  31.             catch (Exception e)
  32.             {
  33.                 e.printStackTrace();
  34.             }
  35.         }
  36.     }
  37. }

  39. /**
  40.  * 线程池执行的任务
  41.  */
  42. class ThreadPoolTask implements Runnable, Serializable
  43. {
  44.     private static final long serialVersionUID = 0;
  45.     private static int consumeTaskSleepTime = 2000;
  46.     // 保存任务所需要的数据
  47.     private Object threadPoolTaskData;

  49.     ThreadPoolTask(Object tasks)
  50.     {
  51.         this.threadPoolTaskData = tasks;
  52.     }

  54.     public void run()
  55.     {
  56.         // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
  57.         System.out.println(Thread.currentThread().getName());
  58.         System.out.println("start .." + threadPoolTaskData);

  60.         try
  61.         {
  62.             // //便于观察，等待一段时间
  63.             Thread.sleep(consumeTaskSleepTime);
  64.         }
  65.         catch (Exception e)
  66.         {
  67.             e.printStackTrace();
  68.         }
  69.         threadPoolTaskData = null;
  70.     }

  72.     public Object getTask()
  73.     {
  74.         return this.threadPoolTaskData;
  75.     }
  76. }
说明： 
1、在这段程序中，一个任务就是一个Runnable类型的对象，也就是一个ThreadPoolTask类型的对象。 
2、一般来说任务除了处理方式外，还需要处理的数据，处理的数据通过构造方法传给任务。 
3、在这段程序中，main()方法相当于一个残忍的领导，他派发出许多任务，丢给一个叫 threadPool的任劳任怨的小组来做。 
这个小组里面队员至少有两个，如果他们两个忙不过来，任务就被放到任务列表里面。 
如果积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。但是基于成本的考虑，不能雇佣太多的队员，至多只能雇佣 4个。 
如果四个队员都在忙时，再有新的任务，这个小组就处理不了了，任务就会被通过一种策略来处理，我们的处理方式是不停的派发，直到接受这个任务为止(更残忍！呵呵)。 
因为队员工作是需要成本的，如果工作很闲，闲到 3SECONDS都没有新的任务了，那么有的队员就会被解雇了，但是，为了小组的正常运转，即使工作再闲，小组的队员也不能少于两个。 
4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制，改变这两个值就可以观察不同速率下程序的工作情况。 
5、通过调整4中所指的数据，再加上调整任务丢弃策略，换上其他三种策略，就可以看出不同策略下的不同处理方式。 
6、对于其他的使用方法，参看jdk的帮助，很容易理解和使用。 


另一个例子: 

点击(此处)折叠或打开
  1. package demo;

  3. import java.util.Queue;
  4. import java.util.concurrent.ArrayBlockingQueue;
  5. import java.util.concurrent.ThreadPoolExecutor;
  6. import java.util.concurrent.TimeUnit;

  8. public class ThreadPoolExecutorTest
  9. {

  11.     private static int queueDeep = 4;

  13.     public void createThreadPool()
  14.     {
  15.         /* 
  16.          * 创建线程池，最小线程数为2，最大线程数为4，线程池维护线程的空闲时间为3秒， 
  17.          * 使用队列深度为4的有界队列，如果执行程序尚未关闭，则位于工作队列头部的任务将被删除， 
  18.          * 然后重试执行程序（如果再次失败，则重复此过程），里面已经根据队列深度对任务加载进行了控制。 
  19.          */ 
  20.         ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
  21.                 new ThreadPoolExecutor.DiscardOldestPolicy());

  23.         // 向线程池中添加 10 个任务
  24.         for (int i = 0; i < 10; i++)
  25.         {
  26.             try
  27.             {
  28.                 Thread.sleep(1);
  29.             }
  30.             catch (InterruptedException e)
  31.             {
  32.                 e.printStackTrace();
  33.             }
  34.             while (getQueueSize(tpe.getQueue()) >= queueDeep)
  35.             {
  36.                 System.out.println("队列已满，等3秒再添加任务");
  37.                 try
  38.                 {
  39.                     Thread.sleep(3000);
  40.                 }
  41.                 catch (InterruptedException e)
  42.                 {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.             TaskThreadPool ttp = new TaskThreadPool(i);
  47.             System.out.println("put i:" + i);
  48.             tpe.execute(ttp);
  49.         }

  51.         tpe.shutdown();
  52.     }

  54.     private synchronized int getQueueSize(Queue queue)
  55.     {
  56.         return queue.size();
  57.     }

  59.     public static void main(String[] args)
  60.     {
  61.         ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
  62.         test.createThreadPool();
  63.     }

  65.     class TaskThreadPool implements Runnable
  66.     {
  67.         private int index;

  69.         public TaskThreadPool(int index)
  70.         {
  71.             this.index = index;
  72.         }

  74.         public void run()
  75.         {
  76.             System.out.println(Thread.currentThread() + " index:" + index);
  77.             try
  78.             {
  79.                 Thread.sleep(3000);
  80.             }
  81.             catch (InterruptedException e)
  82.             {
  83.                 e.printStackTrace();
  84.             }
  85.         }
  86.     }
  87. }

1 0
数控车床编程论文 数控车床编程论文
原创粉丝点击
热门IT博客
银行家算法安全性算法银行家算法安全性算法
淘宝鹊桥登录淘宝鹊桥登录
淘宝商品上架时间
乐视电视网络连接不上
淘宝店铺冻结能退货吗
matlab最优化计算
2017淘宝达人登录入口
北京软件行业协会官网
ck jeans 知乎
c语言中的15优先级表
java sftp 创建目录
人脸识别算法开源代码
网络执法官破解版
淘宝开店保证金
淘宝详情页素材
java bigdecimal 开方
java垃圾回收算法
利用网络学英语
淘宝内部优惠券网站
全能星战 龚琳娜 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 分手怎么和好 和女朋友和好的话 怎么劝夫妻和好 劝夫妻和好的句子 前女友想和好 劝人和好的话 坏女人和好女人 和朋友和好的句子 和好如初的意思 赞美诗歌和好 好开头和好结尾 和好如初意思 和好信怎么写 和朋友和好的话 和好的面怎么保存 万和好还是万家乐好 和好书交朋友 万家乐好还是万和好 好词和好句 和好用英语怎么说 和好书交朋友手抄报 梦见和前女友和好 梦见和前男友和好 情侣吵架怎么和好 梦到和前男友和好 梦见和前女友和好了 作文的好开头和好结尾 梦见跟前男友和好 梦见跟前女友和好 梦见和男朋友和好了 梦见和女朋友和好 唐澄第几集和陆子曰和好 情侣吵架后怎么和好 男生有下家还会和女生和好 和亲罪妃 妃英理和有希子汉化本 医妃难宠王爷和离吧 妃英理和有希子熟肉 医妃难逑冷面王爷和离吧 权宠医妃林初九和萧天耀 和妃宅计划

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