java编写属于自己的线程池

java编写属于自己的线程池

什么是线程池

线程池就是以一个或多个线程[循环执行]多个应用逻辑的线程集合.

一般而言，线程池有以下几个部分:

完成主要任务的一个或多个线程.

用于调度管理的管理线程.

要求执行的任务队列.

线程池的作用：

线程池作用就是限制系统中执行线程的数量。

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

自己实现线程池

根据如上对线程池的理解，我们自己编写一个属于自己的简单线程池:

简单的线程池接口:

public interface ThreadPool{

//执行一个任务(Job),这个Job必须实现Runnable

void execute(Job job);

//关闭线程池

void shutdown();

void addWorkers(int num);

void removeWorker(int num);

//获取正在等待执行的任务数量

void getJobSize();

}

线程池接口的默认实现

public class DefaultThreadPool implements ThreadPool{

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 final LinkedList jobs = new LinkedList();

private final List workers = Collections.synchronizedList(new ArrayList());

private int workerNum;

private AtomicLong threadNum = new AtomicLong();

//生成线程池

public DefaultThreadPool() {

this.workerNum = DEFAULT_WORKER_NUMBERS;

initializeWorkers(this.workerNum);

}

public DefaultThreadPool(int num) {

if (num > MAX_WORKER_NUMBERS) {

this.workerNum =DEFAULT_WORKER_NUMBERS;

} else {

this.workerNum = num;

}

initializeWorkers(this.workerNum);

}

private void initializeWorkers(int num) {

for (int i = 0; i < num; i++) {

Worker worker = new Worker();

workers.add(worker);

Thread thread = new Thread(worker);

thread.start();

}

}

public void execute(Job job) {

if (job != null) {

//根据线程的"等待/通知机制"这里必须对jobs加锁

synchronized (jobs) {

jobs.addLast(job);

jobs.notify();

}

}

}

public void shutdown() {

for (Worker w : workers) http://{

w.shutdown();

}

}

public void addWorkers(int num) {

synchronized (jobs) {

if (num + this.workerNum > MAX_WORKER_NUMBERS) {

num = MAX_WORKER_NUMBERS - this.workerNum;

}

initializeWorkers(num);

this.workerNum += num;

}

}

public void removeWorker(int num) {

synchronized (jobs) {

if(num>=this.workerNum){

throw new IllegalArgumentException("超过了已有的线程数量");

}

for (int i = 0; i < num; i++) {

Worker worker = workers.get(i);

if (worker != null) {

//关闭该线程并从列表中移除

worker.shutdown();

workers.remove(i);

}

}

this.workerNum -= num;

}

}

public int getJobSize() {

// TODO Auto-generated method stub

return workers.size();

}

class Worker implements Runnable {

// 表示是否运行该worker

private volatile boolean running = true;

public void run() {

while (running) {

Job job = null;

//线程的等待/通知机制

synchronized (jobs) {

if (jobs.isEmpty()) {

try {

jobs.wait();//线程等待唤醒

} catch (InterruptedException e) {

//感知到外部对该线程的中断操作，返回

dHBihm Thread.currentThread().interrupt();

return;

}

}

// 取出一个job

job = jobs.removeFirst();

}

//执行job

if (job != null) {

job.run();

}

}

}

// 终止该线程

public void shutdown() {

running = false;

}

}

}

参考: 《java并发编程的艺术》 方腾飞

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。