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

Java线程:新特征-线程池

    博客分类:
  • java
阅读更多
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<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(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<Runnable> workQueue)
用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor。使用 Executors 工厂方法之一比使用此通用构造方法方便得多。
参数:
corePoolSize - 池中所保存的线程数,包括空闲线程。
maximumPoolSize - 池中允许的最大线程数。
keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。
unit - keepAliveTime 参数的时间单位。
workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
抛出:
IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小于零,或者 maximumPoolSize 小于或等于零,或者 corePoolSize 大于 maximumPoolSize。
NullPointerException - 如果 workQueue 为 null
 
自定义连接池稍微麻烦些,不过通过创建的ThreadPoolExecutor线程池对象,可以获取到当前线程池的尺寸、正在执行任务的线程数、工作队列等等。
 
有关Java5线程池的内容到此就没有了,更多的内容还需要研读API来获取。

本文出自 “熔 岩” 博客,请务必保留此出处http://lavasoft.blog.51cto.com/62575/222078

分享到:
评论

相关推荐

    Java多线程编程经验

    #### 十二、Java线程:新特征-线程池 线程池是一种管理线程的技术,可以有效地复用一组预创建的线程。使用线程池可以提高程序性能,并降低创建和销毁线程的开销。 #### 十三、Java线程:新特征-有返回值的线程 ...

    Java多线程编程总结

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

    java线程详解

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

    Java 线程开发讲座

    #### 十一、Java线程:新特征-线程池 - **线程池**:预先创建一定数量的线程,当任务到来时分配给空闲线程执行,提高响应速度和资源利用率。 - **实现类**:`ExecutorService`接口提供了线程池的基本功能,常用实现...

    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