`
zhengxuezhou
  • 浏览: 151789 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

JDK线程池的使用

    博客分类:
  • j2se
阅读更多
一、简介
线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:

  
ThreadPoolExecutor(int corePoolSize,                    int maximumPoolSize,                    long keepAliveTime, TimeUnit unit,                    BlockingQueue<Runnable> workQueue,                    RejectedExecutionHandler handler)  
  

corePoolSize
线程池维护线程的最少数量
maximumPoolSiz
线程池维护线程的最大数量
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()
抛弃当前的任务
二、一般用法举例 [下载源代码]

  
package cn.simplelife.exercise;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {
    private static int produceTaskSleepTime = 2;
    public static void main(String[] args) {
        //构造一个线程池
        ThreadPoolExecutor producerPool = new ThreadPoolExecutor(1, 1, 0,
                TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        //每隔produceTaskSleepTime的时间向线程池派送一个任务。
        int i=1;
        while(true){
            try {
                Thread.sleep(produceTaskSleepTime);

                String task = "task@ " + i;
                System.out.println("put " + task);

                producerPool.execute(new ThreadPoolTask(task));

                i++;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}                   
  

  
package cn.simplelife.exercise;

import java.io.Serializable;

/**
* 线程池执行的任务
* @author hdpan
*/
public class ThreadPoolTask implements Runnable,Serializable{

    //JDK1.5中,每个实现Serializable接口的类都推荐声明这样的一个ID
    private static final long serialVersionUID = 0;

    private static int consumeTaskSleepTime = 2000;
    private Object threadPoolTaskData;
   
    ThreadPoolTask(Object tasks){
        this.threadPoolTaskData = tasks;
    }

    //每个任务的执行过程,现在是什么都没做,除了print和sleep,:)
    public void run(){
        System.out.println("start .."+threadPoolTaskData);
        try {
            //便于观察现象,等待一段时间
            Thread.sleep(consumeTaskSleepTime);
        } catch (Exception e) {
            e.printStackTrace();
        }
        threadPoolTaskData = null;
    }
}               
  


对这两段程序的说明:

在这段程序中,一个任务就是一个Runnable类型的对象,也就是一个ThreadPoolTask类型的对象。
一般来说任务除了处理方式外,还需要处理的数据,处理的数据通过构造方法传给任务。
在这段程序中,main()方法相当于一个残忍的领导,他派发出许多任务,丢给一个叫 threadPool的任劳任怨的小组来做。

这个小组里面队员至少有两个,如果他们两个忙不过来, 任务就被放到任务列表里面。
如果积压的任务过多,多到任务列表都装不下(超过3个)的时候,就雇佣新的队员来帮忙。但是基于成本的考虑,不能雇佣太多的队员, 至多只能雇佣 4个。
如果四个队员都在忙时,再有新的任务, 这个小组就处理不了了,任务就会被通过一种策略来处理,我们的处理方式是不停的派发, 直到接受这个任务为止(更残忍!呵呵)。
因为队员工作是需要成本的,如果工作很闲,闲到 3SECONDS都没有新的任务了,那么有的队员就会被解雇了,但是,为了小组的正常运转,即使工作再闲,小组的队员也不能少于两个。
通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制, 改变这两个值就可以观察不同速率下程序的工作情况。
通过调整4中所指的数据,再加上调整任务丢弃策略, 换上其他三种策略,就可以看出不同策略下的不同处理方式。
对于其他的使用方法,参看jdk的帮助,很容易理解和使用。

[END]





----我也用了文章中的方法,虽然也简单快捷的实现了多线程,但是似乎这个方法和官方文档的使用方法还是有一定的出入,1.5的jdk新加入的类,资料真的好少----
分享到:
评论

相关推荐

    通用多线程模块(jdk线程池的运用)

    介绍一个通用多线程服务模块。是利用jdk线程池,多线程并行处理多任务,以提高执行效率。

    JDK线程池和Spring线程池的使用实例解析

    JDK线程池和Spring线程池的使用实例解析 JDK线程池和Spring线程池是两种常用的线程池实现,它们都提供了线程池的功能,但它们在使用和配置上有所不同。下面我们将详细介绍JDK线程池和Spring线程池的使用实例解析。 ...

    JDK自带线程池分析

    JDK自带线程池分析 JDK 自带线程池是 Java 语言中用于管理和执行线程的工具,旨在提高多线程...通过本文的介绍,我们可以了解 JDK 自带线程池的组成、创建方法和优点,从而更好地使用线程池来开发高效的多线程程序。

    自定义实现Java线程池1-模拟jdk线程池执行流程1

    本篇将探讨如何模拟Java的JDK线程池执行流程,以理解其设计原理。核心知识点包括线程池的执行策略、接口设计以及异常处理。 首先,Java中的线程池设计始于JDK 5.0,主要通过`java.util.concurrent`包中的`Executor`...

    JDK1.5线程池

    资源很不错

    JDK1.5线程池源码及详细注释

    下面是一个简单的线程池使用示例: ```java import java.util.concurrent.*; public class TestThreadPool { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor( ...

    jdk自带线程池实例详解

    jdk自带的线程池可以通过Executors工厂类来创建,Executors工厂类提供了多种创建线程池的方法,下面我们来看下使用示例: 1. newFixedThreadPool(固定大小的线程池) 使用newFixedThreadPool方法可以创建一个固定...

    JDK1.5中的线程池

    JDK1.5中的线程池(ThreadPoolExecutor)使用简介

    Java线程池使用说明

    在JDK 1.5版本之前,Java对线程池的支持非常有限,而在JDK 1.5之后,加入了java.util.concurrent包,其中包含了一系列关于线程池的接口和类,极大地丰富了线程池的应用场景和管理方式。 线程池的主要作用是限制系统...

    jdk1.5线程池讲解

    JDK1.5的线程池讲解,示例代码,很精辟~

    JDK1.4使用线程池

    NULL 博文链接:https://hany.iteye.com/blog/516597

    jdk1.5 线程并发与线程池的使用

    在Java编程语言中,线程并发和线程池是多任务执行的核心概念,尤其是在JDK 1.5及以后的版本中得到了显著增强。线程并发允许程序同时执行多个任务,提高了程序的效率和响应性。线程池是管理线程资源的有效方式,通过...

    JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用

    "JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用" JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用是Java多线程编程中的一种重要概念。随着多线程编程的普及,线程池的使用变得...

    jdk1.5+线程池应用

    使用jdk1.5 实现的线程池. 可以定制人物和其它特性. 下载后可以自己进行相关功能完善. 欢迎加QQ:934547801一起讨论

    JDK1[1].5中的线程池(ThreadPoolExecutor)使用简介

    JDK1[1].5中的线程池(ThreadPoolExecutor)使用简介

    Java8并行流中自定义线程池操作示例

    下面的例子中,我们有一个并行流,这个并行流使用了一个自定义的线程池去计算1到 1,000,000的和。 知识点:可以使用ForkJoinPool的构造方法并设定并行级别来创建一个自定义的线程池。 4. 总结 我们简要地看了一下...

    java线程池的使用方式

    在早期的JDK版本(如JDK 1.4及之前)中,线程池的功能相对简单,使用起来不够灵活。然而,自JDK 1.5开始,随着`java.util.concurrent`包的引入,Java线程池的功能得到了极大的增强,为开发者提供了更加高效且易于...

    java线程池使用说明[借鉴].pdf

    线程池的引入始于JDK 1.5,它引入了`java.util.concurrent`包,提供了`Executor`、`ExecutorService`和相关的实现类,如`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`。 线程池的主要作用是限制系统中同时...

    JDK1[1].5中的线程池(ThreadPoolExecutor)使用简介.

    corePoolSize: 线程池维护线程的最少数量 maximumPoolSize:线程池维护线程的最大数量 keepAliveTime: 线程池维护线程所允许的空闲时间 ...workQueue: 线程池所使用的缓冲队列 handler: 线程池对拒绝任务的处理策略

    java线程池ThreadPoolExecutor类使用详解.docx

    而线程池不允许使用Executors去创建,而要通过ThreadPoolExecutor方式,这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法,...

Global site tag (gtag.js) - Google Analytics