Java多线程设计模式之线程池模式

》 线程池模式与并发型模式？？

Worker Thread，该模式主要在于，事先启动一定数目的工作线程。当没有请求工作的时候，所有的工人线程都会等待新的请求过来，一旦有工作到达，就马上从线程池中唤醒某个线程来执行任务，执行完毕后继续在线程池中等待任务池的工作请求的到达。

工作线程：

利用同步块来处理，利用Vector来存储客户端请求。在Channel有缓存请求方法和处理请求方法，利用生成者与消费者模式来处理存储请求，利用正向等待来判断任务池的非空状态。

这种实例，可以借鉴到网络ServerSocket处理用户请求的模式中，有很好的扩展性与实用性。

利用Vector来存储，依旧是每次集合的最后一个位置添加请求，从开始位置移除请求来处理。

Channel参与者：

package whut.threadpool2; 
import java.util.Vector; 
/* 
 * 这个主要的作用如下 
 * 0,缓冲客户请求线程(利用生产者与消费者模式) 
 * 1,存储客户端请求的线程 
 * 2,初始化启动一定数量的线程 
 * 3,主动来唤醒处于任务池中wait set的一些线程来执行任务 
 */ 
public class Channel { 
    public final static int THREAD_COUNT=4; 
    public static void main(String[] args) { 
      //定义两个集合，一个是存放客户端请求的，利用Vector， 
      //一个是存储线程的，就是线程池中的线程数目 
                              
      //Vector是线程安全的，它实现了Collection和List 
      //Vector 类可以实现可增长的对象数组。与数组一样， 
      //它包含可以使用整数索引进行访问的组件。但Vector 的大小可以根据需要增大或缩小， 
      //以适应创建 Vector 后进行添加或移除项的操作。 
      //Collection中主要包括了list相关的集合以及set相关的集合,Queue相关的集合 
      //注意：Map不是Collection的子类，都是java.util.*下的同级包 
      Vector pool=new Vector(); 
      //工作线程，初始分配一定限额的数目 
      WorkerThread[] workers=new WorkerThread[THREAD_COUNT]; 
                           
      //初始化启动工作线程 
      for(int i=0;i<workers.length;i++) 
      { 
          workers[i]=new WorkerThread(pool); 
          workers[i].start(); 
      } 
                            
      //接受新的任务，并且将其存储在Vector中 
      Object task=new Object();//模拟的任务实体类 
      //此处省略具体工作 
      //在网络编程中，这里就是利用ServerSocket来利用ServerSocket.accept接受一个Socket从而唤醒线程 
                            
      //当有具体的请求达到 
      synchronized(pool) 
      { 
          pool.add(pool.size(), task); 
          pool.notifyAll();//通知所有在pool wait set中等待的线程，唤醒一个线程进行处理 
      } 
      //注意上面这步骤添加任务池请求，以及通知线程，都可以放在工作线程内部实现 
      //只需要定义该方法为static，在方法体用同步块，且共享的线程池也是static即可 
                            
      //下面这步，可以有可以没有根据实际情况 
      //取消等待的线程 
      for(int i=0;i<workers.length;i++) 
      { 
          workers[i].interrupt(); 
      } 
    } 
} 

工作线程：

package whut.threadpool2; 
import java.util.List; 
public class WorkerThread extends Thread { 
    private List pool;//任务请求池 
    private static int fileCompressed=0;//所有实例共享的 
                      
    public WorkerThread(List pool) 
    { 
          this.pool=pool;  
    } 
                      
    //利用静态synchronized来作为整个synchronized类方法，仅能同时一个操作该类的这个方法 
    private static synchronized void incrementFilesCompressed() 
    { 
        fileCompressed++; 
    } 
                      
    public void run() 
    { 
        //保证无限循环等待中 
        while(true) 
        { 
            //共享互斥来访问pool变量 
            synchronized(pool) 
            { 
                //利用多线程设计模式中的 
                //Guarded Suspension Pattern,警戒条件为pool不为空，否则无限的等待中 
                while(pool.isEmpty()) 
                { 
                    try{ 
                        pool.wait();//进入pool的wait set中等待着,释放了pool的锁 
                    }catch(InterruptedException e) 
                    { 
                    } 
                } 
                //当线程被唤醒，需要重新获取pool的锁， 
                //再次继续执行synchronized代码块中其余的工作 
                //当不为空的时候，继续再判断是否为空，如果不为空，则跳出循环 
                //必须先从任务池中移除一个任务来执行，统一用从末尾添加，从开始处移除 
                                  
                pool.remove(0);//获取任务池中的任务，并且要进行转换 
            } 
            //下面是线程所要处理的具体工作 
        } 
    } 
}