- 浏览: 476906 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (501)
- java基础 (45)
- struts2 (22)
- WebService (9)
- JavaScript (21)
- Java多线程 (37)
- Hibernate (5)
- Spring (31)
- 数据库 (4)
- 软件设计 (1)
- J2ee (8)
- oracle (2)
- Linux (41)
- Hadoop (1)
- Java集合 (3)
- 设计模式 (3)
- 高并发 (1)
- JVM (15)
- xml (2)
- 数据库事务 (3)
- 动态代理 (1)
- tomcat (9)
- 其他 (4)
- DNS域名 (3)
- CDN (2)
- javaapi (1)
- 编码问题 (6)
- CSS样式 (1)
- TCP学习 (3)
- Java IO (6)
- 常见异常问题 (1)
- 网络编程 (1)
- 开发工具 (5)
- Maven (10)
- ibatis (12)
- Velocity (8)
- Jquery (11)
- HTTP (9)
- 中间件 (3)
- 软件管理 (2)
- Html (2)
- Redis (3)
- 服务器 (1)
- 分布式文件系统 (1)
- 异常 (1)
- 杂谈 (1)
- ICE (4)
- cxf (1)
- Apache ActiveMQ (1)
- 好文 (1)
- Json (1)
- junit (2)
- JMS (1)
- java工具 (1)
- memcache (5)
- 加密解密 (1)
- powerdesigner (3)
- Enterprise Architect (1)
- ide (0)
- hessian (3)
- svn (1)
- xstream (1)
- idea (12)
- HttpClient (2)
- solr (4)
- lucene (2)
- 正则 (2)
- 商品设计 (1)
- poi (1)
- nginx (8)
- java基础;Java集合类 (1)
- javassist (1)
- JMeter (1)
- springmvc (1)
- Java对象序列化 (2)
- java nio (4)
- RandomAccessFile (1)
- socket (1)
- netty (3)
- 博客 (1)
- Spring AOP (7)
- mysql (10)
- 远程调用 (2)
- https (3)
- 加密 (3)
- sql (1)
- git (1)
- webx (1)
- eclipse (1)
- 上传下载 (2)
- log4j (4)
- Mac 系统使用 (6)
最新评论
-
wanxiaotao12:
aswang 写道总结的不错,
正在读《java并发编程实战 ...
Java并发编程实战-学习笔记 -
aswang:
总结的不错, 正在读《java并发编程实战》,看到其中的不变性 ...
Java并发编程实战-学习笔记 -
lianhan3344:
感谢博主分享!!!!
深入剖析Tomcat How+Tomcat+Works中文367页.pdf -
vict0323:
真的是酱紫么?求真相
Spring 实际开发项目中, 是否要default-autowire="byName"
线程池的作用:
线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费了系统资源,多了造成系统拥挤效率不高。用线程池控制线程数量,其他线程排队等候。一个任务执行完毕,再从队列的中取最前面的任务开始执行。若队列中没有等待进程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了;否则进入等待队列。
为什么要用线程池:
- 减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务
- 可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)
线程池类
- package com.tdt.impl.ls;
- import java.util.LinkedList;
- /**
- * @project LocationGateway
- * @author sunnylocus
- * @verson 1.0.0
- * @date Aug 2, 2008
- * @jdk 1.4.2
- */
- public class ThreadPool extends ThreadGroup {
- private boolean isClosed = false; //线程池是否关闭
- private LinkedList workQueue; //工作队列
- private static int threadPoolID = 1; //线程池的id
- public ThreadPool(int poolSize) { //poolSize 表示线程池中的工作线程的数量
- super(threadPoolID + ""); //指定ThreadGroup的名称
- setDaemon(true); //继承到的方法,设置是否守护线程池
- workQueue = new LinkedList(); //创建工作队列
- for(int i = 0; i < poolSize; i++) {
- new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程
- }
- }
- /** 向工作队列中加入一个新任务,由工作线程去执行该任务*/
- public synchronized void execute(Runnable task) {
- if(isClosed) {
- throw new IllegalStateException();
- }
- if(task != null) {
- workQueue.add(task);//向队列中加入一个任务
- notify(); //唤醒一个正在getTask()方法中待任务的工作线程
- }
- }
- /** 从工作队列中取出一个任务,工作线程会调用此方法*/
- private synchronized Runnable getTask(int threadid) throws InterruptedException {
- while(workQueue.size() == 0) {
- if(isClosed) return null;
- System.out.println("工作线程"+threadid+"等待任务...");
- wait(); //如果工作队列中没有任务,就等待任务
- }
- System.out.println("工作线程"+threadid+"开始执行任务...");
- return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除
- }
- /** 关闭线程池 */
- public synchronized void closePool() {
- if(! isClosed) {
- waitFinish(); //等待工作线程执行完毕
- isClosed = true;
- workQueue.clear(); //清空工作队列
- interrupt(); //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类
- }
- }
- /** 等待工作线程把所有任务执行完毕*/
- public void waitFinish() {
- synchronized (this) {
- isClosed = true;
- notifyAll(); //唤醒所有还在getTask()方法中等待任务的工作线程
- }
- Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。
- int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类,根据活动线程的估计值获得线程组中当前所有活动的工作线程
- for(int i =0; i < count; i++) { //等待所有工作线程结束
- try {
- threads[i].join(); //等待工作线程结束
- }catch(InterruptedException ex) {
- ex.printStackTrace();
- }
- }
- }
- /**
- * 内部类,工作线程,负责从工作队列中取出任务,并执行
- * @author sunnylocus
- */
- private class WorkThread extends Thread {
- private int id;
- public WorkThread(int id) {
- //父类构造方法,将线程加入到当前ThreadPool线程组中
- super(ThreadPool.this,id+"");
- this.id =id;
- }
- public void run() {
- while(! isInterrupted()) { //isInterrupted()方法继承自Thread类,判断线程是否被中断
- Runnable task = null;
- try {
- task = getTask(id); //取出任务
- }catch(InterruptedException ex) {
- ex.printStackTrace();
- }
- //如果getTask()返回null或者线程执行getTask()时被中断,则结束此线程
- if(task == null) return;
- try {
- task.run(); //运行任务
- }catch(Throwable t) {
- t.printStackTrace();
- }
- }// end while
- }// end run
- }// end workThread
- }
package com.tdt.impl.ls; import java.util.LinkedList; /** * @project LocationGateway * @author sunnylocus * @verson 1.0.0 * @date Aug 2, 2008 * @jdk 1.4.2 */ public class ThreadPool extends ThreadGroup { private boolean isClosed = false; //线程池是否关闭 private LinkedList workQueue; //工作队列 private static int threadPoolID = 1; //线程池的id public ThreadPool(int poolSize) { //poolSize 表示线程池中的工作线程的数量 super(threadPoolID + ""); //指定ThreadGroup的名称 setDaemon(true); //继承到的方法,设置是否守护线程池 workQueue = new LinkedList(); //创建工作队列 for(int i = 0; i < poolSize; i++) { new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程 } } /** 向工作队列中加入一个新任务,由工作线程去执行该任务*/ public synchronized void execute(Runnable task) { if(isClosed) { throw new IllegalStateException(); } if(task != null) { workQueue.add(task);//向队列中加入一个任务 notify(); //唤醒一个正在getTask()方法中待任务的工作线程 } } /** 从工作队列中取出一个任务,工作线程会调用此方法*/ private synchronized Runnable getTask(int threadid) throws InterruptedException { while(workQueue.size() == 0) { if(isClosed) return null; System.out.println("工作线程"+threadid+"等待任务..."); wait(); //如果工作队列中没有任务,就等待任务 } System.out.println("工作线程"+threadid+"开始执行任务..."); return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除 } /** 关闭线程池 */ public synchronized void closePool() { if(! isClosed) { waitFinish(); //等待工作线程执行完毕 isClosed = true; workQueue.clear(); //清空工作队列 interrupt(); //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类 } } /** 等待工作线程把所有任务执行完毕*/ public void waitFinish() { synchronized (this) { isClosed = true; notifyAll(); //唤醒所有还在getTask()方法中等待任务的工作线程 } Thread[] threads = new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。 int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类,根据活动线程的估计值获得线程组中当前所有活动的工作线程 for(int i =0; i < count; i++) { //等待所有工作线程结束 try { threads[i].join(); //等待工作线程结束 }catch(InterruptedException ex) { ex.printStackTrace(); } } } /** * 内部类,工作线程,负责从工作队列中取出任务,并执行 * @author sunnylocus */ private class WorkThread extends Thread { private int id; public WorkThread(int id) { //父类构造方法,将线程加入到当前ThreadPool线程组中 super(ThreadPool.this,id+""); this.id =id; } public void run() { while(! isInterrupted()) { //isInterrupted()方法继承自Thread类,判断线程是否被中断 Runnable task = null; try { task = getTask(id); //取出任务 }catch(InterruptedException ex) { ex.printStackTrace(); } //如果getTask()返回null或者线程执行getTask()时被中断,则结束此线程 if(task == null) return; try { task.run(); //运行任务 }catch(Throwable t) { t.printStackTrace(); } }// end while }// end run }// end workThread }
2.测试类
- package com.tdt.test;
- import com.tdt.impl.ls.ThreadPool;
- public class ThreadPoolTest {
- public static void main(String[] args) throws InterruptedException {
- ThreadPool threadPool = new ThreadPool(3); //创建一个有个3工作线程的线程池
- Thread.sleep(500); //休眠500毫秒,以便让线程池中的工作线程全部运行
- //运行任务
- for (int i = 0; i <=5 ; i++) { //创建6个任务
- threadPool.execute(createTask(i));
- }
- threadPool.waitFinish(); //等待所有任务执行完毕
- threadPool.closePool(); //关闭线程池
- }
- private static Runnable createTask(final int taskID) {
- return new Runnable() {
- public void run() {
- // System.out.println("Task" + taskID + "开始");
- System.out.println("Hello world");
- // System.out.println("Task" + taskID + "结束");
- }
- };
- }
- }
package com.tdt.test; import com.tdt.impl.ls.ThreadPool; public class ThreadPoolTest { public static void main(String[] args) throws InterruptedException { ThreadPool threadPool = new ThreadPool(3); //创建一个有个3工作线程的线程池 Thread.sleep(500); //休眠500毫秒,以便让线程池中的工作线程全部运行 //运行任务 for (int i = 0; i <=5 ; i++) { //创建6个任务 threadPool.execute(createTask(i)); } threadPool.waitFinish(); //等待所有任务执行完毕 threadPool.closePool(); //关闭线程池 } private static Runnable createTask(final int taskID) { return new Runnable() { public void run() { // System.out.println("Task" + taskID + "开始"); System.out.println("Hello world"); // System.out.println("Task" + taskID + "结束"); } }; } }
结果:
- 工作线程0等待任务...
- 工作线程1等待任务...
- 工作线程2等待任务...
- 工作线程0开始执行任务...
- Hello world
- 工作线程0等待任务...
- 工作线程1开始执行任务...
- Hello world
- 工作线程1等待任务...
- 工作线程2开始执行任务...
- Hello world
- 工作线程2等待任务...
- 工作线程0开始执行任务...
- Hello world
- 工作线程0等待任务...
- 工作线程1开始执行任务...
- Hello world
- 工作线程1等待任务...
- 工作线程2开始执行任务...
- Hello world
- 工作线程2等待任务...
工作线程0等待任务... 工作线程1等待任务... 工作线程2等待任务... 工作线程0开始执行任务... Hello world 工作线程0等待任务... 工作线程1开始执行任务... Hello world 工作线程1等待任务... 工作线程2开始执行任务... Hello world 工作线程2等待任务... 工作线程0开始执行任务... Hello world 工作线程0等待任务... 工作线程1开始执行任务... Hello world 工作线程1等待任务... 工作线程2开始执行任务... Hello world 工作线程2等待任务...
发表评论
-
进程与线程的一个简单解释
2014-07-09 00:39 446进程与线程的一个简单解释 -
Callable和Future
2014-04-21 08:09 707Callable接口类似于Runnable,从名字就可以看 ... -
用实例揭示notify()和notifyAll()的本质区别
2014-04-15 08:43 497用实例揭示notify()和notifyAll()的本质区别 -
多线程
2014-02-15 20:44 428http://www.cnblogs.com/hoojo/ar ... -
Java偏向锁实现原理(Biased Locking)
2013-12-18 23:12 679Java偏向锁实现原理(Biased Locking) -
聊聊并发(一)——深入分析Volatile的实现原理
2013-09-12 00:40 741聊聊并发(一)——深入分析Volatile的实现原理 -
原子变量与原子类
2013-07-15 14:36 862Java多线程(二)之Atomic:原子变量与原子类 -
正确理解ThreadLocal
2013-05-13 00:25 756一般用法: class Test{ ... -
Future
2013-04-28 00:10 845如果想获取某一线程执行后的结果, 则使用Callable( ... -
ThreadPoolExecutor
2013-04-27 23:40 702ThreadPoolExecutor线程池 ... -
BlockingQueue深入分析
2013-04-27 23:18 808http://jiangzhengjun.iteye.co ... -
java线程组
2013-04-27 00:30 765线程组:线程组存在的意义,首要原因是安全。java默认创建的线 ... -
Java Thread join() 的用法
2013-04-25 00:58 697Java Thread join() 的用法 -
Java 线程池学习
2013-04-25 00:39 691Java 线程池学习 -
Java线程同步机制synchronized关键字的理解
2013-03-29 10:49 1008由于同一进程的多个线程共享同一片存储空间,在带来方便的同时 ... -
Java线程中断的本质和编程原则
2013-03-29 00:06 804在历史上,Java试图提供过抢占式限制中断,但问题多多, ... -
java线程池Executor
2013-03-26 23:58 848http://www.iteye.com/topic/ ... -
信号量
2013-03-25 22:34 857Java线程:新特征-信号量 Java的信号量实际 ... -
Java多线程共享数据问题
2013-03-21 02:32 1585两个人分别用银行卡, 存折同时取钱, 以下是代码,并执行: ... -
Thread守护线程
2013-01-17 15:16 884概念 Java有两种Thread:守护线程、用户线程 ...
相关推荐
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术,可以帮助开发者更好地管理线程资源,提高系统的性能和可靠性。然而,在使用java线程池时,一个常见的问题是:使用完线程池后到底要不要关闭?...
"Java 线程池完整代码解析" Java 线程池是 Java 语言中的一个重要概念,它允许开发者创建和管理多个线程,以提高程序的并发性和性能。下面是对给定文件的解析,包括 title、description、标签和部分内容的解析。 ...
Java线程池是一种高效管理线程的技术,它允许开发者预定义一组线程,根据任务的需要灵活调度,而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能,减少了系统资源的消耗,特别是在高并发...
java线程池知识、
Java线程池是一种高效管理线程资源的工具,它能够帮助开发者有效地控制并调度线程,从而提升系统性能,减少系统资源的浪费。在Java中,`ExecutorService`接口是线程池的主要入口,它是`java.util.concurrent`包的一...
Java线程池是Java并发编程中的重要组件,它能够有效地管理和复用线程,从而提高程序的执行效率和降低资源消耗。在JDK 1.5版本之前,Java对线程池的支持非常有限,而在JDK 1.5之后,加入了java.util.concurrent包,...
Java线程池(ThreadPool)是Java并发编程中的一个重要概念,它可以帮助我们有效地管理和控制并发执行的任务,从而提高系统的效率和稳定性。线程池通过复用已存在的线程,避免了频繁创建和销毁线程带来的开销,同时也...
### 自定义实现Java线程池 #### 一、概述 在深入探讨自定义Java线程池之前,我们先简要回顾一下线程池的基本概念及其重要性。线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动...
Java线程池是Java并发编程中的重要组成部分,它在多线程和高并发场景下扮演着关键角色。本文将深入探讨Java线程池的源码分析,并对比不同类型的线程池,以帮助开发者更好地理解和利用这一强大的工具。 首先,我们要...
Java线程池是一种高效管理线程资源的工具,它的出现是为了应对多线程编程中频繁创建和销毁线程带来的性能开销以及资源消耗。在Java中,通过使用线程池,我们可以预先创建一定数量的线程,这些线程在空闲时可以被复用...
Java线程池是Java并发编程中的重要组成部分,它允许开发者管理多个线程并有效地调度任务。线程池通过ThreadPoolExecutor类实现,这是一个高度可配置的工具,能够根据具体需求定制线程的创建、管理和销毁策略。 ...
简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类
Java线程池是一种高级的多线程处理框架,它是Java并发编程中非常重要的一个组件。线程池的原理和实现涉及到操作系统调度、内存管理和并发控制等多个方面。理解线程池的工作原理有助于优化程序性能,避免过度创建和...
2.然后根据提示运行java命令执行示例程序,观看线程池的运行结果 目标:Java中多线程技术是一个难点,但是也是一个核心技术。因为Java本身就是一个多线程语言。本人目前在给46班讲授Swing的网络编程--使用Swing来...
### Java线程池详解 #### 一、线程与线程池的概念 在Java中,线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程中的实际运作单位。一个进程(例如某个Java应用)至少有一个线程,如果线程...
Java线程池是一种高效管理并发任务的机制,它允许开发者预先配置一定数量的线程,以便在处理多个并发任务时能有效地复用这些线程,从而避免了频繁创建和销毁线程带来的开销。在Java中,`java.util.concurrent`包下的...
基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池...
Java线程池是一种高效利用系统资源、管理并发执行任务的机制。它的原理是通过预先创建一组线程,这些线程在任务到来时可以立即执行,而不是每次需要执行任务时都新建线程,从而降低了线程创建和销毁带来的开销。...
Java线程池是Java并发编程中的重要组成部分,它允许开发者高效地管理多个并发执行的线程,有效地控制系统的资源消耗,提高系统性能和稳定性。在Java中,`java.util.concurrent`包提供了`ExecutorService`接口及其...
讲述了java线程池的优点,参数,6种线程池的使用场景,线程池用到的handler,线程任务的提交方式等等。