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

线程池示例代码版本2

工作threadWeblogic项目管理SUN 
阅读更多
包结构
src
  test
    TestThreadPool          测试类
  thread
    ThreadPool              线程池类
    WorkThread              工作线程类
    TaskMonitorThread       任务监测线程类
    TaskTimeOutThread       任务超时监测线程类
  task
    TaskManager             任务管理器
    WorkTask                任务接口
    WorkTaskImp             正常任务类
    WorkTaskAImp            异常任务类
    WorkTaskBImp            超时任务类
  event
    AbstractEvent           任务事件类
    BeginTaskEvent          任务执行开始事件类
    EndTaskEvent            任务执行结束事件类
    TaskRunTime             任务运行时间类
    TaskTimeOutEvent        任务执行超时事件类

源代码 
package test;

import task.TaskManager;
import task.WorkTask;
import task.WorkTaskAImp;
import task.WorkTaskBImp;
import task.WorkTaskImp;
import thread.ThreadPool;

/**
 * 线程池测试类,测试功能如下：
 * 1、测试线程池创建功能
 * 2、测试处理并发请求功能
 * 3、测试关闭功能
 **/
public class TestThreadPool {
	public static void main(String[] args){
		//创建线程池,开启处理请求服务
		final int threadCount=10;
		ThreadPool pool=ThreadPool.getInstance();
		pool.init(threadCount);
		//接收客户端请求
		WorkTask task1=new WorkTaskBImp("执行超时任务...");
		TaskManager.addTask(task1);
		final int requestCount=20;
		for(int i=0;i<requestCount;i++){
			WorkTask task=new WorkTaskImp("执行第"+i+"个增加用户操作...");
			TaskManager.addTask(task);
		}
		WorkTask task2=new WorkTaskBImp("执行超时任务...");
		TaskManager.addTask(task2);
		for(int i=0;i<requestCount;i++){
			WorkTask task=new WorkTaskAImp("执行第"+i+"个修改用户异常操作...");
			TaskManager.addTask(task);
		}
		for(int i=0;i<requestCount;i++){
			WorkTask task=new WorkTaskImp("执行第"+i+"个删除用户操作...");
			TaskManager.addTask(task);
		}
		//关闭线程池
		try {
			Thread.sleep(2000);//为了显示处理请求效果
			pool.close();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import event.BeginTaskEvent;
import event.EndTaskEvent;

import task.TaskManager;
/**
 * 线程池类，功能如下：
 * 1、初始化线程池
 * 2、获取空闲线程
 * 3、任务运行，注册超时监测
 * 4、任务结束，注销超时监测
 * 5、关闭线程池
 */
public class ThreadPool {
	private int threadcount;
	private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置
	private static ThreadPool pool=new ThreadPool();//线程实例	
	private Vector<WorkThread> threadlist=new Vector<WorkThread>();//工作线程列表
	private TaskMonitorThread mainThread;//任务监测线程
	private TaskTimeOutThread timeThread; //任务超时线程
	private boolean StopGetIdleThread=false;
    //单例模式
	private ThreadPool(){
	}	
	public static synchronized ThreadPool getInstance(){
		return pool;
	}
	private void stopGetIdleThread(){
		StopGetIdleThread = true;
	}
	//初始化线程池
	public  void init(int count){
		System.out.println("开始初始化线程池...");
		threadcount=count;
		for(int i=0;i<count;i++){
			WorkThread t=new WorkThread(new Integer(i));
			threadlist.add(t);
			t.start();
		}
		mainThread=new  TaskMonitorThread(pool);
		mainThread.start();
		timeThread=new TaskTimeOutThread(pool);
		timeThread.start();
		System.out.println("结束初始化线程池...");
	}
	//获取空闲线程
	public  WorkThread getIdleThread(){
			while(true){
				if (StopGetIdleThread) return null;
				synchronized(threadlist){
					for(int i=0;i<threadlist.size();i++){
						WorkThread t=(WorkThread)threadlist.get(i);
						if (t.getMyState().equals(WorkThread.IDlESTATE)){
							return t;
						}
					}
				}
				try {
					Thread.sleep(GetIdleThreadPollTime);//放弃CPU,若干时间后重新获取空闲线程
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
	}

	//任务运行，注册监测
	public  void beginTaskRun(BeginTaskEvent begin){
		timeThread.beginTaskRun(begin);
	}
	//任务结束，注销监视
	public  void endTaskRun(EndTaskEvent end){
		timeThread.endTaskRun(end);
	}
	
	//从工作线程表中移除线程
	public  void removeWorkThread(WorkThread t){
		threadlist.remove(t);
	}
	//添加新的线程
	public void addWorkThread(){
		synchronized(threadlist){
			WorkThread t=new WorkThread(new Integer(++threadcount));
			threadlist.add(t);
			t.start();
		}
	}
	
	//关闭线程池
	public  void close(){
		//停止获取空闲线程
		stopGetIdleThread();
		//关闭任务监测线程，不再接收请求
		mainThread.kill();
		//关闭超时监测线程
		timeThread.kill();
		//关闭工作线程，不再处理任务
		for(int i=0;i<threadlist.size();i++){
			WorkThread t=(WorkThread)threadlist.get(i);
			t.kill();
		}
	}
	
	
}

package thread;

import task.WorkTask;
import event.BeginTaskEvent;
import event.EndTaskEvent;
/**
 * 工作线程类,功能如下：
 * 1、执行业务方法，业务参数可动态设置
 * 2、自身状态可设置、可获取
 * 3、自我唤醒功能
 * 4、自杀功能
 */
public final class WorkThread extends Thread{
	private boolean shutdown=false;
	private String info; //业务参数
	private Object threadKey;//线程标识
	private Object lock=new Object();//锁对象
	private String state; //线程状态
	private int waitExecFinishPollTime=500;//关闭线程时的轮询等待时间，可配置
	public static final String CREATESTATE="1";//创建状态
	public static final String RUNSTATE="2";   //运行状态
	public static final String IDlESTATE="3";  //空闲状态
    private WorkTask nowTask; //当前任务

	//获取线程标识key
	public Object getThreadKey() {
		return threadKey;
	}      
    //设置线程的任务
    public void setWorkTask(WorkTask task){
    	this.nowTask=task;
    }
	//设置是否关闭线程
	private void setShutdown(boolean shutdown) {
		this.shutdown = shutdown;
	}
	//设置线程状态
	private void setMyState(String state){
		this.state=state;
	}
	//获取线程状态
	public String getMyState(){
		return state;
	}
	public WorkThread(Object key){
		System.out.println("正在创建工作线程...线程编号"+key.toString());
		this.threadKey=key;
		this.state=CREATESTATE;
	}
	
	@Override
	public synchronized void start() {
		// TODO Auto-generated method stub
		super.start();
		setMyState(RUNSTATE);
	}
	public void run(){
		while(true){
			try {
				setMyState(IDlESTATE);
				synchronized(this){
					wait(); /*开始等待，直至被激活*/
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if (shutdown) break;
			try{
				new BeginTaskEvent(this,Thread.currentThread(),nowTask).execute();
				nowTask.execute();//执行业务
				new EndTaskEvent(this,Thread.currentThread(),nowTask).execute();
			}catch(Exception e){
				new EndTaskEvent(this,Thread.currentThread(),nowTask).execute();
				System.out.println(e.getMessage());
			}
		}
	}
	//重新激活线程
	public void activate(){
		synchronized(this){
			setMyState(RUNSTATE);
			notify();
		}
	}
	//关闭线程
	public void kill(){
		synchronized(this){
		    if (this.getMyState().equals(IDlESTATE)){//如果线程处于空闲状态,则直接关掉
				System.out.println("正在关闭工作线程...线程编号"+threadKey.toString());
		    	this.setShutdown(true);
		    	this.activate();
		    }else if (this.getMyState().equals(RUNSTATE)){//如果线程处于运行状态,则执行完后再关掉
				System.out.println("正在等待线程执行业务完成...工作线程编号"+threadKey.toString());
		    	while(this.getMyState().equals(RUNSTATE)){
		    		try {
						Thread.sleep(waitExecFinishPollTime);//放弃CPU,若干时间后再检查线程状态
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
		    	}
				System.out.println("正在关闭工作线程...线程编号"+threadKey.toString());
		    	this.setShutdown(true);
		    	this.activate();
		    }
		}
	}
}


package thread;

import task.TaskManager;
import task.WorkTask;
/**
 * 任务检测线程类
 * 1、自杀功能 
 */
public final class TaskMonitorThread extends Thread {
	private ThreadPool threadPool;
	private int GetWorkTaskPollTime=10;//监测任务轮询时间，可配置
	private boolean shutdown=false; 
	public TaskMonitorThread(ThreadPool pool){
		System.out.println("正在创建任务监测线程...");
		this.threadPool=pool;
	}
	private void setShutDown(boolean b){
		this.shutdown=b;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
			while(true){
				if (shutdown) break;
				WorkTask task=TaskManager.getWorkTask();//看是否有任务请求
				if (task==null){
					try {
						Thread.sleep(GetWorkTaskPollTime);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}else{
					WorkThread t=threadPool.getIdleThread();//获取空闲线程
					if (t==null) break;
					t.setWorkTask(task);//设置线程任务
					task.setTaskThreadKey(t.getThreadKey());//为了显示任务当前线程
					t.activate();//激活空闲线程
					try {
						Thread.sleep(GetWorkTaskPollTime); 
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
	}
	//关闭线程
	public  void kill(){
		System.out.println("正在关闭任务监测线程...");
		this.setShutDown(true);
	}
	
}

package thread;

import java.util.Vector;

import event.BeginTaskEvent;
import event.EndTaskEvent;
import event.TaskRunTime;
import event.TaskTimeOutEvent;
/**
 * 任务超时监测线程类
 * 1、任务开始注册
 * 2、任务完成注销
 * 3、自杀功能 
 */
public class TaskTimeOutThread extends Thread {
	private ThreadPool pool;
	private boolean shutdown=false;
	private Vector<TaskRunTime> taskruntimelist=new Vector<TaskRunTime>();//运行任务列表
	private int pollTime=500; //轮询时间
	private int TaskOutTime=2000; //任务过时时间
	public TaskTimeOutThread(ThreadPool pool){
		this.pool=pool;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
			while(!shutdown){
				synchronized(taskruntimelist){
					for(int i=0;i<taskruntimelist.size();i++){
						TaskRunTime t=(TaskRunTime) taskruntimelist.get(i);
						if (t.checkRunTimeOut(TaskOutTime)){
							taskruntimelist.remove(i);
							new TaskTimeOutEvent(t.getEvent()).execute();
							break;
						}
					}
				}
				try {
					sleep(pollTime);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
	}
	
	//任务运行，开始监测
	public  void beginTaskRun(BeginTaskEvent begin){
		taskruntimelist.add(new TaskRunTime(begin));
	}
	//任务正常结束
	public  void endTaskRun(EndTaskEvent end){
		synchronized(taskruntimelist){
			for(int i=0;i<taskruntimelist.size();i++){
				BeginTaskEvent begin=((TaskRunTime) taskruntimelist.get(i)).getEvent();
				if (begin.equals(end)){
					taskruntimelist.remove(i);
					break;
				}
			}
		}
	}

	
	//自杀
	public void kill(){
		System.out.println("正在关闭超时监测线程...");
		while(taskruntimelist.size()>0){
			try {
				Thread.sleep(pollTime);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		shutdown=true;
	}
	
}

package task;

import java.util.ArrayList;
import java.util.List;
/**
 *  任务管理器
 *  1、添加任务
 *  2、监测是否有新任务
 */
public class TaskManager {
	private  static List taskQueue=new ArrayList<WorkTask>(); //任务队列 
	private TaskManager(){
		
	}
	//添加任务                                            
	public synchronized static  void addTask(WorkTask task){
		taskQueue.add(task);
	}
	//判断是否有任务未执行
	public synchronized static WorkTask getWorkTask(){
		if (taskQueue.size()>0){
			return (WorkTask)taskQueue.remove(0);
		}else
			return null;
	}
}

package task;
/**
 * 任务接口 
 * 继承它来定义自己具体的工作任务
 */
public interface WorkTask {
	void execute() throws Exception; //执行工作任务
	void setTaskThreadKey(Object key);//设置任务线程编号
}

package task;
/**
 * 任务类1
 * 正常执行的工作任务 
 */
public class WorkTaskImp implements WorkTask {
	protected String param;
	protected Object threadkey; //为了显示执行线程编号
	protected final int TaskExecTime=500; //任务执行时间
	public void execute() throws Exception {
		// TODO Auto-generated method stub
		System.out.println(param+"工作线程编号"+threadkey.toString());
	    Thread.sleep(TaskExecTime);
	}
	public WorkTaskImp(String param){
		this.param=param;
	}
	public void setTaskThreadKey(Object key){
		this.threadkey=key;
	}
	public String toString(){
		return param+"工作线程编号"+threadkey.toString();
	}
}

package task;
/**
 * 任务类2
 * 执行报异常的工作任务 
 */
public class WorkTaskAImp extends WorkTaskImp{
	public WorkTaskAImp(String param) {
		super(param);
		// TODO Auto-generated constructor stub
	}
	public void execute() throws Exception {
		// TODO Auto-generated method stub
		throw new Exception("运行WorkTaskAImp任务时出错");
	}

}

package task;
/*
 * 任务类3
 * 执行超时的工作任务
 */
public class WorkTaskBImp extends WorkTaskImp{

	public WorkTaskBImp(String param) {
		super(param);
		// TODO Auto-generated constructor stub
	}

	public void execute() throws Exception {
		// TODO Auto-generated method stub
		System.out.println("正在"+param);
	    Thread.sleep(50000); //随便定义
	}

}

package event;

import task.WorkTask;
import thread.WorkThread;
/*
 *任务抽象事件 
 */
public abstract class AbstractEvent {
	protected WorkThread workthread;
	protected Thread nowthread;
	protected WorkTask nowtask;
	//事件触发
	public synchronized void execute(){};
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		AbstractEvent other=(AbstractEvent)obj;
		return this.workthread==other.workthread&&this.nowtask==this.nowtask;
	};
	
}

package event;

import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
 * 任务开始运行事件
 */
public class BeginTaskEvent extends AbstractEvent{
	public BeginTaskEvent(WorkThread workthread,Thread nowthread,WorkTask task){
		this.workthread=workthread;
		this.nowthread=nowthread;
		this.nowtask=task;
	}
	@Override
	public  void execute() {
		// TODO Auto-generated method stub
		ThreadPool pool=ThreadPool.getInstance();
		pool.beginTaskRun(this);
	}
}

package event;

import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
 * 任务运行结束事件
 */
public class EndTaskEvent extends AbstractEvent {
	public EndTaskEvent(WorkThread workthread,Thread nowthread,WorkTask task){
		this.workthread=workthread;
		this.nowthread=nowthread;
		this.nowtask=task;
	}

	@Override
	public  void execute() {
		// TODO Auto-generated method stub
		ThreadPool pool=ThreadPool.getInstance();
		pool.endTaskRun(this);
	}
	
}

package event;
/*
 * 任务运行时间类
 */
public class TaskRunTime {
		private long begintime;
		private long endtime;
		private BeginTaskEvent event;
		public TaskRunTime(BeginTaskEvent event){
			this.event=event;
			this.begintime=System.currentTimeMillis();
			this.endtime=this.begintime;
		}
		public BeginTaskEvent getEvent() {
			return event;
		}
		//检查是否超时
		public boolean checkRunTimeOut(long maxtime){
			endtime=System.currentTimeMillis();
			long cha=endtime-begintime;
			return cha>=maxtime;
		}
		
	}

package event;

import task.WorkTask;
import thread.ThreadPool;
import thread.WorkThread;
/*
 * 任务超时事件
 */
public class TaskTimeOutEvent  {
	private AbstractEvent event;
	public TaskTimeOutEvent(AbstractEvent event){
		this.event=event;
	}


	@SuppressWarnings("deprecation")
	public  void execute() {
		// TODO Auto-generated method stub
		ThreadPool pool=ThreadPool.getInstance();
		pool.addWorkThread();
		pool.removeWorkThread(event.workthread);
		Object obj=event.workthread.getThreadKey();
		System.out.println("正在停止工作超时线程...线程编号"+obj);
		event.nowthread.stop();
		
	}

}

运行结果
开始初始化线程池...
正在创建工作线程...线程编号0
正在创建工作线程...线程编号1
正在创建工作线程...线程编号2
正在创建工作线程...线程编号3
正在创建工作线程...线程编号4
正在创建工作线程...线程编号5
正在创建工作线程...线程编号6
正在创建工作线程...线程编号7
正在创建工作线程...线程编号8
正在创建工作线程...线程编号9
正在创建任务监测线程...
结束初始化线程池...
正在执行超时任务1...
执行第0个增加用户操作...工作线程编号1
执行第1个增加用户操作...工作线程编号2
执行第2个增加用户操作...工作线程编号3
执行第3个增加用户操作...工作线程编号4
执行第4个增加用户操作...工作线程编号5
执行第5个增加用户操作...工作线程编号6
执行第6个增加用户操作...工作线程编号7
执行第7个增加用户操作...工作线程编号8
执行第8个增加用户操作...工作线程编号9
执行第9个增加用户操作...工作线程编号1
执行第10个增加用户操作...工作线程编号2
执行第11个增加用户操作...工作线程编号3
执行第12个增加用户操作...工作线程编号4
执行第13个增加用户操作...工作线程编号5
执行第14个增加用户操作...工作线程编号6
执行第15个增加用户操作...工作线程编号7
执行第16个增加用户操作...工作线程编号8
执行第17个增加用户操作...工作线程编号9
执行第18个增加用户操作...工作线程编号1
执行第19个增加用户操作...工作线程编号2
正在执行超时任务2...
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
运行WorkTaskAImp任务时出错
执行第0个删除用户操作...工作线程编号4
执行第1个删除用户操作...工作线程编号5
执行第2个删除用户操作...工作线程编号6
执行第3个删除用户操作...工作线程编号7
执行第4个删除用户操作...工作线程编号8
执行第5个删除用户操作...工作线程编号9
执行第6个删除用户操作...工作线程编号1
执行第7个删除用户操作...工作线程编号2
执行第8个删除用户操作...工作线程编号4
执行第9个删除用户操作...工作线程编号5
执行第10个删除用户操作...工作线程编号6
执行第11个删除用户操作...工作线程编号7
执行第12个删除用户操作...工作线程编号8
执行第13个删除用户操作...工作线程编号9
正在关闭任务监测线程...
正在关闭超时监测线程...
正在创建工作线程...线程编号11
正在停止工作超时线程...线程编号0
正在创建工作线程...线程编号12
正在停止工作超时线程...线程编号3
正在关闭工作线程...线程编号1
正在关闭工作线程...线程编号2
正在关闭工作线程...线程编号4
正在关闭工作线程...线程编号5
正在关闭工作线程...线程编号6
正在关闭工作线程...线程编号7
正在关闭工作线程...线程编号8
正在关闭工作线程...线程编号9
正在关闭工作线程...线程编号11
正在关闭工作线程...线程编号12

分享到：
| 线程池示例代码，请大家多指教
评论
12 楼 cuishen 2010-01-04  
libo_591 写道
用stop方法停掉线程，不会产生什么问题么？
急盼回复，因为在一个线程外部，控制杀掉这个运行中的线程，貌似除了stop，其他的都不太行。
(别说布尔值的。。情景不一样。。)

stop方法是sun所不推荐使用的，楼主为何不用interrupt？
11 楼 winc218 2009-12-21  
我是来顶楼主的，我的项目中正好需要这样的一个线程池
10 楼 libo_591 2009-12-07  
用stop方法停掉线程，不会产生什么问题么？
急盼回复，因为在一个线程外部，控制杀掉这个运行中的线程，貌似除了stop，其他的都不太行。
(别说布尔值的。。情景不一样。。)
9 楼 fjlyxx 2009-10-20  
允许的话 可以把你的代码发给我学习下...fjlyxx@gmail.com
8 楼 sfjsffjjj 2009-10-20  
to fjlyxx兄：
引用
sfjsffjjj 写道
现在线程池的工作线程数目固定，下一步要做到监控线程池状态，记录吞吐量等参数，
然后依据这些参数来优化工作线程数目，就像weblogic可以自动调节线程个数，使线程池
工作效率最高


写个监控线程 就解决这个问题了. 清洗多余的线程. 线程池线程最好保存在数组中 效率会高.

线程池初始化时我们会指定默认的工作线程数目，在下面三个阶段中怎样使线程池吞吐量最高：
1、在请求高峰期阶段，可能会增加一些工作线程来处理请求，但增加多少工作线程数才能使线程池
   的平均吞吐量最高
2、在请求低谷期阶段，可能会减少一些空闲工作线程，而且不同时间点的空闲线程数目是不一样的
   那应该减少多少工作线程怎样才能使线程池的平均吞吐量最高
3、在请求平均阶段，线程池内的最优线程数为多少才能使线程池的平均吞吐量最高。
注：阶段指相当一段时间。

7 楼 sfjsffjjj 2009-10-19  
to fjlyxx:
引用
个人认为任务的超时不应该由线程池去管理 应该由具体业务自己去管理. 这是一个两难的问题 为了保障线程池需要管理超时 但是线程池管理的超时不一定满足业务的需求.

任务的超时肯定应该由线程池来管理，但超时检测的间隔时间是由业务特点来决定的，要保证对工作线程的影响最小，并且业务的超时时间也是由业务本身来决定。
引用
而且用另外N条线程去判断超时 还不如只用一条线程去判断超时  如果一定要线程池管理超时 建议你写在监控线程里面 用一条线程定时轮询判断.

//初始化线程池 
     public  void init(int count){ 
         System.out.println("开始初始化线程池..."); 
         threadcount=count; 
         for(int i=0;i<count;i++){ 
             WorkThread t=new WorkThread(new Integer(i)); 
             threadlist.add(t); 
             t.start(); 
         } 
         mainThread=new  TaskMonitorThread(pool); 
         mainThread.start(); 
              
         timeThread=new TaskTimeOutThread(pool); 
         timeThread.start();
        
         System.out.println("结束初始化线程池..."); 
     } 
见上面加黑代码，线程池任务超时检测线程只有一个呀。
6 楼 fjlyxx 2009-10-19  
使用任务超时的线程 在一定程度上损耗了线程池的效率   个人认为任务的超时不应该由线程池去管理 应该由具体业务自己去管理. 这是一个两难的问题 为了保障线程池需要管理超时 但是线程池管理的超时不一定满足业务的需求. 而且用另外N条线程去判断超时 还不如只用一条线程去判断超时  如果一定要线程池管理超时 建议你写在监控线程里面 用一条线程定时轮询判断.
5 楼 fjlyxx 2009-10-19  
sfjsffjjj 写道
现在线程池的工作线程数目固定，下一步要做到监控线程池状态，记录吞吐量等参数，
然后依据这些参数来优化工作线程数目，就像weblogic可以自动调节线程个数，使线程池
工作效率最高


写个监控线程 就解决这个问题了. 清洗多余的线程. 线程池线程最好保存在数组中 效率会高.
4 楼 sfjsffjjj 2009-10-19  
现在线程池的工作线程数目固定，下一步要做到监控线程池状态，记录吞吐量等参数，
然后依据这些参数来优化工作线程数目，就像weblogic可以自动调节线程个数，使线程池
工作效率最高
3 楼 vtrtbb 2009-10-17  
不错，学习了
2 楼 sfjsffjjj 2009-10-16  
各个时间参数需要根据任务特点自己调试
1 楼 whaosoft 2009-10-15  
效率咋的样 测试过木有
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    线程池示例代码

    它可能指向了关于线程池的讨论、文章或者更多的示例代码。 理解并有效地使用线程池是优化并发性能的关键。合理设置线程池参数、选择合适的工作队列类型以及正确地管理和调度任务，都能帮助系统更好地应对高并发场景...

    java 线程池示例（自己实现的参考别人的代码）

    NULL 博文链接：https://yulincqupt.iteye.com/blog/1673919

    Java线程池示例代码.zip

    线程池的作用: 线程池作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他...

    线程池使用示例（含源代码）

    在提供的"线程池示例"文件中，应该包含了创建和使用线程池的代码示例，你可以参考并进行扩展，例如添加更多任务、调整线程池参数，或者实现自定义的线程工厂和拒绝策略，以加深对线程池的理解。

    C++ 线程池示例，VS2015编译通过

    一个简单的线程池示例，可以自定义线程数量和执行任务，代码简洁可扩展性强。在使用上也很方便。下面是一个简单的调用 int main() { xcyk::ThreadPool threadPool("xcyk"); SYSTEM_INFO SystemInfo; ...

    关于线程池的代码demo

    下面将详细解释线程池的工作原理以及如何通过代码实现一个简单的线程池示例。 线程池的基本工作流程如下： 1. **初始化**: 创建线程池，设置线程数量、任务队列大小等参数。 2. **提交任务**: 当有新的任务需要...

    线程池实例（Linux）

    2. **线程池的概念**：线程池是一组预先创建并保持就绪状态的线程集合。当有新的任务到来时，线程池会从池中选择一个空闲线程执行任务，而不是每次都创建新线程。线程池能有效控制运行的线程数量，防止过多线程导致...

    线程池示例

    2. 调度优化：线程池内部有调度机制，可以自动调整线程数量，以适应系统负载。 3. 避免资源争抢：线程池能有效控制运行的线程数量，防止过多线程导致系统资源耗尽。 4. 提高系统吞吐量：通过复用线程，减少了线程间...

    c++线程池及示例代码

    `quickstart.cpp` 文件很可能是线程池实现的一个快速入门示例，它可能包含了如何创建、使用线程池以及处理任务的代码。`threadpool.hpp` 可能是线程池类的头文件，定义了线程池的相关接口和数据结构，而 `threadpool...

    线程池实现代码(C代码版本)

    3. 示例代码：可能包含一个或多个示例，展示如何在实际应用中使用这个线程池库。 通过阅读和理解这些源码，开发者可以学习到如何在C语言中高效地管理和使用线程，以及如何通过线程池优化并发执行的任务，从而提升...

    c++线程池类代码实现

    该线程池类为初学者提供了一个良好的学习示例，有助于理解线程池的基本原理和在C++中的具体应用。 #### 二、核心结构与功能 `CThreadPoolExecutor` 类作为线程池的核心，主要负责管理线程的数量、任务队列的维护...

    uThreadPool线程池示例（查找0-1亿之间的质数任务）

    总之，`uThreadPool线程池示例`是一个很好的学习资源，它演示了如何利用线程池处理大型计算任务，同时展示了多线程编程中的并发控制和任务调度。对于想要提升并发编程能力的开发者来说，这是一个值得研究的案例。

    线程池示例代码VC源代码

    包含DEMO（ThreadPoolDemo.rar），源代码　thread_pool.rar(只有一个HPP文件）及经过裁减的Boost1.32库；之后以用Boost是因为ThreadPool中用到了　Boost库的线程组件。 关键字：thread,pool,线程池

    uThreadPool.pas 线程池示例 DEMO 修正资源死锁

    取自卢伟的专栏DELPHI 线程池代码(http://blog.csdn.net/babyvspp/archive/2008/01/01/2008234.aspx)，封装的十分完美，用法也非常简单，可以根据使用者设定的初始工作线程数和最大线程数以及线程执行时间自动增加...

    C# 线程池使用示例

    示例代码： ```csharp using System; using System.Threading; class Program { static void Main(string[] args) { // 提交任务到线程池 ThreadPool.QueueUserWorkItem(new WaitCallback(YourMethod)); ...

    使用IO完成端口机制实现的定制线程池的代码

    如果是一个示例项目，可能还会有使用线程池的代码片段，帮助开发者理解如何在实际应用中配置和使用这个线程池。 总之，使用I/O完成端口机制的线程池在处理大量I/O密集型任务时能展现其优势，特别是在网络服务器、...

    linux线程池代码（c++实现）

    在`demo.cpp`中，我们可以看到线程池的使用示例： 1. **创建线程池**：根据需求实例化线程池对象，设置线程池的大小。 2. **提交任务**：使用线程池提供的接口，向线程池提交多个任务。这些任务可以是自定义的函数...

    德国人写的 线程池代码 for DelphiXE

    Examples 文件夹中可能包含了使用线程池的示例代码，这些示例有助于开发者理解和学习如何在自己的项目中应用线程池。通过查看这些例子，我们可以了解如何提交任务到线程池，如何等待所有任务完成，以及如何处理...

    100行Java代码构建一个线程池

    在示例代码中，作者使用简单的Java代码创建了一个线程池，通过`ThreadPoolManager`类来管理线程池，并使用`SimpleThread`类作为处理任务的线程。 【示例代码分析】 1. `TestThreadPool`类是测试类，模拟客户端发送...

Magicbox
Global site tag (gtag.js) - Google Analytics