Java实现通用线程池

转载 2007年09月29日 15:16:00
URL: http://blog.csdn.net/polarman/archive/2006/08/09/1042149.aspx

      线程池通俗的描述就是预先创建若干空闲线程,等到需要用多线程去处理事务的时候去唤醒某些空闲线程执行处理任务,这样就省去了频繁创建线程的时间,因为频 繁创建线程是要耗费大量的CPU资源的。如果一个应用程序需要频繁地处理大量并发事务,不断的创建销毁线程往往会大大地降低系统的效率,这时候线程池就派 上用场了。
      本文旨在使用Java语言编写一个通用的线程池。当需要使用线程池处理事务时,只需按照指定规范封装好事务处理对象,然后用已有的线程池对象去自动选择空 闲线程自动调用事务处理对象即可。并实现线程池的动态修改(修改当前线程数,最大线程数等)。下面是实现代码:

//ThreadTask .java

package polarman.threadpool;

/**
 * 线程任务
 * 
@author ryang
 * 2006-8-8
 
*/

public interface ThreadTask {
    
public void run();
}


//PooledThread.java

package polarman.threadpool;

import java.util.Collection;
import java.util.Vector;

/**
 * 接受线程池管理的线程
 * 
@author ryang
 * 2006-8-8
 
*/

public class PooledThread extends Thread {
   
    
protected Vector tasks = new Vector();
    
protected boolean running = false;
    
protected boolean stopped = false;
    
protected boolean paused = false;
    
protected boolean killed = false;
    
private ThreadPool pool;
   
    
public PooledThread(ThreadPool pool){
        
this.pool = pool;
    }

   
    
public void putTask(ThreadTask task){
        tasks.add(task);
    }

   
    
public void putTasks(ThreadTask[] tasks){
        
for(int i=0; i<tasks.length; i++)
            
this.tasks.add(tasks[i]);
    }

   
    
public void putTasks(Collection tasks){
        
this.tasks.addAll(tasks);
    }

   
    
protected ThreadTask popTask(){
        
if(tasks.size() > 0)
            
return (ThreadTask)tasks.remove(0);
        
else
            
return null;
    }

   
    
public boolean isRunning(){
        
return running;
    }

   
    
public void stopTasks(){
        stopped 
= true;
    }

   
    
public void stopTasksSync(){
        stopTasks();
        
while(isRunning()){
            
try {
                sleep(
5);
            }
 catch (InterruptedException e) {
            }

        }

    }

   
    
public void pauseTasks(){
        paused 
= true;
    }

   
    
public void pauseTasksSync(){
        pauseTasks();
        
while(isRunning()){
            
try {
                sleep(
5);
            }
 catch (InterruptedException e) {
            }

        }

    }

   
    
public void kill(){
        
if(!running)
            interrupt();
        
else
            killed 
= true;
    }

   
    
public void killSync(){
        kill();
        
while(isAlive()){
            
try {
                sleep(
5);
            }
 catch (InterruptedException e) {
            }

        }

    }

   
    
public synchronized void startTasks(){
        running 
= true;
        
this.notify();
    }

   
    
public synchronized void run(){
        
try{
            
while(true){
                
if(!running || tasks.size() == 0){
                    pool.notifyForIdleThread();
                    
//System.out.println(Thread.currentThread().getId() + ": 空闲");
                    this.wait();
                }
else{
                    ThreadTask task;
                    
while((task = popTask()) != null){
                        task.run();
                        
if(stopped){
                            stopped 
= false;
                            
if(tasks.size() > 0){
                                tasks.clear();
                                System.out.println(Thread.currentThread().getId() 
+ ": Tasks are stopped");
                                
break;
                            }

                        }

                        
if(paused){
                            paused 
= false;
                            
if(tasks.size() > 0){
                                System.out.println(Thread.currentThread().getId() 
+ ": Tasks are paused");
                                
break;
                            }

                        }

                    }

                    running 
= false;
                }


                
if(killed){
                    killed 
= false;
                    
break;
                }

            }

        }
catch(InterruptedException e){
            
return;
        }

       
        
//System.out.println(Thread.currentThread().getId() + ": Killed");
    }

}


//ThreadPool.java

package polarman.threadpool;

import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;

/**
 * 线程池
 * 
@author ryang
 * 2006-8-8
 
*/

public class ThreadPool {
   
    
protected int maxPoolSize;
    
protected int initPoolSize;
    
protected Vector threads = new Vector();
    
protected boolean initialized = false;
    
protected boolean hasIdleThread = false;
   
    
public ThreadPool(int maxPoolSize, int initPoolSize){
        
this.maxPoolSize = maxPoolSize;
        
this.initPoolSize = initPoolSize;
    }

   
    
public void init(){
        initialized 
= true;
        
for(int i=0; i<initPoolSize; i++){
            PooledThread thread 
= new PooledThread(this);
            thread.start();
            threads.add(thread);
        }

       
        
//System.out.println("线程池初始化结束,线程数=" + threads.size() + " 最大线程数=" + maxPoolSize);
    }

   
    
public void setMaxPoolSize(int maxPoolSize){
        
//System.out.println("重设最大线程数,最大线程数=" + maxPoolSize);
        this.maxPoolSize = maxPoolSize;
        
if(maxPoolSize < getPoolSize())
            setPoolSize(maxPoolSize);
    }

   
    
/**
     * 重设当前线程数
     * 若需杀掉某线程,线程不会立刻杀掉,而会等到线程中的事务处理完成
     * 但此方法会立刻从线程池中移除该线程,不会等待事务处理结束
     * 
@param size
     
*/

    
public void setPoolSize(int size){
        
if(!initialized){
            initPoolSize 
= size;
            
return;
        }
else if(size > getPoolSize()){
            
for(int i=getPoolSize(); i<size && i<maxPoolSize; i++){
                PooledThread thread 
= new PooledThread(this);
                thread.start();
                threads.add(thread);
            }

        }
else if(size < getPoolSize()){
            
while(getPoolSize() > size){
                PooledThread th 
= (PooledThread)threads.remove(0);
                th.kill();
            }

        }

       
        
//System.out.println("重设线程数,线程数=" + threads.size());
    }

   
    
public int getPoolSize(){
        
return threads.size();
    }

   
    
protected void notifyForIdleThread(){
        hasIdleThread 
= true;
    }

   
    
protected boolean waitForIdleThread(){
        hasIdleThread 
= false;
        
while(!hasIdleThread && getPoolSize() >= maxPoolSize){
            
try {
                Thread.sleep(
5);
            }
 catch (InterruptedException e) {
                
return false;
            }

        }

       
        
return true;
    }

   
    
public synchronized PooledThread getIdleThread(){
        
while(true){
            
for(Iterator itr=threads.iterator(); itr.hasNext();){
                PooledThread th 
= (PooledThread)itr.next();
                
if(!th.isRunning())
                    
return th;
            }

           
            
if(getPoolSize() < maxPoolSize){
                PooledThread thread 
= new PooledThread(this);
                thread.start();
                threads.add(thread);
                
return thread;
            }

           
            
//System.out.println("线程池已满,等待...");
            if(waitForIdleThread() == false)
                
return null;
        }

    }

   
    
public void processTask(ThreadTask task){
        PooledThread th 
= getIdleThread();
        
if(th != null){
            th.putTask(task);
            th.startTasks();
        }

    }

   
    
public void processTasksInSingleThread(ThreadTask[] tasks){
        PooledThread th 
= getIdleThread();
        
if(th != null){
            th.putTasks(tasks);
            th.startTasks();
        }

    }

   
    
public void processTasksInSingleThread(Collection tasks){
        PooledThread th 
= getIdleThread();
        
if(th != null){
            th.putTasks(tasks);
            th.startTasks();
        }

    }

}



下面是线程池的测试程序
//ThreadPoolTest.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import polarman.threadpool.ThreadPool;
import polarman.threadpool.ThreadTask;

public class ThreadPoolTest {

    
public static void main(String[] args) {
        System.out.println(
""quit" 退出");
        System.out.println(
""task A 10" 启动任务A,时长为10秒");
        System.out.println(
""size 2" 设置当前线程池大小为2");
        System.out.println(
""max 3" 设置线程池最大线程数为3");
       
System.out.println();
       
        final ThreadPool pool = new ThreadPool(32);
        pool.init();
        
        Thread cmdThread 
= new Thread(){
            
public void run(){
                
                BufferedReader reader 
= new BufferedReader(new InputStreamReader(System.in));
                
                
while(true){
                    
try {
                        String line 
= reader.readLine();
                        String words[] 
= line.split(" ");
                        
if(words[0].equalsIgnoreCase("quit")){
                            System.exit(
0);
                        }
else if(words[0].equalsIgnoreCase("size"&& words.length >= 2){
                            
try{
                                
int size = Integer.parseInt(words[1]);
                                pool.setPoolSize(size);
                            }
catch(Exception e){
                            }

                        }
else if(words[0].equalsIgnoreCase("max"&& words.length >= 2){
                            
try{
                                
int max = Integer.parseInt(words[1]);
                                pool.setMaxPoolSize(max);
                            }
catch(Exception e){
                            }

                        }
else if(words[0].equalsIgnoreCase("task"&& words.length >= 3){
                            
try{
                                
int timelen = Integer.parseInt(words[2]);
                                SimpleTask task 
= new SimpleTask(words[1], timelen * 1000);
                                pool.processTask(task);
                            }
catch(Exception e){
                            }

                        }

                        
                    }
 catch (IOException e) {
                        e.printStackTrace();
                    }

                }

            }

        }
;
        
        cmdThread.start();
        
/*
        for(int i=0; i<10; i++){
            SimpleTask task = new SimpleTask("Task" + i, (i+10)*1000);
            pool.processTask(task);
        }
*/

    }


}


class SimpleTask implements ThreadTask{
    
    
private String taskName;
    
private int timeLen;
    
    
public SimpleTask(String taskName, int timeLen){
        
this.taskName = taskName;
        
this.timeLen = timeLen;
    }

    
    
public void run() {
        System.out.println(Thread.currentThread().getId() 
+
                
": START TASK "" + taskName + """);
        
try {
            Thread.sleep(timeLen);
        }
 catch (InterruptedException e) {
        }

        
        System.out.println(Thread.currentThread().getId() 
+
                
": END TASK "" + taskName + """);
    }

    
}


使用此线程池相当简单,下面两行代码初始化线程池:

ThreadPool pool = new ThreadPool(32);
pool.init();

要处理的任务实现ThreadTask接口即可(如测试代码里的SimpleTask),这个接口只有一个方法run()
两行代码即可调用:

ThreadTask task = ... //实例化你的任务对象
pool.processTask(task);

相关文章推荐

sdaa

係。 /dev/sda /dev/sdb : /dev/sdz /dev/sdaa /dev/sdab : : /dev/sdiv 最多 256 個 (以 kernel 2.6.3...

线程池;java实现线程池原理;适用于交互频繁的(如电商网站)

线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中。如果某个线程在托...

java线程池---编写自己的线程池

java线程池---编写自己的线程池
  • canot
  • canot
  • 2016-03-16 12:25
  • 5110

Java 线程池技术之一 自实现线程池

尽管自jdk1.5,Java已经自带了线程池实现,了解如何自己实现Java线程池有助于加深对操作系统和Java虚拟机的理解。 一,线程池的基本要素 线程池一般需要一个线程管理类: ...

java并发编程之源码分析ThreadPoolExecutor线程池实现原理

本文从线程池的创建、核心线程数、最大线程数、线程的创建、任务队列、拒绝策略、工作线程keep-alive等方面详细解读了线程池特性。然后介绍了线程池的状态以及线程池的实现原理,详解了addWorker...

Java 多线程编程之九:使用 Executors 和 ThreadPoolExecutor 实现的 Java 线程池的例子

线程池用来管理工作线程的数量,它持有一个等待被执行的线程的队列。         java.util.concurrent.Executors 提供了 java.util.concurrent.Exe...

java线程池学习(二) —— 实现一个简单的线程池

在上一篇文章中《java线程池学习(一) —— BlockingQueue》,我们简单探讨了一个BlockingQueue的概念。 那么在这边文章,我们要利用BlockingQueue来自己实现一个简...

java多线程的简单实现及线程池实例

一、多线程的两种实现方式 1、继承Thread类的多线程 /** * 继承Thread类的多线程简单实现 */ public class extThread extends Thread ...

java实现通用的线程池

  • 2011-05-14 14:46
  • 183KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)