`

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

 
阅读更多


一般一个简单线程池至少包含下列组成部分

  • 线程池管理器（ThreadPoolManager）:用于创建并管理线程池
  • 工作线程（WorkThread）: 线程池中线程
  • 任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行。
  • 任务队列:用于存放没有处理的任务。提供一种缓冲机制。

 

package com.yulin.threadpool;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;

/*
 *  线程池管理器（PoolManager）:用于创建并管理线程池，采用单例模式
 *
 */
public class PoolManage {
    public static PoolManage mPool=new PoolManage();
    public final int max_pool =2;
    public final int max_Tasks = 15;
    public static ArrayList<Worker> init_pools;
    private int GetIdleThreadPollTime=50;//获取空闲线程轮询间隔时间,可配置
    private TaskMonitorThread mainThread;//任务监测线程

    static {
        init_pools = new ArrayList(1);
    }

    public static PoolManage getInstance() {
        if (mPool == null) {
            mPool = new PoolManage();
        }

        return mPool;
    }
    
    
    
    //获取空闲线程
    public  Worker getIdleThread(){
        Worker working =null;
        while(true){
            synchronized(init_pools){
                for (int i = 0; i < max_pool; i++) {
                    //Worker working = init_pools.get(i);
                    working = init_pools.get(i);
                    if (!working.isrunning) {
                    //    System.out.println("工作将由闲置线程" + working.getThreadTag() + "执行");
                        return working;
                    }
                }
            }
            try {
                Thread.sleep(5000);//放弃CPU,若干时间后重新获取空闲线程
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        
    }
    public void init() {
        System.out.println("线程池初始化开始。。。");
        Worker worker = null;
        for (int i = 0; i < this.max_pool; i++) {
            worker = new Worker("initThread"+i);
            init_pools.add(worker);
            worker.start();
        }
        mainThread=new  TaskMonitorThread();
        mainThread.start();
        System.out.println("结束初始化线程池...");

    }
    

}

 

 

package com.yulin.threadpool;

import java.util.LinkedList;

/**
 *  任务管理器
 *  1、添加任务
 *  2、监测是否有新任务
 */
public class TaskManager {
    public static LinkedList<WorkTask> workqueue =new LinkedList<WorkTask>();// 缓冲队列
    /**
     * 向工作队列中加入一个任务，由工作线程去执行该任务
     *
     * @param task
     */
    public synchronized static void addTask(WorkTask worktask) {
        if (worktask != null &&workqueue.size()<15) {
            workqueue.add(worktask);
        }
    }
    /*[com.yulin.threadpool.WorkTaskImp@44f4ac30,
     com.yulin.threadpool.WorkTaskImp@44f4ad60,
     com.yulin.threadpool.WorkTaskImp@44f4ae00,
     com.yulin.threadpool.WorkTaskImp@44f4aea0,
     com.yulin.threadpool.WorkTaskImp@44f4af40]*/

    /**
     * 从工作队列中取出一个任务
     *
     * @return
     * @throws InterruptedException
     */
    public synchronized static WorkTask getTask() throws InterruptedException {
        while (workqueue.size() >0) {
            return (WorkTask) workqueue.removeFirst();
        }
        return null;
    }
}

 

package com.yulin.threadpool;

/**
 * 任务检测线程类 检测空闲线程并检测待运行任务
 */
public final class TaskMonitorThread extends Thread {
    //private PoolManage threadPool;
    private int GetWorkTaskPollTime = 10;// 监测任务轮询时间，可配置
    /*public TaskMonitorThread(PoolManage pool) {
        System.out.println("正在创建任务监测线程...");
        this.threadPool = pool;
    }*/
    public TaskMonitorThread() {
        System.out.println("正在创建任务监测线程...");
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
           
            try {
                WorkTask task = TaskManager.getTask();
                if (task == null) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                } else {
                    Worker t = PoolManage.getInstance().getIdleThread();// 获取空闲线程
                     System.out.println("Worker.toString()=============================>?"+t.toString());
                    if (t == null)
                        break;
                     t.setWorkTask(task);// 设置线程任务
                     System.out.println("task.toString()=============================>?"+task.toString());
                     t.setIsRunning(true);//激活空闲线程
                     System.out.println("Worker.toString()=============================>?"+t.getIsrunning());
                    // try {
                    //Thread.sleep(GetWorkTaskPollTime);
                    //
                }

            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }


}

 

package com.yulin.threadpool;
/**
 * 工作线程（WorkThread）: 线程池中线程
 * @author yulin
 *
 */
public class Worker extends Thread {
    public boolean isrunning=false;
    private WorkTask nowTask; // 当前任务
    private Object threadTag;// 线程标识
    //获取线程标识key
    public Object getThreadTag() {
        return threadTag;
    }     
    public synchronized void setWorkTask(WorkTask task) {
        this.nowTask = task;
    }

    public synchronized void setIsRunning(boolean flag) {
        this.isrunning = flag;
        if (flag) {
            this.notify();
        }
    }

    public Worker(Object key) {
        System.out.println("正在创建工作线程...线程编号" + key.toString());
        this.threadTag = key;
        // this.state=CREATESTATE;
    }

    public boolean getIsrunning() {
        return isrunning;
    }

    public synchronized void run() {
        System.out.println("工作线程" +  this.getThreadTag()  + "初始化成功");
        while (true) {
            if (!isrunning) {
                try {
                    System.out.println("工人" + this.getThreadTag() + "任务完成回归线程池");
                    this.wait();
                } catch (InterruptedException e) {
                    System.out.println("线程被阻挡");
                    e.printStackTrace();
                }
            } else {
                //try {
                    nowTask.runTask();
                    setIsRunning(false);
                    System.out.println("工人" +this.getThreadTag()  + "开始工作");
                    //this.sleep(3000);
            //} catch (InterruptedException e) {
                //    e.printStackTrace();
                //}
               
                //this.notify();
                //break;
            }
        }
    }
}

 

 

package com.yulin.threadpool;
/**
 * 任务接口
 * 继承它来定义自己具体的工作任务
 */
public interface WorkTask {
     public void runTask();//执行工作任务
        //public int compareTo(mJob job);
     public void cancelTask();
     public int getProgress();
}

 

package com.yulin.threadpool;

import android.util.Log;

/**
 * 任务类1
 * 正常执行的工作任务
 */
public class WorkTaskAImp implements WorkTask {

    protected String param;
    public WorkTaskAImp(){
    }
    public WorkTaskAImp(String param){
        this.param=param;
    }
    @Override
    public void runTask() {
        // TODO Auto-generated method stub
       // Log.v("=============>Task1", this.param);
        System.out.println("=============>Task1"+this.param);
    }

    @Override
    public void cancelTask() {
        // TODO Auto-generated method stub
      
    }

    @Override
    public int getProgress() {
        // TODO Auto-generated method stub
        return 0;
    }
   
}

 

package com.yulin.threadpool;

import android.util.Log;

/**
 * 任务类1
 * 正常执行的工作任务
 */
public class WorkTaskImp implements WorkTask {

    protected String param;
    public WorkTaskImp(){
    }
    public WorkTaskImp(String param){
        this.param=param;
    }
    @Override
    public void runTask() {
        // TODO Auto-generated method stub
        System.out.println("=============>Task0"+this.param);
    }

    @Override
    public void cancelTask() {
        // TODO Auto-generated method stub
      
    }

    @Override
    public int getProgress() {
        // TODO Auto-generated method stub
        return 0;
    }
   
}

 

最后是测试 类

 

package com.example.test;
 
import com.example.task.TaskManager;
import com.example.task.WorkTask;
import com.example.task.WorkTaskAImp;
import com.example.task.WorkTaskBImp;
import com.example.task.WorkTaskImp;
import com.example.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  WorkTaskAImp("执行超时任务1...");
        TaskManager.addTask(task1);
        final int requestCount=15;
        for(int i=0;i<requestCount;i++){
            WorkTask task=new WorkTaskImp("执行第"+i+"个增加用户操作.....");
            TaskManager.addTask(task);
        }
        /**/
    }
}

分享到：
| 源码下载
评论
3 楼 memoryisking 2014-11-18  
可以看看这篇文章，构建一个简单的线程池，这个是struts教程网上的一个简单例子：http://www.strutshome.com/index.php/archives/710
2 楼 zwq194 2014-07-25  
坑爹啊，误导人，代码有问题
1 楼 zhouming4455 2014-06-13  
貌似你传错了哦
发表评论

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

相关推荐

    线程池示例代码

    在Java中，`java.util.concurrent`包提供了`ExecutorService`接口和它的实现类，如`ThreadPoolExecutor`，用于创建线程池。`ThreadPoolExecutor`构造函数接收几个关键参数：核心线程数、最大线程数、存活时间、时间...

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

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

    50879510A6_Java线程池_funbde_

    `funbde`可能是指作者的名字或者是某个特定功能的代号，由于描述中提到“不是整一个项目，仅供参考”，我们可以理解为这是一个关于Java线程池的示例代码或片段，用于演示线程池的基本用法或者特定的线程池配置和优化...

    java 线程池常用方法

    Java线程池是Java并发编程中的重要组成部分，它在Java 5及后续版本中引入，大大简化了线程管理和资源调度。线程池通过`Executor`接口和`ExecutorService`接口提供了一套强大的机制，允许开发者高效地创建、管理和...

    java后台示例代码

    Java后台示例代码是针对基于JAVA企业级平台开发的内容管理系统的实例展示，旨在提供开发者一个实践和学习的参考。在企业级应用开发中，Java语言因其高效性、安全性以及稳定性等特性，被广泛用于构建复杂且高负载的...

    Java BIO Socke示例

    在提供的"example"压缩包中，可能包含了实现上述示例的源代码，供学习者参考和实践。通过这些示例，你可以更深入地理解Java BIO Socket通信以及如何使用线程池来优化并发性能。不过，实际生产环境中，通常会使用NIO...

    Java for Programmers Second Edition示例代码

    《Java for Programmers Second Edition》是一本面向有编程基础的读者深入学习Java的书籍，其示例代码提供了丰富的实践操作示例，旨在帮助读者更好地理解和掌握Java编程语言的核心概念和技术。这本书涵盖了Java语言...

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

    这篇博客“100行Java代码构建一个线程池”提供了一个简洁的示例，展示了如何在Java中自定义一个简单的线程池。下面我们将深入探讨线程池的工作原理及其核心组件，以及这篇博客中可能涉及的关键知识点。 线程池的...

    java源代码项目实战示例

    "Java源代码项目实战示例"提供了丰富的实例，帮助我们深入理解Java语言的核心概念和最佳实践。这个压缩包可能包含了各种类型的Java项目，从基础的数据结构和算法实现到复杂的网络编程、多线程应用，甚至可能是数据库...

    java通过Callable和Future来接收线程池的执行结果

    Java中的线程池执行结果获取一直是一个棘手的问题，对于直接继承Thread的方式或实现Runnable接口的方式，都无法获取到线程执行的返回结果。如果线程在执行过程中出现了错误，那么主线程也不会感知到。即使打印了日志...

    详解Java中的线程池

    主要介绍了Java中的线程池，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

    java多线程示例

    在Java编程语言中，多线程是核心特性之一，它允许程序同时执行多个任务，从而提高了应用程序的效率和响应...文档“java多线程实例.docx”可能包含具体的示例代码和详细解释，建议参考学习，以加深对Java多线程的理解。

    Java_从博客文章等代码示例的集合.zip

    这个名为"Java_从博客文章等代码示例的集合.zip"的压缩包文件显然包含了一组从博客文章和其他来源收集的Java代码示例。这些示例可能是为了帮助开发者更好地理解和学习Java的各种概念和技术。 在"code-examples_...

    Java+创建线程的例子源代码学习

    本篇文章将深入探讨Java中创建线程的几种方法，以及如何通过示例源代码进行学习。 首先，Java提供了两种主要的方式来创建线程： 1. **继承Thread类**：创建一个新的类，该类继承自`Thread`类，并重写`run()`方法。...

    java2核心技术卷2 源代码

    《Java2核心技术卷2》是Java开发者深入学习的权威...同时，源代码是很好的学习资源，可以用来参考、调试和修改，以便在自己的项目中实现类似的功能。在实践中不断学习和改进，是成为一名优秀的Java开发者的必经之路。

    java 从入门到精通 源代码

    总的来说，"java 从入门到精通 源代码"是一份非常实用的学习资源，它覆盖了Java编程的全面内容，从基础到高级，从理论到实践，对于任何希望在Java领域深造的人来说，都是不可多得的参考资料。通过系统学习并实践这些...

    Java手动配置线程池过程详解

    主要介绍了Java手动配置线程池过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

    Java2核心技术卷II源代码

    5. **多线程编程**：Java2支持并发编程，源代码会展示如何创建和管理线程，理解同步和互斥，以及使用守护线程和线程池等高级技术。 6. **输入/输出（I/O）系统**：Java的I/O流模型是其强大之处，源代码将涵盖文件...

    Java通用范例开发金典源代码

    《Java通用范例开发金典源代码》是一个包含大量Java编程示例的资源集合，旨在帮助开发者深入理解和掌握Java编程语言的各种特性和应用场景。这个压缩包文件中的源代码覆盖了Java语言的基础到高级各个方面，是Java学习...

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