1.引言
合理利用线程池能够带来三个好处。第一:降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二:提高响应速度。当任务到达时,任务可以不需要的等到线程创建就能立即执行。第三:提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。但是要做到合理的利用线程池,必须对其原理了如指掌。
2.线程池使用
Executors提供的四种线程 1.newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 2.newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。 3.newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。 4.newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1.newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例如下
ExecutorService executorService = Executors.newCachedThreadPool();
for(int i=0;i<5;i++){
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "," +index);
}
});
}
2.newFixedThreadPool创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例如下
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for(int i=0;i<5;i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + ", " + index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
3.newScheduledThreadPool 创建一个定长线程池,支持周期和定时任务示例如下
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("延迟3秒执行的哦 :" + System.currentTimeMillis()/1000);
}
}, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);
System.out.println("before:" + System.currentTimeMillis()/1000);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("延迟1秒之后,3秒执行一次:" +System.currentTimeMillis()/1000);
}
}, 1, 3, TimeUnit.SECONDS);
System.out.println("after :" +System.currentTimeMillis()/1000);
4.newSingleThreadExecutor创建一个单线程化的线程池,只会用工作线程来执行任务,保证顺序,示例如下
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i=0;i<10;i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + "," + index);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
向线程池提交任务 ThreadPoolExecutor类中execute()和submit()区别 execute()方法实际上是Executor中声明的方法,在ThreadPoolExecutor进行了具体的实现,这个方法是ThreadPoolExecutor的核心方法,通过这个方法可以向线程池提交一个任务,交由线程池去执行。
submit()方法是在ExecutorService中声明的方法,在AbstractExecutorService就已经有了具体的实现,在ThreadPoolExecutor中并没有对其进行重写,这个方法也是用来向线程池提交任务的,但是它和execute()方法不同,它能够返回任务执行的结果,通过源码查看submit()方法的实现,会发现它实际上还是调用的execute()方法,只不过它利用了Future来获取任务执行结果。
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
Future使用
必须实现callable封装业务逻辑
/**
* @author liuminglin
* JAVA 线程池之Callable返回结果
*/
public class TaskThread implements Callable<String> {
private Integer number;
public TaskThread(Integer number) {
this.number = number;
}
@Override
public String call() throws Exception {
//这里一般实现业务逻辑
System.out.println("线程:" + number + " -> 运行...");
Thread.sleep(5000);
System.out.println("线程:" + number + " -> 结束.");
return "返回的字符串" + number;
}
}
Future调用
import java.util.ArrayList;
import java.util.concurrent.*;
public class ExecutorService {
public ExecutorService() {
java.util.concurrent.ExecutorService executor = new ThreadPoolExecutor(4, 6, 1, TimeUnit.MINUTES,
new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
ArrayList<Future<String>> resultList = new ArrayList<Future<String>>();
//开启10个线程
for (int i = 0; i < 10; i++) {
//执行业务逻辑
TaskThread task = new TaskThread(i);
//异步提交
Future<String> future = executor.submit(task);
resultList.add(future);
}
System.out.println("获取结果中...");
for (Future<String> f : resultList) {
try {
// if(f.isDone())
System.out.println(f.get());
} catch (Exception e) {
e.printStackTrace();
}
}
System.out.println("得到结果.");
// 关闭线程池。
executor.shutdown();
}
public static void main(String[] args) {
new ExecutorService();
}
}
匿名内部类使用线程池
public void threadPool(final List userInfoList) {
ExecutorService executor = new ThreadPoolExecutor(4, 6, 1, TimeUnit.MINUTES,
new LinkedBlockingQueue<>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
try {
for (int i = 0; i < 5; i++) {
executor.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程名称___________>" + Thread.currentThread().getName());
log.info("线程名称 :{}", Thread.currentThread().getName());
batchList(userInfoList);
}
});
}
} catch (Exception e) {
e.printStackTrace();
}
}
执行代码逻辑
public void batchList(final List userInfoList) {
int size = userInfoList.size();
int limitNum = 10;
//批次数
int batchNum = size % limitNum == 0 ? size / limitNum : size / limitNum + 1;
boolean falg = size % limitNum != 0;
for (int i = 0; i < batchNum; i++) {
int starNum = i * limitNum;
int endNum = (i + 1) * limitNum;
//size/limitNum取余数(除不尽),计算end的索引值
if (falg && i == batchNum - 1) {
endNum = size;
}
List batchList = userInfoList.subList(starNum, endNum);
dbDao.batchExecutor(NameSpaceEnum.USER_MAPPER, "batchInsert", batchList);
}
}
@RequestMapping(value = "/insertList", method = {RequestMethod.GET})
public void batchInsertList() {
List<UserInfo> userInfoList = new ArrayList<>();
for (int i = 1; i <= 201; i++) {
UserInfo userInfo = new UserInfo();
userInfo.setId(i);
userInfo.setUserId(String.valueOf(i));
userInfo.setUserName("张三" + String.valueOf(i));
userInfo.setPhone(String.valueOf(i));
userInfo.setHometown(String.valueOf(i));
userInfo.setEmail(String.valueOf(i));
userInfo.setAddress(String.valueOf(i));
userInfo.setCreatTime(new Date());
userInfo.setModifyDate(new Date());
userInfoList.add(userInfo);
}
threadPool(userInfoList);
}
案例三
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.atomic.AtomicInteger;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
public class ThreadManager {
/**
* 线程池
*/
private final static ThreadPoolTaskExecutor EXECUTOR = new ThreadPoolTaskExecutor();
/**
* 计数器
*/
private final static AtomicInteger COUNTER = new AtomicInteger(0);
static {
EXECUTOR.setCorePoolSize(5); // 线程池维护线程的最少数量
EXECUTOR.setKeepAliveSeconds(200); // 允许的空闲时间
EXECUTOR.setMaxPoolSize(20); // 线程池维护线程的最大数量
EXECUTOR.setQueueCapacity(50); // 缓存队列
EXECUTOR.initialize();
}
public void sendPost(final String url, final String param) {
synchronized (this) {
while (COUNTER.get() > 50) { // 如果记数器超过40,则等待一段时间
System.out.println("param:" + param + "等待");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
COUNTER.incrementAndGet(); // 任务开始前,计数器加1
}
EXECUTOR.execute(new Runnable() {
@Override
public void run() {
try {
doSendPost(url, param);
} finally {
// 任务完成后,计数器减1
int num = COUNTER.decrementAndGet();
}
}
});
}
// public static void main(String[] args) {
// ThreadManager manager = new ThreadManager();
// 测试执行100次处理
// for (int i = 0; i < 100; i++) {
// manager.sendPost("url", "num:" + i);
// }
// System.out.println("==============");
// }
private static String doSendPost(String url, String param) {
// 具体执行推送
}
}
线程池的关闭 我们可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池,但是它们的实现原理不同,shutdown的原理是只是将线程池的状态设置成SHUTDOWN状态,然后中断所有没有正在执行任务的线程。shutdownNow的原理是遍历线程池中的工作线程,然后逐个调用线程的interrupt方法来中断线程,所以无法响应中断的任务可能永远无法终止。shutdownNow会首先将线程池的状态设置成STOP,然后尝试停止所有的正在执行或暂停任务的线程,并返回等待执行任务的列表。
只要调用了这两个关闭方法的其中一个,isShutdown方法就会返回true。当所有的任务都已关闭后,才表示线程池关闭成功,这时调用isTerminaed方法会返回true。至于我们应该调用哪一种方法来关闭线程池,应该由提交到线程池的任务特性决定,通常调用shutdown来关闭线程池,如果任务不一定要执行完,则可以调用shutdownNow。
3. 线程池的分析
流程分析:线程池的主要工作流程如下图: Java线程池主要工作流程
从上图我们可以看出,当提交一个新任务到线程池时,线程池的处理流程如下:
- 首先线程池判断基本线程池是否已满?没满,创建一个工作线程来执行任务。满了,则进入下个流程。
- 其次线程池判断工作队列是否已满?没满,则将新提交的任务存储在工作队列里。满了,则进入下个流程。
- 最后线程池判断整个线程池是否已满?没满,则创建一个新的工作线程来执行任务,满了,则交给饱和策略来处理这个任务。
**源码分析。**上面的流程分析让我们很直观的了解的线程池的工作原理,让我们再通过源代码来看看是如何实现的。线程池执行任务的方法如下:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
工作线程。线程池创建线程时,会将线程封装成工作线程Worker,Worker在执行完任务后,还会无限循环获取工作队列里的任务来执行。