在实际使用中,线程是很占用系统资源的,如果对线程管理不善很容易导致系统问题。因此,在大多数并发框架中都会使用线程池来管理线程,使用线程池管理线程主要有如下好处:
– 1、使用线程池可以重复利用已有的线程继续执行任务,避免线程在创建和销毁时造成的消耗
– 2、由于没有线程创建和销毁时的消耗,可以提高系统响应速度
– 3、通过线程可以对线程进行合理的管理,根据系统的承受能力调整可运行线程数量的大小等
线程池的工作原理
线程池执行所提交的任务过程:
1、先判断线程池中核心线程池所有的线程是否都在执行任务。 如果不是,则新创建一个线程执行刚提交的任务,否则,核心线程池中所有的线程都在执行任务,则进入第2步;
2、判断当前阻塞队列是否已满,如果未满,则将提交的任务放置在阻塞队列中;否则,则进入第3步;
3、判断线程池中所有的线程是否都在执行任务,如果没有,则创建一个新的线程来执行任务,否则,则交给饱和策略进行处理
线程池的分类
线程池的生命周期
RUNNING :能接受新提交的任务,并且也能处理阻塞队列中的任务;
SHUTDOWN:关闭状态,不再接受新提交的任务,但却可以继续处理阻塞队列中已保存的任务。
STOP:不能接受新任务,也不处理队列中的任务,会中断正在处理任务的线程。
TIDYING:如果所有的任务都已终止了,workerCount (有效线程数) 为0,线程池进入该状态后会调用 terminated() 方法进入TERMINATED 状态。
TERMINATED:在terminated() 方法执行完后进入该状态,默认terminated()方法中什么也没有做。
线程池的创建
corePoolSize:核心线程池的大小
maximumPoolSize:线程池能创建线程的最大个数
keepAliveTime:空闲线程存活时间
unit:时间单位,为keepAliveTime指定时间单位
workQueue:阻塞队列,用于保存任务的阻塞队列
threadFactory:创建线程的工程类
handler:饱和策略(拒绝策略)
execute方法执行逻辑![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/6e7ba024c91325aeaef6f5290d6ef84e.png)
如果当前运行的线程少于corePoolSize,则会创建新的线程来执 行新的任务;
如果运行的线程个数等于或者大于corePoolSize,则会将提交的 任务存放到阻塞队列workQueue中;
如果当前workQueue队列已满的话,则会创建新的线程来执行任务;
如果线程个数已经超过了maximumPoolSize,则会使用饱和策略RejectedExecutionHandler来进行处理。
线程池的关闭
关闭线程池,可以通过shutdown和shutdownNow两个方法
原理:遍历线程池中的所有线程,然后依次中断
1、shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程,并返回等待执行任务的列表;
2、shutdown只是将线程池的状态设置为SHUTDOWN状态,然后中断所有没有正在执行任务的线程
CacheThreadPool
package com.petrel.demo.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author Petrel
* @data 2020/6/29 20:26
*/
//线程池触发线程 一起执行
public class CacheThreadPoolDemo {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0;i<20;i++){
executorService.execute(new Task());
}
executorService.shutdown();
}
}
------------
package com.petrel.demo.demo;
/**
* @author Petrel
* @data 2020/6/29 20:29
*/
public class Task implements Runnable{
@Override
public void run() {
try {
Thread.sleep(1000); //不加这句话CacheThreadPoolDemo运行会出现重复线程 复用
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"running");
}
}
FixedThreadPool
package com.petrel.demo.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author Petrel
* @data 2020/6/29 20:39
*/
//规定几个一起执行
public class FixedThreadPool {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5); //5个线程5个线程执行
for (int i = 0;i<20;i++){
executorService.execute(new Task());
}
executorService.shutdown();
}
}
SingleThreadPoolDemo
package com.petrel.demo.demo;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author Petrel
* @data 2020/6/29 20:54
*/
//一个一个执行
public class SingleThreadPoolDemo {
public static void main(String[] args) {
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0;i<20;i++){
executorService.execute(new Task());
}
executorService.shutdown();
}
}
ScheduledThreadPool
package com.petrel.demo.demo;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author Petrel
* @data 2020/6/30 9:43
*/
//延迟
//延迟三秒执行:schedule()方法
public class ScheduledThreadPoolDemo {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
System.out.println(System.currentTimeMillis());//运行结果:1593481712713
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
System.out.println("延迟三秒执行");
System.out.println(System.currentTimeMillis());//运行结果:1593481715722
}
},3, TimeUnit.SECONDS);
scheduledExecutorService.shutdown();
}
}
/*
1593481715722-1593481712713≈3000 3秒
*/
package com.petrel.demo.demo;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* @author Petrel
* @data 2020/6/30 9:43
*/
//定时
//每三秒执行一次:scheduleAtFixedRate()方法
public class ScheduledThreadPoolDemo2 {
public static void main(String[] args) {
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
System.out.println(System.currentTimeMillis());//运行结果:1593481712713
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("延迟一秒执行,每三秒执行一次");
System.out.println(System.currentTimeMillis());//运行结果:1593481715722
}
},1,3, TimeUnit.SECONDS);
//scheduledExecutorService.shutdown();
}
}
/*
运行结果:
1593482149884
延迟一秒执行,每三秒执行一次
1593482150894
延迟一秒执行,每三秒执行一次
1593482153897
延迟一秒执行,每三秒执行一次
1593482156897
延迟一秒执行,每三秒执行一次
1593482159893
延迟一秒执行,每三秒执行一次
1593482162930
延迟一秒执行,每三秒执行一次
......
*/
ExecutorService
package com.petrel.demo.callable;
import java.util.concurrent.Callable;
/**
* @author Petrel
* @data 2020/6/30 17:15
*/
public class Task implements Callable<String> {
private int i;
public Task(int i){
this.i = i;
}
@Override
public String call() throws Exception {
Thread.sleep(1000);
return Thread.currentThread().getName()+"is running"+i;
}
}
------------
package com.petrel.demo.callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* @author Petrel
* @data 2020/6/30 17:15
*/
public class Test {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0;i<20;i++){
Future<String> submit = executorService.submit(new Task(i));
try {
String str = submit.get();
System.out.println(str);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}
/*
运行结果:
pool-1-thread-1is running0
pool-1-thread-2is running1
pool-1-thread-3is running2
pool-1-thread-4is running3
pool-1-thread-5is running4
pool-1-thread-1is running5
pool-1-thread-2is running6
pool-1-thread-3is running7
pool-1-thread-4is running8
pool-1-thread-5is running9
pool-1-thread-1is running10
pool-1-thread-2is running11
pool-1-thread-3is running12
pool-1-thread-4is running13
pool-1-thread-5is running14
pool-1-thread-1is running15
pool-1-thread-2is running16
pool-1-thread-3is running17
pool-1-thread-4is running18
pool-1-thread-5is running19
*/
ThreadPool
package com.petrel.demo;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @author Petrel
* @data 2020/6/30 17:34
*/
public class ThreadPoolDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,new ArrayBlockingQueue(5));
threadPoolExecutor.execute(new Runnable() {
@Override
public void run() {
System.out.println(Math.random());//运行结果:0.6386970527063673
}
});
}
}