一个线程池的最小实现

     在消息中间件的实现中,为了提高客户端和服务器端通信的效率以及提高资源的利用率,利用线程池是必不可少的一环.

     下面我们简单介绍下线程池的实现方式,线程池的实现主要由以下部分组成:

     1.任务接口:要让线程去执行的代码段应该用任务接口定义好

     2.任务队列:在任务队列中保存了所有将要执行的任务

     3.工作线程:工作线程继承自Thread类或实现Runnable接口,在此类中持有任务队列的引用,在run方法中具体去执行某个任务,如果此时任务队列为空,则等待新任务去唤醒

     4.线程池管理器:此类中完成线程的初始化,启动,添加任务以及其他一些相关操作.该类持有任务队列的引用以及开启的线程的引用

    下面我们看看实现代码:

    (1)任务接口 

package com.liu.threadpool;

/*
 * 任务接口
 */
public interface Task {

	//执行任务的入口
	public void execute();
}

   (2)任务接口的具体实现类 

package com.liu.threadpool;

/*
 * 任务接口的实现类
 */
public class TaskImpl implements Task {

	public void execute() 
	{
		System.out.println(Thread.currentThread().getName()+"--->");
	}
}

   (3)工作线程

package com.liu.threadpool;

import java.util.List;

/*
 * 工作线程
 */
public class WorkThread extends Thread {

	//任务队列
	private List<Task> list;
	//开关变量,用于结束线程(true:关闭线程 false:不关闭线程)
	private boolean shutdown;
	
	public WorkThread(List<Task> list)
	{
		this.list=list;
		this.shutdown=false;
	}
	
	public void run()
	{
		while(!shutdown)
		{
			synchronized(list)
			{
				//任务队列非空,则执行任务			
				if(!list.isEmpty())
				{
					Task task=list.remove(0);
					task.execute();
				}
				//任务队列为空,线程暂停执行,等待有新的任务到来
				else
				{
					try 
					{
						list.wait();
					}
					catch (InterruptedException e) 
					{
						e.printStackTrace();
					}
				}
			}
		}
	}
	
	public void closeThread()
	{
		this.shutdown=true;
	}
}

   (4)线程池管理器

package com.liu.threadpool;

import java.util.ArrayList;
import java.util.List;

/*
 * 线程池管理器
 */
public class ThreadManager {
	
	//初始化线程池中线程的个数
	private int size=3;
	//任务队列
	private List<Task> tasklist;
	//保存开启线程的引用
	private List<WorkThread> threadlist;
	
	public ThreadManager(int size)
	{
		if(size>0)this.size=size;
		tasklist=new ArrayList<Task>();
		threadlist=new ArrayList<WorkThread>();
		start();
	}
	
	/*
	 * 开启指定数目的线程,并放入线程池中进行管理
	 */
	public void start()
	{
		synchronized(tasklist)
		{
			for(int i=0;i<this.size;i++)
			{
				WorkThread thread=new WorkThread(tasklist);
				threadlist.add(thread);
				thread.start();
			}
		}
	}
	
	/*
	 * 添加工作任务
	 */
	public void addTask(Task task)
	{
		synchronized(tasklist)
		{
			tasklist.add(task);
			tasklist.notifyAll();
		}
	}
	
	/*
	 * 停止第i个线程
	 */
	public void stop(int i)
	{
		synchronized(tasklist)
		{
			threadlist.get(i).closeThread();
			threadlist.remove(i);
		}
	}
}

   (5)测试用例

package com.liu.threadpool;

public class ThreadPoolTest {

	public static void main(String[] args) 
	{
		ThreadManager manager=new ThreadManager(3);
		Task t1=new TaskImpl();
		Task t2=new TaskImpl();
		Task t3=new TaskImpl();
		Task t4=new TaskImpl();
		Task t5=new TaskImpl();
		Task t6=new TaskImpl();
		Task t7=new TaskImpl();
		Task t8=new TaskImpl();
		Task t9=new TaskImpl();
		manager.addTask(t1);
		manager.addTask(t2);
		manager.addTask(t3);
		
		try 
		{
			Thread.currentThread().sleep(3000);
		} 
		catch (InterruptedException e) 
		{
			e.printStackTrace();
		}
		manager.stop(0);
		
		manager.addTask(t4);
		manager.addTask(t5);
		manager.addTask(t6);
		manager.addTask(t7);
		manager.addTask(t8);
		manager.addTask(t9);
		
		manager.stop(0);
		manager.stop(0);
	}
}