Java线程池ThreadPool

1、线程池基础

1.1 什么是线程池

线程池是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的任务就是我们学过的实现了Runnable或Callable接口的实现对象。

 

1.2 使用线程池有哪些优势

 

1.2 线程池使用

 

1.3 自定义线程池 - 参数设计分析

 

1.4 自定义线程池 - 实现步骤

1.5 代码

（1）任务类

package com.dhu.thread.threadlocal.demo1;

/**
 * 任务类：包含任务编号，每一个任务执行时间设为0.2秒
 * @author zhou
 *
 */
public class MyTask implements Runnable{
	private int id;
	
	public MyTask(int id) {
		this.id = id;
	}

	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		System.out.println("线程: " + name + "即将执行任务：" + id);
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("线程: " + name + "完成任务：" + id);
	}

	@Override
	public String toString() {
		return "MyTask [id=" + id + "]";
	}
	
	

}

（2）线程类

package com.dhu.thread.threadlocal.demo1;

import java.util.List;

/**
 * 线程类：设计一个属性，保存线程的名字
 * 			设计一个集合，保存所有的任务
 * @author zhou
 *
 */
public class MyWork extends Thread{
	private String name;
	private List<Runnable> tasks;
	
	public MyWork(String name, List<Runnable> tasks) {
//		this.name = name;
		super(name);
		this.tasks = tasks;
	}
	
	
	@Override
	public void run() {
		while(tasks.size() > 0) {
			Runnable r = tasks.remove(0);
			r.run();
		}
	}


	@Override
	public String toString() {
		return "MyWork [name=" + name + ", tasks=" + tasks + "]";
	}
	

}

（3）自定义线程池类

package com.dhu.thread.threadlocal.demo1;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 * 自定义的线程池类：
 * 		成员变量：
 * 			1.任务队列， 集合，需要控制线程安全问题
 * 			2.核心线程数量
 * 			3.最大线程数量
 * 			4.当前线程数量
 * 			5.任务队列的长度
 * 		成员方法：
 * 			1.提交任务；
 * 				将任务添加到任务队列，需要判断是否超出了任务总长度
 * 			2.执行任务：
 * 				判断当前线程的数量，决定创建核心线程还是非核心线程
 * @author zhou
 *
 */
public class MyThreadPool {
	//1.任务队列， 集合，需要控制线程安全问题
	private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
	//2.核心线程数量
	private int corePoolSize;
	//3.最大线程数量
	private int maxSize;
	//4.当前线程数量
	private int num;
	//5.任务队列的长度
	private int workSize;
	
	
	public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
		super();
		this.corePoolSize = corePoolSize;
		this.maxSize = maxSize;
		this.workSize = workSize;
	}

	//1.提交任务；
	public void submit(Runnable r) {
		//判断任务队列中任务数是否超出最大任务长度
		if(tasks.size() >= workSize) {
			System.out.println("任务 " + r + "被丢弃了");
		}else {
			tasks.add(r);
			//2.执行任务：
			executeTask(r);
		}
		
	}

	private void executeTask(Runnable r) {
		//判断线程池中当前线程数量是否超出最大线程数
		if(num < corePoolSize) {
			new MyWork("核心线程" + num, tasks).start();
			num ++;
		}else if(num < maxSize) {
			new MyWork("非核心线程" + num, tasks).start();
			num ++;
		}else {
			System.out.println("任务" + r + "被缓存了...");
		}
		
	}
	
}

（4）测试类

package com.dhu.thread.threadlocal.demo1;

public class MyTest {
	public static void main(String[] args) {
		//1.创建线程池类对象
		MyThreadPool threadPool = new MyThreadPool(2, 4, 20);
		
		//2.提交多个任务
		for (int i = 0; i < 10; i++) {
			//3.创建任务对象，并提交给线程池
			MyTask task = new MyTask(i);
			threadPool.submit(task);
		}
	}
}

package com.dhu.thread.threadlocal.demo1;

public class MyTest {
	public static void main(String[] args) {
		//1.创建线程池类对象
		MyThreadPool threadPool = new MyThreadPool(2, 4, 20);
		
		//2.提交多个任务
		for (int i = 0; i < 30; i++) {
			//3.创建任务对象，并提交给线程池
			MyTask task = new MyTask(i);
			threadPool.submit(task);
		}
	}
}