Java 线程池简单实现

Java 线程池简单实现

---

线程池的作用

对于一些并发量不高，不要求服务器快速响应请求的任务，我们可以通过每接收一个任务，创建一个线程来执行任务的方式来完成，但是对于一些高并发下场景下，很容易就会性能瓶颈的。一个任务一个线程的话，系统会创建大量的线程，导致操作系统频繁地进行上下文切换，增加系统的负载，同时线程是一个很珍贵的资源，每一次线程的创建和销毁都会消耗系统资源。
我们可以通过创建线程池来解决问题，线程池通过预先创建一定数量的worker，不让用户直接创建线程来执行任务，通过重复的使用固定数目的worker来完成任务，可以方便管理线程的分配、监控和调优，同时减少了线程和销毁线程的系统资源开销，而且提高了任务的相应速度，不需要等到任务到来时才创建线程。

线程池的原理

线程池任务处理过程

当接收到一个任务请求的时候，线程池首先会判断线程池里的线程是否都在执行任务，如果有空闲线程的话，会调用空闲线程来执行任务，否则，就会将任务添加到工作队列，如果工作队列已满的话，就会将这个任务交给RejectExecutionHandler(饱和策略)来处理。

线程池简单实现(没有实现饱和策略)

package me.kuye.concurrent;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicLong;

public class ThreadPool<Task extends Runnable> {
    //最大线程数
	private static final int MAX_WORKER_NUMBERS = 10;
	//默认线程数
	private static final int DEFAULT_WORKER_NUMBERS = 5;
	//最小线程数
	private static final int MIN_WORKER_NUMBERS = 1;
    //工作队列
	private BlockingQueue<Task> taskQueue = new LinkedBlockingQueue<>();
	//工作者队列
	private List<Worker> workerList = Collections.synchronizedList(new ArrayList<>());
	//当前线程数
	private int workerNum = DEFAULT_WORKER_NUMBERS;
	//
	private AtomicLong threadNumber = new AtomicLong();
	public ThreadPool() {
		this(DEFAULT_WORKER_NUMBERS);
	}

	public ThreadPool(int number) {
		this.workerNum = number > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS
				: number < MIN_WORKER_NUMBERS ? MIN_WORKER_NUMBERS : number;
		init(workerNum);
	}
	//线程池预热，预先创建固定数目的线程
	private void init(int workerNum) {
		for (int i = 0; i < workerNum; i++) {
			workerList.add(new Worker("worker-" + threadNumber.incrementAndGet()));
		}
		for (Worker worker : workerList) {
			new Thread(worker).start();
		}
	}
    //执行任务
	public void execute(Task task) {
		if (task != null) {
			synchronized (taskQueue) {
				taskQueue.add(task);
				taskQueue.notify();
			}
		}
	}
    //关闭线程池
	public void shutdown() {
		for (Worker worker : workerList) {
			worker.shutdown();
		}
	}
    // 增加一定数目的工作者
	public void addWorkers(int number) {
		synchronized (workerList) {
			if (number + this.workerNum > MAX_WORKER_NUMBERS) {
				number = MAX_WORKER_NUMBERS - this.workerNum;
			}
			init(number);
			this.workerNum += number;
		}

	}
    //减少一定数目的工作者
	public void removeWorkers(int number) {
		synchronized (workerList) {
			if (number > this.workerNum) {
				throw new IllegalArgumentException("the number is more than the workerNum");
			}
			int count = 0;
			while (count < number) {
				Worker worker = workerList.get(count);
				if (workerList.remove(worker)) {
					worker.shutdown();
					count++;
				}
			}
		}
		this.workerNum -= number;
	}
    // 工作者
	private class Worker implements Runnable {
		private volatile boolean isStop = false;
		private String workerName = "";

		public Worker(String workerName) {
			this.workerName = workerName;
		}

		@Override
		public void run() {
			while (!isStop) {
				Task task = null;
				synchronized (taskQueue) {
					while (taskQueue.isEmpty()) {
						try {
							taskQueue.wait();
						} catch (InterruptedException e) {
							Thread.currentThread().interrupt();
							return;
						}
					}
					task = taskQueue.poll();
				}
				if (task != null) {
					try {
						System.out.print(this.workerName+ " ");
						task.run();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}
		}

		public void shutdown() {
			this.isStop = true;
			System.out.println(this.workerName + " is shutdown");
		}
	}

}