juc之线程池

线程池

好处

1. 提高响应速度
2. 便于资源管理
3. 节约开销，合理利用CPU和内存

应用场合

ThreadPoolExecutor

构造方法

创建和停止线程

工作队列

1. 直接交接：只是作为缓冲，相当于长度为0的队列，直接将任务交给线程，需要将最大线程数加大
2. 无界队列：无限填充任务
3. 有界队列：根据需要设置队列大小

线程池手动创建

异步模式之工作线程

线程数量设置

拒绝策略

线程池状态

Tomcat 线程池

手写线程池

package com.concurrent.pool;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class MySelfThreadPool {
	//默认线程池中的线程的数量
	private static final int WORK_NUM = 5;
	//默认处理任务的数量
	private static final int TASK_NUM = 100;
	private int workNum;//线程数量
	private int taskNum;//任务数量
	private final Set<WorkThread> workThreads;//保存线程的集合
	private final BlockingQueue<Runnable> taskQueue;//阻塞有序队列存放任务
	public MySelfThreadPool() {
		this(WORK_NUM, TASK_NUM);
	}
	public MySelfThreadPool(int workNum, int taskNum) {
		if (workNum <= 0) workNum = WORK_NUM;
		if (taskNum <= 0) taskNum = TASK_NUM;
		taskQueue = new ArrayBlockingQueu图e<>(taskNum);
		this.workNum = workNum;
		this.taskNum = taskNum;
		workThreads = new HashSet<>();
		//启动一定数量的线程数，从队列中获取任务处理
		for (int i=0;i<workNum;i++) {
			WorkThread workThread = new WorkThread("thead_"+i);
			workThread.start();
			workThreads.add(workThread);
		}
	}
	public void execute(Runnable task) {
		try {
			taskQueue.put(task);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public void destroy() {
		System.out.println("ready close thread pool...");
		if (workThreads == null || workThreads.isEmpty()) return ;
		for (WorkThread workThread : workThreads) {
			workThread.stopWork();
			workThread = null;//help gc
		}
		workThreads.clear();
	}
	private class WorkThread extends Thread{
		public WorkThread(String name) {
			super();
			setName(name);
		}
		@Override
		public void run() {
			while (!interrupted()) {
				try {
					Runnable runnable = taskQueue.take();//获取任务
					if (runnable !=null) {
						System.out.println(getName()+" readyexecute:"+runnable.toString());
						runnable.run();//执行任务
					}
					runnable = null;//help gc
				} catch (Exception e) {
					interrupt();
					e.printStackTrace();
				}
			}
		}
		public void stopWork() {
			interrupt();
		}
	}
}

package com.concurrent.pool;
 
public class TestMySelfThreadPool {
	private static final int TASK_NUM = 50;//任务的个数
	public static void main(String[] args) {
		MySelfThreadPool myPool = new MySelfThreadPool(3,50);
		for (int i=0;i<TASK_NUM;i++) {
			myPool.execute(new MyTask("task_"+i));
		}
	}
	static class MyTask implements Runnable{
		private String name;
		public MyTask(String name) {
			this.name = name;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		@Override
		public void run() {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("task :"+name+" end...");
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return "name = "+name;
		}
	}
}

Fork / Join