Java实现通用线程池

最新推荐文章于 2023-07-04 14:56:58 发布
最新推荐文章于 2023-07-04 14:56:58 发布
阅读量6k 收藏 4
点赞数
分类专栏： java 文章标签： java import thread null 任务 vector
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(3, 2);
        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(3, 2);
pool.init();

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

 ThreadTask task = ... //实例化你的任务对象
pool.processTask(task);
coofucoo
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 线程池详解（一）：线程池实现原理及使用
To be a great coder
07-22 2081
阿瑟东撒的
java线程池（简单易懂）
qq_64680177的博客
06-28 5649
它最长的构造方法有七个参数。 核心线程数量——在线程池当中无论空闲多久都不会被删除的线程 线程池当中最大的线程数量——线程池当中最大能创建的线程数量 空闲时间（数值）——临时线程（线程池中出核心线程之外的线程）空闲了多久就会被淘汰的时间。 空闲时间（单位）——临时线程空闲了多久就会被淘汰的时间单位，要用枚举类TimeUnit类作为参数 阻塞队列——就是创建一个阻塞队列作为参数传入，就是当线程池当中线程数量已经达到了最大线程数量，允许多少个任务排队获取线程，其余的用参数七那个方案来处理。
java创建线程池一共有七种方式
xukaiqiang123的博客
07-04 2523
Executors.newCachedThreadPool：创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。Executors.newFixedThreadPool：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。Executors.newSingleThreadExecutor：创建单个线程数的线程池，它可以保证先进先出的执行顺序。Executors.newScheduledThreadPool：创建一个可以执行延迟任务的线程池。
Java多线程实现-线程池
kking_edc的博客
08-28 1364
在《阿里巴巴Java手册》里有这样一条： 【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。 简单来说使用线程池有以下几个目的： 线程是稀缺资源，不能频繁的创建 解耦作用：线程创建时执行完全分开，方便维护 可以将其放入一个池子中，方便给其他任务进行复用 一、线程池原理 谈到线程池就会想到池化技术，其中最
java多线程之线程池
程序三两行
06-30 2110
在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗...
Java 中如何实现自己的一个简单线程池
Java徐师兄的博客
04-30 510
本文介绍了如何自己实现一个简单的线程池。线程池的实现原理是将线程的创建、销毁和管理等操作交给线程池来完成，从而避免了频繁地创建和销毁线程，节约了系统资源，提高了程序的效率。线程池的实现包括一个任务队列和一个线程池管理器，可以通过 execute 方法向线程池中添加任务，并可以通过 shutdown 方法来停止线程池中的所有工作线程。
java实现通用线程池的代码
09-11
本文旨在使用Java语言编写一个通用的线程池。当需要使用线程池处理事务时，只需按照指定规范封装好事务处理对象，然后用已有的线程池对象去自动选择空 闲线程自动调用事务处理对象即可。并实现线程池的动态修改...
java中通用的线程池实例代码
09-05
java中通用的线程池实例代码，需要的朋友可以参考一下
java实现通用的线程池
05-14
java实现通用的线程池，这是我网上找的资料，O(∩_∩)O~希望大家能用的到。
一个通用的Java线程池类
11-07
环境：Windows XP Professional SP3, JDK 1.6 使用步骤： 1.下载解压之后，在控制台运行...这里本人翻写一个通用的线程池类，它可以用来作为工具类处理许多多线程问题。代码注释非常详尽，一行注释一行代码。 阅读对象
Java多线程案例之线程池
未见花闻的博客
04-14 1768
本篇文章将介绍多线程案例，线程池，线程在Linux中也叫做轻量级线程，尽管线程比进程较轻，但是如果线程的创建和销毁频率高了，开销也还是有的，为了进一步提高效率，引入了线程池，和字符串常量池类似，把线程提前创建好，放到一个“池子”里面，后面使用的时候，速度就快了，但是代价就是空间，线程池本质上也还是空间换时间。
JAVA中四种线程池
jj89929665的博客
11-05 269
四种线程池newFixedThreadPoolnewCachedThreadPoolnewSingleThreadExecutornewScheduledThreadPool newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的
Java多场景需求使用各自独立线程池还是共用一个线程池？
qq_34486648的博客
05-12 3869
在Java项目开发过程中，我们经常会使用到线程池，但是当面对多个任务场景，我们是给每个场景单独定义一个线程池，还是所有场景共用一个线程池？想必，很多同学也为此纠结过，那我们应该具体怎么做呢？ 一、建议 这里我们建议，如果你的Java项目中有多个场景需要使用线程池，那么最好为每一个业务场景使用独立的线程池，不要让所有的场景共用一个线程池 二、原因分析 1）独立的线城池之间互相不影响彼此的任务作业，更有利于保证本任务的独立性和完整性，更符合低耦合的设计思想 2）如果所有的场景共用一个线程池，可能会出现如下问题，
Java线程池（超详细）
热门推荐
CodePanda@GPF的博客
03-10 4万+
文章目录1.线程池概念2. JUC线程池架构3. Executors创建线程的4种方法4. 线程池的标准创建方式5. 向线程池提交任务的两种方式6. 线程池的任务调度流程7. ThreadFactory（线程工厂）8. 任务阻塞队列 1.线程池概念 创建Java线程需要给线程分配堆栈内存以及初始化内存，还需要进行系统调用，频繁地创建和销毁线程会大大降低系统的运行效率，采用线程池来管理线程有以下好处： 提升性能：线程池能独立负责线程的创建、维护和分配 线程管理：每个Java线程池会保持一些基本的线程统计信息
java InputStreamReader类
weixin_42277992的博客
09-02 240
InputStreamReader
Java线程池详解
weixin_38650077的博客
04-27 436
ThreadLocal类提供了线程本地变量（thread-local variables），这些变量不同于普通的变量，访问线程本地变量的每个线程（通过其get或set方法）都有其自己的独立初始化的变量副本，因此ThreadLocal没有多线程竞争的问题，不需要单独进行加锁。在java工程实践中，线程池和线程变量被广泛使用，因线程池和线程变量的不当使用经常造成安全生产事故，因此，正确使用线程池和线程变量是每一位开发人员必须修炼的基本功。
Java 中的线程池
飞鱼的博客
08-19 241
本文主要介绍了线程池框架 Executor，ThreadPoolExecutor 的「构造参数」和「工作行为」，线程池的生命周期，Executors 提供的线程池
Java 标准库中线程池的四种创建方式
m0_58154870的博客
04-20 334
1. 使用 Executors 工厂类创建固定大小的线程池。 2. 使用 Executors 工厂类创建大小不受限制的线程池。 3. 使用 ThreadPoolExecutor 构造函数自定义线程池的各项参数。 4. 使用 ScheduledThreadPoolExecutor 创建周期性执行任务的线程池。
springboot 通用线程池 自定义线程池
最新发布
08-11
在Spring Boot中，你可以使用`TaskExecutor`接口来创建一个通用的线程池，同时也可以自定义线程池的配置。 首先，你需要在Spring Boot应用程序的配置类或配置文件中进行以下配置： ```java @Configuration @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值