Java之线程池简单实现

以前做的东西，实现一个简单的多线程机制，开始之前，现说说原理性的东西吧，下面是我在ibm开发者上搜到的内容

创新互联是专业的安徽网站建设公司，安徽接单;提供网站制作、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行安徽网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

线程池的技术背景

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象， 以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用 已有对象来服务就是一个需要解决的关键问题，其实这就是一些"池化资源"技术产生的原因。

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。但如果对多线程应用不当，会增加对单个任务的处理时间。可以举一个简单的例子：

假设在一台服务器完成一项任务的时间为T

◆  T1 创建线程的时间

◆ T2 在线程中执行任务的时间，包括线程间同步所需时间

◆ T3 线程销毁的时间

显然T ＝ T1＋T2＋T3。注意这是一个极度简化的假设。

可以看出T1,T3是多线程本身的带来的开销，我们渴望减少T1,T3所用的时间，从而减少T的时间。但一些线程的使用者并没有注意到 这一点，所以在程序中频繁的创建或销毁线程，这导致T1和T3在T中占有相当比例。显然这是突出了线程的弱点（T1，T3），而不是优点（并发性）。

线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。

线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。在看一个例子：

假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。我们比较利用线程池技术和不利于线程池技术的服务器 处理这些请求时所产生的线程总数。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目或者上限（以下简称线程池尺寸），而如果 服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池尺寸是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处 理请求时浪费时间，从而提高效率。

这些都是假设，不能充分说明问题，下面我将讨论线程池的简单实现并对该程序进行对比测试，以说明线程技术优点及应用领域。

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

◆ 线程池管理器（ThreadPoolManager）：用于创建并管理线程池

◆ 工作线程（WorkThread）： 线程池中线程

◆ 任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行。

◆ 任务队列：用于存放没有处理的任务。提供一种缓冲机制。

线程池管理器至少有下列功能：创建线程池，销毁线程池，添加新任务。下面就是小弟的实现，还是欢迎拍砖哈：

 
 
 
    
  
  
  
  1. public class ThreadPoolManager {  
    2.   
  
  
  2.     private static ThreadPoolManager instance = null;  
    3.   
  
  
  3.     private List taskQueue = Collections.synchronizedList(new LinkedList());//任务队列  
    4.   
  
  
  4.     private WorkThread[] workQueue ;    //工作线程（真正执行任务的线程）  
    5.   
  
  
  5.     private static int worker_num = 5;    //工作线程数量（默认工作线程数量是5）  
    6.   
  
  
  6.     private static int worker_count = 0;  
    7.   
  
  
  7.       
    8.   
  
  
  8.     private ThreadPoolManager(){  
    9.   
  
  
  9.         this(5);  
    10.   
  
  
  10.     }  
    11.   
  
  
  11.     private ThreadPoolManager(int num){  
    12.   
  
  
  12.         worker_num = num;  
    13.   
  
  
  13.         workQueue = new WorkThread[worker_num];  
    14.   
  
  
  14.         for(int i=0;i  
  
  
  15.             workQueue[i] = new WorkThread(i);  
    16.   
  
  
  16.         }  
    17.   
  
  
  17.     }  
    18.   
  
  
  18.       
    19.   
  
  
  19.     public static synchronized ThreadPoolManager getInstance(){  
    20.   
  
  
  20.         if(instance==null)  
    21.   
  
  
  21.             instance = new ThreadPoolManager();  
    22.   
  
  
  22.         return instance;  
    23.   
  
  
  23.     }  
    24.   
  
  
  24.       
    25.   
  
  
  25.     public void addTask(Upload task){  
    26.   
  
  
  26.         //对任务队列的操作要上锁  
    27.   
  
  
  27.         synchronized (taskQueue) {  
    28.   
  
  
  28.             if(task!=null){  
    29.   
  
  
  29.                 taskQueue.add(task);  
    30.   
  
  
  30.                 taskQueue.notifyAll();  
    31.   
  
  
  31.                 System.out.println("task id "+task.getInfo() + " submit!");  
    32.   
  
  
  32.             }  
    33.   
  
  
  33.                   
    34.   
  
  
  34.         }  
    35.   
  
  
  35.     }  
    36.   
  
  
  36.       
    37.   
  
  
  37.     public void BatchAddTask(Upload[] tasks){  
    38.   
  
  
  38.         //对任务队列的修改操作要上锁  
    39.   
  
  
  39.         synchronized (taskQueue) {  
    40.   
  
  
  40.             for(Upload e:tasks){  
    41.   
  
  
  41.                 if(e!=null){  
    42.   
  
  
  42.                     taskQueue.add(e);  
    43.   
  
  
  43.                     taskQueue.notifyAll();  
    44.   
  
  
  44.                     System.out.println("task id "+e.getInfo() + " submit!");  
    45.   
  
  
  45.                 }  
    46.   
  
  
  46.             }          
    47.   
  
  
  47.         }  
    48.   
  
  
  48.     }  
    49.   
  
  
  49.       
    50.   
  
  
  50.     public void destory(){  
    51.   
  
  
  51.         System.out.println("pool begins to destory ...");  
    52.   
  
  
  52.         for(int i = 0;i  
  
  
  53.             workQueue[i].stopThread();  
    54.   
  
  
  54.             workQueue[i] = null;  
    55.   
  
  
  55.         }  
    56.   
  
  
  56.         //对任务队列的操作要上锁  
    57.   
  
  
  57.         synchronized (taskQueue) {  
    58.   
  
  
  58.             taskQueue.clear();  
    59.   
  
  
  59.         }  
    60.   
  
  
  60.           
    61.   
  
  
  61.         System.out.println("pool ends to destory ...");  
    62.   
  
  
  62.     }  
    63.   
  
  
  63.       
    64.   
  
  
  64.     private class WorkThread extends Thread{  
    65.   
  
  
  65.         private int taksId ;  
    66.   
  
  
  66.         private boolean isRuning = true;  
    67.   
  
  
  67.         private boolean isWaiting = false;  
    68.   
  
  
  68.           
    69.   
  
  
  69.           
    70.   
  
  
  70.            
    71.   
  
  
  71.         public WorkThread(int taskId){  
    72.   
  
  
  72.             this.taksId= taskId;  
    73.   
  
  
  73.             this.start();  
    74.   
  
  
  74.         }  
    75.   
  
  
  75.           
    76.   
  
  
  76.         public boolean isWaiting(){  
    77.   
  
  
  77.             return isWaiting;  
    78.   
  
  
  78.         }  
    79.   
  
  
  79.         // 如果任务进行中时，不能立刻终止线程，需要等待任务完成之后检测到isRuning为false的时候，退出run()方法  
    80.   
  
  
  80.         public void stopThread(){  
    81.   
  
  
  81.             isRuning = false;  
    82.   
  
  
  82.         }  
    83.   
  
  
  83.           
    84.   
  
  
  84.         @Override 
    85.   
  
  
  85.         public void run() {  
    86.   
  
  
  86.             while(isRuning){  
    87.   
  
  
  87.                 Upload temp = null;  
    88.   
  
  
  88.                 //对任务队列的操作要上锁  
    89.   
  
  
  89.                 synchronized (taskQueue) {  
    90.   
  
  
  90.                     //任务队列为空，等待新的任务加入  
    91.   
  
  
  91.                     while(isRuning&&taskQueue.isEmpty()){  
    92.   
  
  
  92.                         try {  
    93.   
  
  
  93.                             taskQueue.wait(20);  
    94.   
  
  
  94.                         } catch (InterruptedException e) {  
    95.   
  
  
  95.                             System.out.println("InterruptedException occre...");  
    96.   
  
  
  96.                             e.printStackTrace();  
    97.   
  
  
  97.                         }  
    98.   
  
  
  98.                     }  
    99.   
  
  
  99.                     if(isRuning)  
    100.   
  
  
  100.                         temp = taskQueue.remove(0);  
    101.   
  
  
  101.                 }  
    102.   
  
  
  102.                 //当等待新任务加入时候，终止线程(调用stopThread函数)造成 temp ＝ null  
    103.   
  
  
  103.                 if(temp!=null){  
    104.   
  
  
  104.                     System.out.println("task info: "+temp.getInfo()+ " is begining");  
    105.   
  
  
  105.                     isWaiting = false;  
    106.   
  
  
  106.                     temp.uploadPic();  
    107.   
  
  
  107.                     isWaiting = true;  
    108.   
  
  
  108.                     System.out.println("task info: "+temp.getInfo()+ " is finished");  
    109.   
  
  
  109.                 }      
    110.   
  
  
  110.             }  
    111.   
  
  
  111.         }  
    112.   
  
  
  112.     }  
    113.   
  
  
  113. } 
    114.

然后定义任务接口（Task）：这里我定义的是上传图片的功能接口(这里用抽象类或者接口随你自己)。

 
 
 
    
  
  
  
  1. public abstract class Upload {  
    2.   
  
  
  2.     protected String info;  
    3.   
  
  
  3.     abstract boolean uploadPic();  
    4.   
  
  
  4.     public String getInfo(){  
    5.   
  
  
  5.         return info;  
    6.   
  
  
  6.     }  
    7.   
  
  
  7. } 
    8.

然后定义具体任务类：我这里简单，让它睡眠2s。当然你也可以定义很多实现Upload的任务类。

 
 
 
    
  
  
  
  1. public class TaskUpload extends Upload {  
    2.   
  
  
  2.       
    3.   
  
  
  3.     public TaskUpload(String info){  
    4.   
  
  
  4.         this.info = info;  
    5.   
  
  
  5.     }  
    6.   
  
  
  6.     public String getInfo(){  
    7.   
  
  
  7.         return info;  
    8.   
  
  
  8.     }  
    9.   
  
  
  9.     @Override 
    10.   
  
  
  10.     public boolean uploadPic()  {  
    11.   
  
  
  11.         // TODO Auto-generated method stub  
    12.   
  
  
  12.         System.out.println(info+"sleep begin ....");  
    13.   
  
  
  13.         try {  
    14.   
  
  
  14.             Thread.sleep(2000);  
    15.   
  
  
  15.         } catch (InterruptedException e) {  
    16.   
  
  
  16.             // TODO Auto-generated catch block  
    17.   
  
  
  17.             e.printStackTrace();  
    18.   
  
  
  18.         }  
    19.   
  
  
  19.         System.out.println(info+"sleep end ....");  
    20.   
  
  
  20.         return false;  
    21.   
  
  
  21.     }  
    22.   
  
  
  22. } 
    23.

***，测试这个简单的线程池：

 
 
 
    
  
  
  
  1. public class ThreadPoolManagerTest {  
    2.   
  
  
  2.  
    3.   
  
  
  3.  
    4.   
  
  
  4.     public static void main(String[] args) {  
    5.   
  
  
  5.         // TODO Auto-generated method stub  
    6.   
  
  
  6.         Upload[] tasks = createBatchTask(7);  
    7.   
  
  
  7.         ThreadPoolManager pool = ThreadPoolManager.getInstance();  
    8.   
  
  
  8.         pool.BatchAddTask(tasks);  
    9.   
  
  
  9.         pool.destory();  
    10.   
  
  
  10.     }  
    11.   
  
  
  11.     private static Upload[] createBatchTask(int n){  
    12.   
  
  
  12.         Upload[] tasks = new TaskUpload[n];  
    13.   
  
  
  13.         for(int i = 0;i  
  
  
  14.             tasks[i] = new TaskUpload("task id is "+ i);  
    15.   
  
  
  15.         }  
    16.   
  
  
  16.         return tasks;  
    17.   
  
  
  17.     }  
    18.   
  
  
  18. } 
    19.

线程池技术适用范围及应注意的问题

线程池的应用范围：

1、需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2、对性能要求苛刻的应用，比如要求服务器迅速相应客户请求。

3、接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目***值不是问题，短时间内产生大量线程可能使内存到达极限，并出现"OutOfMemory"的错误。

原文链接：http://www.cnblogs.com/slider/archive/2012/01/16/2323895.html

网页名称：Java之线程池简单实现
转载源于：http://www.shufengxianlan.com/qtweb/news40/291890.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制开发知识

分类信息网

混凝土搅拌车　　 　重庆机房托管　　 　成都宣传海报　　 　瑞捷酒店用品　　 　成都h5网站建设　　 　SSL证书　　 　成都网络营销　　 　攀枝花网站建设　　 　专业网站建设　　 　成都网站建设　　 　成都网页设计　　 　网络推广外包　　 　seo优化排名　　 　成都网站建设　　 　子晨木包装箱　　 　全网营销网站推广　　 　贵安服务器托管　　 　租用服务器　　 　成都定制网站建设　　 　公路打桩机