自定义java 线程池

小虾米阅读：623 2021-03-31 23:14:19 评论：0

为什么要建立线程池？

在多线程项目中，如果建立的线程过多，反而可能导致运行速度大大减慢，这是由于线程建立所花费的时间和资源都比较多。
所以我们在多线程中必须很好地来管理线程，在很好利用多线程能“同步工作”的好处之外，更有效地提高程序运行速度。

线程池是什么？

线程池是指具有固定数量的线程组成的一种组件。这些线程用来循环执行多个应用逻辑。

怎么建立线程池？

线程池主要包括4个部分，它们是：
1. 线程管理

主要是用来建立，启动，销毁工作线程和把工作任务加入工作线程。

2. 工作线程

它是真正的线程类，运行工作任务。

3. 工作队列

它是用来封装线程的容器。

4. 工作任务

它是实现应用逻辑的具体类。

流程图：

线程管理类：

Java代码

<span style="color: rgb(51, 102, 255);">import java.util.ArrayList; 
import java.util.List; 
import java.util.Queue; 
import java.util.concurrent.ConcurrentLinkedQueue; 
 
/** 
 * ThreadPoolManager.java 
 * 
 */ 
 
/** 
 * the thread pool manager, is responsible for starting and stopping the work thread. 
 *  
 * @author  gray 
 * @version 1.0 
 */ 
public class ThreadPoolManager { 
 
	private static final int DEFAULT_POOL_SIZE = 4; 
	private List<WorkThread> threadPool; 
	private Queue<Task> taskQueue; 
	private int poolSize; 
	 
	public ThreadPoolManager() { 
		this(DEFAULT_POOL_SIZE); 
	} 
	 
	public ThreadPoolManager(int poolSize) { 
		if(poolSize <= 0) { 
			this.poolSize = DEFAULT_POOL_SIZE; 
		}else { 
			this.poolSize = poolSize; 
		} 
		threadPool = new ArrayList<WorkThread>(this.poolSize); 
		taskQueue = new ConcurrentLinkedQueue<Task>(); 
		startup(); 
	} 
	 
	public void startup() { 
		System.out.println("start work thread..."); 
		synchronized(taskQueue) { 
			for(int i = 0; i < this.poolSize; i++) { 
				WorkThread workThread = new WorkThread(taskQueue); 
				threadPool.add(workThread); 
				workThread.start(); 
			} 
		} 
	} 
	 
	public void shutdown() { 
		System.out.println("shutdown work thread..."); 
		synchronized(taskQueue) { 
			for(int i = 0; i < this.poolSize; i++) { 
				threadPool.get(i).shutdown(); 
			}			 
			 
			System.out.println("done..."); 
		} 
	} 
	 
	public void addTask(Task task) { 
		synchronized(taskQueue) { 
			taskQueue.add(task); 
			taskQueue.notify(); 
		} 
	} 
}</span>

工作线程类：

Java代码

<span style="color: rgb(51, 102, 255);">import java.util.Queue; 
 
/** 
 * WorkThread.java 
 * 
 */ 
 
/** 
 * the work thread used pull the task of task queue, and execute it. 
 *  
 * @author  gray 
 * @version 1.0 
 */ 
public class WorkThread extends Thread { 
 
	private boolean shutdown = false; 
	private Queue<Task> queue; 
	 
	public WorkThread(Queue<Task> queue) { 
		this.queue = queue; 
	} 
	 
	public void run() { 
		while(!shutdown) { 
			try { 
				Thread.sleep(1000); 
			} catch (InterruptedException e1) { 
				e1.printStackTrace(); 
			} 
			System.out.println(Thread.currentThread() + " is running..."); 
			synchronized(queue) { 
				if(!queue.isEmpty()) { 
					Task task = queue.poll(); 
					task.execute(); 
				}else { 
					try { 
						queue.wait(1000); 
						System.out.println(Thread.currentThread() + " wait..."); 
					}catch(InterruptedException e) { 
						 
					} 
				} 
			} 
		} 
	} 
	 
	public void shutdown() { 
		shutdown = true; 
	} 
}</span>

工作任务接口：

<span style="color: rgb(51, 102, 255);">/** 
 * Task.java 
 * 
 */ 
 
/** 
 * The task want to execute. 
 *  
 * @author  gray 
 * @version 1.0 
 */ 
public interface Task { 
 
	public void execute(); 
}</span>

工作任务类：

<span style="color: rgb(51, 102, 255);">/** 
 * SimpleTask.java 
 * 
 */ 
 
/** 
 * @author  gray 
 * @version 1.0 
 */ 
public class SimpleTask implements Task { 
 
	/* (non-Javadoc) 
	 * @see Task#execute() 
	 */ 
	public void execute() { 
		System.out.println(Thread.currentThread()); 
	} 
 
}</span>

线程池测试类：

Java代码

<span style="color: rgb(51, 102, 255);">/** 
 * ThreadPoolDemo.java 
 * 
 */ 
 
/** 
 * @author  gray 
 * @version 1.0 
 */ 
public class ThreadPoolDemo { 
 
	public static void main(String[] args) { 
		ThreadPoolManager threadMg = new ThreadPoolManager(); 
		 
		for(int i = 0; i < 50; i++) { 
			threadMg.addTask(new SimpleTask()); 
		} 
		try { 
			Thread.sleep(5000); 
		} catch (InterruptedException e) { 
			e.printStackTrace(); 
		} 
		threadMg.shutdown(); 
	}	 
}</span>

标签:java 编程语言

声明

1.本站遵循行业规范，任何转载的稿件都会明确标注作者和来源；2.本站的原创文章，请转载时务必注明文章作者和来源，不尊重原创的行为我们将追究责任；3.作者投稿可能会经我们编辑修改或补充。