目录
认识线程池
介绍
什么是线程池
- 线程池就是一个可以复用线程的技术。
不使用线程池的问题
- 用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。
线程池的工作原理
任务对象实现接口：
- Runnable
- Callable
由于线程池可以控制线程的数量，又可以控制那些任务的数量，因此它不会因为这些线程过多或者任务过多而导致把系统资源耗尽，引起系统瘫痪的风险。整体看是可以提高系统的工作性能的。
如何创建线程池
介绍
谁代表线程池？
- JDK5.0起提供了代表线程池的接口：ExecutorService。
如何得到线程池对象？
- 方式一：使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池对象。
- 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。
ThreadPoolExecutor构造器
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,
long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler);- 参数一：corePoolSize：指定线程池的核心线程的数量。
- 参数二：maximumPoolSize：指定线程池的最大线程数量。
- 参数三：keepAliveTime：指定临时线程的存活时间。
- 参数四：unit：指定临时线程存活的时间单位(秒、分、时、天)
- 参数五：workQueue：指定线程池的任务队列。
- 参数六：threadFactory：指定线程池的线程工厂。
- 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）
以餐厅作为例子：
代码实例
import java.util.concurrent.*;
/*
掌握线程池的创建
*/
public class ThreadPoolTest1 {
public static void main(String[] args) {
//1.通过ThreadPoolExecutor创建一个线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,5,8,
TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}
}
线程池的注意事项
1、临时线程什么时候创建？
- 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
2、什么时候会开始拒绝新任务？
- 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。
线程池处理Runnable任务
ExecutorService的常用方法
| 方法名称 | 说明 |
|---|---|
| void execute(Runnable command) | 执行 Runnable 任务 |
| Future<T> submit(Callable<T> task) | 执行Callable任务，返回未来任务对象，用于获取线程返回的结果 |
| void shutdown() | 等全部任务执行完毕后，再关闭线程池！ |
| List<Runnable> shutdownNow() | 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务 |
代码实例
public class MyRunnable implements Runnable{
@Override
public void run() {
//线程类执行的任务
System.out.println(Thread.currentThread().getName() + "--> 输出233！");
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.*;
public class ThreadPoolTest1 {
public static void main(String[] args) {
//1.通过ThreadPoolExecutor创建一个线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,5,8,
TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
Runnable target = new MyRunnable();
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //复用前面的核心线程
pool.execute(target); //复用前面的核心线程
pool.shutdown(); //等待线程池的全部任务全部执行完毕后，再关闭线程
// pool.shutdownNow(); //立即关闭线程池！不管任务是否执行完毕
}
}
运行结果：
临时线程的创建时机
import java.util.concurrent.*;
public class ThreadPoolTest1 {
public static void main(String[] args) {
//1.通过ThreadPoolExecutor创建一个线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,5,8,
TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
Runnable target = new MyRunnable();
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);
//占满任务队列，到了临时线程的创建时机了
pool.execute(target);
pool.execute(target);
pool.shutdown(); //等待线程池的全部任务全部执行完毕后，再关闭线程
// pool.shutdownNow(); //立即关闭线程池！不管任务是否执行完毕
}
}
运行结果：
新任务的拒绝时机
package user.ThreadTest;
import java.util.concurrent.*;
/*
掌握线程池的创建
*/
public class ThreadPoolTest1 {
public static void main(String[] args) {
//1.通过ThreadPoolExecutor创建一个线程池对象
ExecutorService pool = new ThreadPoolExecutor(3,5,8,
TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
Runnable target = new MyRunnable();
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target); //线程池会自动创建一个新线程，自动处理这个任务，自动执行
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);
//占满任务队列，到了临时线程的创建时机了
pool.execute(target);
pool.execute(target);
//再创建，就到了新任务的拒绝时机了
pool.execute(target);
pool.shutdown(); //等待线程池的全部任务全部执行完毕后，再关闭线程
// pool.shutdownNow(); //立即关闭线程池！不管任务是否执行完毕
}
}
运行结果：
新任务拒绝策略
| 策略 | 详解 |
|---|---|
| ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 |
| ThreadPoolExecutor.DiscardPolicy | 丢弃任务，但是不抛出异常这是不推荐的做法 |
| ThreadPoolExecutor.DiscardoldestPolicy | 抛弃队列中等待最久的任务然后把当前任务加入队列中 |
| ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run0方法从而绕过线程池直接执行 |
改成ThreadPoolExecutor.CallerRunsPolicy策略：
改完拒绝策略，就不会报之前的那个错，
运行结果变为：
线程池处理Callable任务
ExecutorService的常用方法
| 方法名称 | 说明 |
|---|---|
| void execute(Runnable command) | 执行 Runnable 任务 |
| Future<T> submit(Callable<T> task) | 执行Callable任务，返回未来任务对象，用于获取线程返回的结果 |
| void shutdown() | 等全部任务执行完毕后，再关闭线程池！ |
| List<Runnable> shutdownNow() | 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务 |
代码实例
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n){
this.n = n;
}
//2.重写call方法
@Override
public String call() throws Exception {
//描述线程的任务，返回线程执行返回后的结果
//需求：求1-n的和返回
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
}
}
import java.util.concurrent.*;
public class ThreadPoolTest2 {
public static void main(String[] args) throws Exception{
//1、通过ThreadPooLExecutor创建一个线程池对象。
ExecutorService pool = new ThreadPoolExecutor(3,5,8,
TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
//2、使用线程处理CaLLabLe任务。
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
pool.shutdown(); //等待线程池的全部任务全部执行完毕后，再关闭线程
}
}
运行结果
END
学习自：黑马程序员——Java课程
扫一扫
1387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
