`
coach
  • 浏览: 386686 次
  • 性别: Icon_minigender_2
  • 来自: 印度
社区版块
存档分类
最新评论

Java线程:新特征-线程池

阅读更多
Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要。

  有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少,大所属介绍线程方面书籍还停留在java5之前的知识层面上。

  当然新特征对做多线程程序没有必须的关系,在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。

  线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理。当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程对象所带来的性能开销,节省了系统的资源。

  在Java5之前,要实现一个线程池是相当有难度的,现在Java5为我们做好了一切,我们只需要按照提供的API来使用,即可享受线程池带来的极大便利。

  Java5的线程池分好多种:固定尺寸的线程池、可变尺寸连接池、。

  在使用线程池之前,必须知道如何去创建一个线程池,在Java5中,需要了解的是java.util.concurrent.Executors类的API,这个类提供大量创建连接池的静态方法,是必须掌握的。

  一、固定大小的线程池


  import java.util.concurrent.Executors;
  import java.util.concurrent.ExecutorService;
  /**
  * Java线程:线程池-
  *
  * @author Administrator 2009-11-4 23:30:44
  */
  public class Test {
  public static void main(String[] args) {
  //创建一个可重用固定线程数的线程池
  ExecutorService pool = Executors.newFixedThreadPool(2);
  //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
  Thread t1 = new MyThread();
  Thread t2 = new MyThread();
  Thread t3 = new MyThread();
  Thread t4 = new MyThread();
  Thread t5 = new MyThread();
  //将线程放入池中进行执行
  pool.execute(t1);
  pool.execute(t2);
  pool.execute(t3);
  pool.execute(t4);
  pool.execute(t5);
  //关闭线程池
  pool.shutdown();
  }
  }
  class MyThread extends Thread{
  @Override
  public void run() {
  System.out.println(Thread.currentThread().getName()+"正在执行。。。");
  }
  }



  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  Process finished with exit code 0


  二、单任务线程池

  在上例的基础上改一行创建pool对象的代码为:

  //创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。

  ExecutorService pool = Executors.newSingleThreadExecutor();

  输出结果为:


      pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  Process finished with exit code 0


  对于以上两种连接池,大小都是固定的,当要加入的池的线程(或者任务)超过池最大尺寸时候,则入此线程池需要排队等待。

  一旦池中有线程完毕,则排队等待的某个线程会入池执行。

  三、可变尺寸的线程池

  与上面的类似,只是改动下pool的创建方式:

  //创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。


   ExecutorService pool = Executors.newCachedThreadPool();
  pool-1-thread-5正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-4正在执行。。。
  pool-1-thread-3正在执行。。。
  pool-1-thread-2正在执行。。。
  Process finished with exit code 0


  四、延迟连接池

 


 import java.util.concurrent.Executors;
  import java.util.concurrent.ScheduledExecutorService;
  import java.util.concurrent.TimeUnit;
  /**
  * Java线程:线程池-
  *
  * @author Administrator 2009-11-4 23:30:44
  */
  public class Test {
  public static void main(String[] args) {
  //创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。
  ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
  //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
  Thread t1 = new MyThread();
  Thread t2 = new MyThread();
  Thread t3 = new MyThread();
  Thread t4 = new MyThread();
  Thread t5 = new MyThread();
  //将线程放入池中进行执行
  pool.execute(t1);
  pool.execute(t2);
  pool.execute(t3);
  //使用延迟执行风格的方法
  pool.schedule(t4, 10, TimeUnit.MILLISECONDS);
  pool.schedule(t5, 10, TimeUnit.MILLISECONDS);
  //关闭线程池
  pool.shutdown();
  }
  }
  class MyThread extends Thread {
  @Override
  public void run() {
  System.out.println(Thread.currentThread().getName() + "正在执行。。。");
  }
  }



    pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  Process finished with exit code 0


  五、单任务延迟连接池

  在四代码基础上,做改动

  //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。

 


 ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-1正在执行。。。
  Process finished with exit code 0


  六、自定义线程池

 


 import java.util.concurrent.ArrayBlockingQueue;
  import java.util.concurrent.BlockingQueue;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.TimeUnit;
  /**
  * Java线程:线程池-自定义线程池
  *
  * @author Administrator 2009-11-4 23:30:44
  */
  public class Test {
  public static void main(String[] args) {
  //创建等待队列
  BlockingQueue bqueue = new ArrayBlockingQueue(20);
  //创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
  ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);
  //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
  Thread t1 = new MyThread();
  Thread t2 = new MyThread();
  Thread t3 = new MyThread();
  Thread t4 = new MyThread();
  Thread t5 = new MyThread();
  Thread t6 = new MyThread();
  Thread t7 = new MyThread();
  //将线程放入池中进行执行
  pool.execute(t1);
  pool.execute(t2);
  pool.execute(t3);
  pool.execute(t4);
  pool.execute(t5);
  pool.execute(t6);
  pool.execute(t7);
  //关闭线程池
  pool.shutdown();
  }
  }
  class MyThread extends Thread {
  @Override
  public void run() {
  System.out.println(Thread.currentThread().getName() + "正在执行。。。");
  try {
  Thread.sleep(100L);
  } catch (InterruptedException e) {
  e.printStackTrace();
  }
  }
  }


 
      pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  pool-1-thread-2正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  pool-1-thread-1正在执行。。。
  pool-1-thread-2正在执行。。。
  Process finished with exit code 0


  创建自定义线程池的构造方法很多,本例中参数的含义如下:


    ThreadPoolExecutor
  public ThreadPoolExecutor(int corePoolSize,
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue workQueue)


  用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。

  参数:

  corePoolSize - 池中所保存的线程数,包括空闲线程。

  maximumPoolSize - 池中允许的最大线程数。

  keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。

  unit - keepAliveTime 参数的时间单位。

  workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

  抛出:

  IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于零,或者 maximumPoolSize 小于或等于零,或者 corePoolSize 大于 maximumPoolSize。

  NullPointerException - 如果 workQueue 为 null

  自定义连接池稍微麻烦些,不过通过创建的ThreadPoolExecutor线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。

  有关Java5线程池的内容到此就没有了,更多的内容还需要研读API来获取。

分享到:
评论
6 楼 a1514966 2013-12-16  
Creates a new ThreadPoolExecutor with the given initial parameters and default thread factory and rejected execution handler. It may be more convenient to use one of the Executors factory methods instead of this general purpose constructor.

Parameters:
corePoolSize the number of threads to keep in the pool, even if they are idle.
maximumPoolSize the maximum number of threads to allow in the pool.
keepAliveTime when the number of threads is greater than the core, this is the maximum time that excess idle threads will wait for new tasks before terminating.
unit the time unit for the keepAliveTime argument.
workQueue the queue to use for holding tasks before they are executed. This queue will hold only the Runnable tasks submitted by the execute method.
Throws:
IllegalArgumentException - if corePoolSize or keepAliveTime less than zero, or if maximumPoolSize less than or equal to zero, or if corePoolSize greater than maximumPoolSize.
NullPointerException - if workQueue is null

这一段你直接在文档里粘过来让我看的好糊涂啊,中文文档不能看的呀。
除此,感谢你写的这些,正在学习
5 楼 hanmiao 2013-01-10  
楼主,你写错字了,文章第五行“大所属介绍”应该是“大多数介绍"吧...
4 楼 paladin1988 2012-08-15  
真是有如醍醐灌顶呀,哈哈,多谢了。。
3 楼 yyh123456 2012-08-03  
谢谢哥们,项目中正好涉及到这方面,有一点不明白,内存数据库和多线程池之间的关系,
2 楼 makemelike 2012-01-10  
不错,学习了~~~
1 楼 zhang4044 2011-12-15  
不错,学习了!

相关推荐

    Java多线程编程总结

    Java线程:新特征-线程池 Java线程:新特征-有返回值的线程 Java线程:新特征-锁(上) Java线程:新特征-锁(下) Java线程:新特征-信号量 Java线程:新特征-阻塞队列 Java线程:新特征-阻塞栈 Java线程:新特征-...

    java线程详解

    Java线程:新特征-线程池 一、固定大小的线程池 二、单任务线程池 三、可变尺寸的线程池 四、延迟连接池 五、单任务延迟连接池 六、自定义线程池 Java线程:新特征-有返回值的线程 Java线程:新特征-锁(上...

    Java多线程

    #### 十二、Java线程:新特征-线程池 线程池是一种管理线程的有效机制,它可以重用预先创建好的线程,从而提高响应速度和减少创建销毁线程的开销。 #### 十三、Java线程:新特征-有返回值的线程 通过使用`...

    Java多线程运算集合

    #### 十一、Java线程:新特征-线程池 - **线程池**: - 线程池是一种管理线程的机制,它可以重用预先创建好的线程,减少了创建和销毁线程的开销。 - Java的 `java.util.concurrent.ExecutorService` 接口及其实现...

    JAVA线程、线程池资料----下载不扣分,回帖加1分,欢迎下载,童叟无欺

    .......................................JAVA线程、线程池资料----下载不扣分,回帖加1分,欢迎下载,童叟无欺JAVA线程、线程池资料----下载不扣分,回帖加1分,欢迎下载,童叟无欺JAVA线程、线程池资料----下载不...

    JAVA并发编程实践-线程池-学习笔记

    Java并发编程实践中的线程池是一个关键的概念,它在多线程编程中扮演着至关重要的角色,有效地管理和调度线程资源,以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销,避免了频繁的上...

    线程-线程池-锁-集合-Map-队列.docx

    Java线程有六种状态:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。NEW表示线程刚创建还未启动,RUNNABLE表示线程在执行或等待CPU资源,BLOCKED表示线程被阻塞等待监视器锁,WAITING表示线程处于...

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

    Java8并行流中自定义线程池操作示例 Java8并行流中自定义线程池操作示例主要介绍了Java8并行流中自定义线程池操作,结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧。 1. 概览 Java8引入了...

    多线程简单应用-线程池

    另一个常用的是Executors工具类,它提供了一些静态工厂方法,方便地创建不同类型的线程池,如固定大小的线程池、单线程线程池和缓存线程池。 线程池的工作流程大致如下: 1. 当提交一个任务到线程池时,线程池会...

    论文研究-线程池技术研究与应用.pdf

    - 新建(New):新创建的线程尚未启动。 - 可运行(Runnable):线程可能正在运行或者在运行队列中等待。 - 阻塞(Blocked):线程处于阻塞状态,等待监视器锁。 - 等待(Waiting):线程无限期等待另一个线程...

    java多线程、并发及线程池介绍收藏的几篇文档

    - 线程优先级:Java线程有10个优先级,但实际效果可能受到操作系统调度的影响。 - 异常处理:线程中抛出的异常不会影响主线程,需通过`Thread.UncaughtExceptionHandler`设置未捕获异常处理器。 6. **使用Java...

    Java中多线程的使用线程池.docx

    `Executors` 类是一个静态工厂类,用于创建不同类型的线程池,如固定大小的线程池、单线程线程池、缓存线程池等。 4. **创建线程池**:使用`Executors`类的静态方法创建线程池,例如 `newFixedThreadPool(int ...

    12-线程池ThreadPoolExecutor底层原理源码分析(下)-周瑜.pdf

    2. 如果线程池的worker线程数量小于核心线程数,创建新的worker线程。 3. 如果队列未满,则尝试将任务添加到队列中。 4. 如果队列已满,且当前线程数小于最大线程数,则创建新的worker线程。 5. 如果以上条件均不...

    线程池管理多线程上传

    在Java等编程语言中,线程池通过有效地管理和复用线程资源,避免了频繁创建和销毁线程带来的开销,提升了系统性能。下面将详细讲解线程池的核心概念、工作原理以及如何应用于文件上传场景。 1. **线程池核心概念**...

    Java线程入门大全

    ### Java线程入门大全知识点详解 #### 一、线程基础概述 - **定义与特点:** - **线程**是一种比进程更细粒度的执行单元,它允许在一个进程中并发执行多个任务。 - **多线程**能够提高程序的效率和响应速度,...

    Java并发编程:线程池的使用 - 平凡希 - 博客园1

    Java并发编程中的线程池是提高系统效率的关键工具,它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务,从而避免了每次任务执行完毕后销毁线程的开销。在Java中,线程池的核心实现是`java....

    并发-线程池和阻塞队列

    在Java编程中,"并发-线程池和阻塞队列"是两个核心概念,它们在多线程环境下处理任务调度和数据同步方面发挥着重要作用。线程池是一种管理线程资源的有效方式,而阻塞队列则常用于线程间通信和数据共享。 线程池...

Global site tag (gtag.js) - Google Analytics