目录
认识线程池
介绍
线程池的工作原理
如何创建线程池
介绍
ThreadPoolExecutor构造器
代码实例
线程池的注意事项
线程池处理Runnable任务
ExecutorService的常用方法
代码实例
新任务拒绝策略
线程池处理Callable任务
ExecutorService的常用方法
代码实例
认识线程池
介绍
什么是线程池
- 线程池就是一个可以复用线程的技术。
不使用线程池的问题
- 用户每发起一个请求,后台就需要创建一个新线程来处理,下次新任务来了肯定又要创建新线程处理的,而创建新线程的开销是很大的,并且请求过多时,肯定会产生大量的线程出来,这样会严重影响系统的性能。
线程池的工作原理
任务对象实现接口:
- 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{@Overridepublic 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方法@Overridepublic 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课程