第一章 Java线程池技术应用
文章目录
前言
介绍Java的线程、线程池等操作
1、Java创建线程方式回顾
1.1、继承Thread类(只运行一次)
public class ThreadTest extends Thread{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args) {
new ThreadTest().start();
}
}
1.1.1、改造成主线程常驻,每秒开启新线程运行
import java.util.Date;
@Slf4j
public class ThreadTest extends Thread{
@Override
public void run() {
log.info("线程名称:{} , 当前时间:{}" , Thread.currentThread().getName() , new Date().getTime() );
}
public static void main(String[] args) {
while (true) {
try {
new ThreadTest().start();
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
log.info("主线程常驻");
}
}
}
1.1.2、匿名内部类
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class ThreadTest extends Thread{
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
log.info("Hello {}" , "world");
}
};
thread.start();
}
}
1.1.3、缺点
继承了Thread类之后,就不能继承其他类
1.1.4、扩展知识:Java内部类
成员内部类(外部类内部使用,外部类外部使用)
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Outer {
public static void main(String[] args) {
Inner inner = new Outer().initTest();
log.info(inner.innerTest());
}
public Inner initTest(){
Inner inner = new Inner();
return inner;
}
class Inner{
public Inner(){
}
public Inner(String s){
}
public String innerTest(){
return "Inner Hello world";
}
}
}
1.1.4.1、静态内部类
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Outer {
public static void main(String[] args) {
Inner inner = new Inner();
log.info(inner.innerTest());
}
public void initTest(){
Inner inner = new Inner();
}
static class Inner{
public Inner(){
}
public Inner(String s){
}
public String innerTest(){
return "Inner Hello world";
}
}
}
1.1.4.2、匿名内部类
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Outer {
public static void main(String[] args) {
Outer outer = new Outer();
outer.sayHello();
}
public void sayHello(){
IMessage iMessage = new IMessage() {
//匿名类
@Override
public String sayHello() {
return "Hello world";
}
};
log.info(iMessage.sayHello());
}
interface IMessage{
String sayHello();
}
}
1.2、实现Runnable接口
1.2.1、普通类实现Runnable接口
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class StatSales implements Runnable{
@Override
public void run() {
log.info("统计销量");
}
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
public void run() {
log.info("Hello world");
}
};
thread.start();
}
}
1.2.2、匿名方式创建Runnable实现类
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("统计成绩");
}
};
new Thread(runnable).start();
}
1.2.3、使用Lambda方式创建匿名Runnable类
// 使用 Lambda 匿名 Runnable 方式
Thread t3 = new Thread(() -> {
//添加业务方法…
});
// 启动线程
t3.start();
public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println("统计平均寿命");
});
thread.start();
}
1.2.4、缺点
不能获得程序的执行结果
1.2.5、扩展Lambda表达式
把函数作为一个方法的参数
表达式语法:
(parameters) -> expression
或
(parameters) ->{ statements; }
说明:
- 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
- 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号。
- 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
- 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定表达式返回了一个数值。
举例:
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
1.3、实现Callable接口
FutureTask+Callable
1.3.1、普通类实现Callable接口
public class StatScore implements Callable<Double> {
@Override
public Double call() throws Exception {
//统计分数的逻辑
return 88.98;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
StatScore statScore = new StatScore();
//跟FutureTask 关联上
FutureTask<Double> doubleFutureTask = new FutureTask<>(statScore);
//跟Thread关联上
Thread thread = new Thread(doubleFutureTask);
thread.start();
log.info(String.valueOf(doubleFutureTask.get()));
}
1.3.2、扩展Lambda表达式
public class StatScore {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Order order = new Order();
order.setOrderId(100);
order.setPayStatus(1);
order.setOrderTime( "2023-05-31");
order.setOrderId(1001);
order.setUserId(10001);
FutureTask<List<Order>> doubleFutureTask = new FutureTask<>( ()-> {
// 获取订单列表
List<Order> orderList = new ArrayList<>();
orderList.add(order);
Thread.sleep(3000);
System.out.println("return list");
return orderList;
});
//跟Thread关联上
Thread thread = new Thread(doubleFutureTask);
thread.start();
try {
System.out.println( doubleFutureTask.get(500 , TimeUnit.MILLISECONDS) );
} catch (TimeoutException e) {
System.out.println("获取订单列表接口超时");
}
System.out.println("------------------------end------------------------------");
}
}
2、线程池
线程池就是存放线程的池子,池子里存放了很多可以复用的线程。
使用线程池的优势
- 提高效率,创建好一定数量的线程放在池中,等需要使用的时候就从池中拿一个,这要比需要的时候创建一个线程对象要快的多。
- 减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
- 提升系统响应速度,假如创建线程用的时间为T1,执行任务用的时间为T2,销毁线程用的时间为T3,那么使用线程池就免去了T1和T3的时间;
2.1、五种创建线程的方式
//创建一个单线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
ExecutorService executorService = Executors.newSingleThreadExecutor();
//创建一个定长的线程池,可控制最大并发数,超出的线程进行队列等待。 ExecutorService executorService =
Executors.newFixedThreadPool(2); //可以创建定长的、支持定时任务,周期任务执行。
ExecutorService executorService = Executors.newScheduledThreadPool(2);
//创建一个可以缓存的线程池,如果线程池长度超过处理需要,可以灵活回收空闲线程,没回收的话就新建线程 ExecutorService
executorService = Executors.newCachedThreadPool(); //创建一个具有抢占式操作的线程池
ExecutorService executorService = Executors.newWorkStealingPool();
2.2、new ThreadPoolExecutor()创建线程
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数说明:
参数 | 含义 | 解释 |
---|---|---|
corePoolSize | 该线程池中核心线程数最大值 | 核心线程生命周期无限,即使空闲也不会死亡 |
maximumPoolSize | 线程总数最大值 | 任务队列满了以后当有新任务进来则会增加一个线程来处理新任务(线程总数<maximumPoolSize ) |
keepAliveTime | 闲置超时时间 | 当线程数大于核心线程数时,超过keepAliveTime时间将会回收非核心线程 |
unit | keepAliveTime 的单位 | |
workQueue | 线程池中的任务队列 | * |
threadFactory | 为线程池提供创建新线程的线程工厂 | * |
RejectedExecutionHandler | 饱和策略 | 抛出异常专用,当队列和最大线程池都满了之后的饱和策略。 |
2.2.1、拒绝策略
ThreadPoolExecutor的饱和策略可以通过调用setRejectedExecutionHandler来修改。JDK提供了几种不同的RejectedExecutionHandler实现,每种实现都包含有不同的饱和策略:AbortPolicy、CallerRunsPolicy、DiscardPolicy和DiscardOldestPolicy。
拒绝策略如下:
- CallerRunsPolicy : 调用线程处理任务
- AbortPolicy : 抛出异常
- DiscardPolicy : 直接丢弃
- DiscardOldestPolicy : 丢弃队列中最老的任务,执行新任务
RejectedExecutionHandler rejected = null;
//默认策略,阻塞队列满,则丢任务、抛出异常
rejected = new ThreadPoolExecutor.AbortPolicy();
//阻塞队列满,则丢任务,不抛异常
rejected = new ThreadPoolExecutor.DiscardPolicy();
//删除队列中最旧的任务(最早进入队列的任务),尝试重新提交新的任务
rejected = new ThreadPoolExecutor.DiscardOldestPolicy();
//队列满,不丢任务,不抛异常,若添加到线程池失败,那么主线程会自己去执行该任务
rejected = new ThreadPoolExecutor.CallerRunsPolicy();
总结: 就是被拒绝的任务,直接在主线程中运行,不再进入线程池。
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符,请联系我的编程经验分享网邮箱:veading@qq.com进行投诉反馈,一经查实,立即删除!