java nio 线程池_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 {

//最大线程数

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 taskQueue = new LinkedBlockingQueue<>();

//工作者队列

private List 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");

}

}

}