java 线程 spring_java springboot线程池以及多线程

最新推荐文章于 2023-04-19 23:47:29 发布

创新先锋

最新推荐文章于 2023-04-19 23:47:29 发布

阅读量102

点赞数

文章标签： java 线程 spring

本文链接：https://blog.csdn.net/weixin_29612723/article/details/114431099

版权

本文介绍了线程与进程的区别，多线程的应用场景，以及为何使用线程池。通过SpringBoot展示了如何配置和使用线程池，并提供了线程池参数设置的参考建议。此外，还演示了线程池实现异步和多线程操作的代码实例，以CountDownLatch为例展示了多线程同步的方法。

摘要由CSDN通过智能技术生成

线程和进程

进程是资源分配的最小单位，线程是CPU调度的最小单位。

是不是很抽象，做个简单比喻，进程=火车，线程=车厢，线程在进程里运行(单个的车厢是无法运行的)；不同进程之间数据很难共享，同一进程下的线程数据共享则很容易。

多线程

一个应用程序有多条执行路径(单线程：一个应用程序只有一条执行路径)。

应用场景

异步，有些功能无需同步执行，可以使用另外一个线程去执行。

多个线程共同完成一个事情，缩短整体执行时间，同时cpu也得到了充分利用(例如，盖房子垒墙，一个人需要10天，10个人同时做，1天左右可以完成)。

线程池

什么是线程池

线程池，顾名思义，是存放了一堆线程的池子/容器，并且管理线程的整个生命周期。

java.util.concurrent.Executors提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。

为什么要用线程池

减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

实现方式

此处以springboot实现方式为例

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.annotation.EnableAsync;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

import java.util.concurrent.ThreadPoolExecutor;

/**

* @author lipeiguang

@Configuration

@EnableAsync

public class ThreadPoolConfig {

@Bean(name = "executor")

public Executor getAsyncThread() {

ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();

//线程池维护线程的最少数量

taskExecutor.setCorePoolSize(5);

//线程池维护线程的最大数量,只有在缓冲队列满了之后才会申请超过核心线程数的线程

taskExecutor.setMaxPoolSize(10);

//缓存队列

taskExecutor.setQueueCapacity(20);

//允许的空闲时间,当超过了核心线程出之外的线程在空闲时间到达之后会被销毁

taskExecutor.setKeepAliveSeconds(200);

//线程名称前缀

taskExecutor.setThreadNamePrefix("my-thread-");

// 线程池对拒绝任务(无线程可用)的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者

taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 调度器shutdown被调用时等待当前被调度的任务完成

taskExecutor.setWaitForTasksToCompleteOnShutdown(true);

// 等待时长

taskExecutor.setAwaitTerminationSeconds(60);

taskExecutor.initialize();

return taskExecutor;

}

其中的corePoolSize设置参考：

N为cpu个数

如果是CPU密集型应用，则线程池大小设置为N+1

如果是IO密集型应用，则线程池大小设置为2N+1

cpu个数查询方式：

Runtime.getRuntime().availableProcessors()；

linux查询方式：

cat /proc/cpuinfo| grep "processor"| wc -l

使用线程池实现异步

importio.swagger.annotations.Api;importio.swagger.annotations.ApiOperation;importlombok.extern.slf4j.Slf4j;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.web.bind.annotation.GetMapping;importorg.springframework.web.bind.annotation.RestController;importjavax.annotation.Resource;importjava.util.concurrent.Executor;/*** 使用demo

*@authorlipeiguang*/@Slf4j

@Api(tags= {"异步线程测试"})

@RestControllerpublic classExecutorDemo {//使用时通过注解

/*** 如果是多线程，可以直接使用这个executor*/@Resource(name=TaskExecutorConstant.SALARY_TASK_EXECUTOR)privateExecutor executor;

@AutowiredprivateServiceDemo serviceDemo;

@ApiOperation("异步测试")

@GetMapping("/test/async")publicString testAsync(){

log.info("主线程开始执行。。。。");

serviceDemo.async();

log.info("主线程结束执行。。。。");return "success";

}

importlombok.extern.slf4j.Slf4j;importorg.springframework.scheduling.annotation.Async;importorg.springframework.stereotype.Service;/***@authorlipeiguang*/@Service

@Slf4jpublic classServiceDemo {/*** 如果只是想异步执行，也可以通过如下注解*/@Async(TaskExecutorConstant.SALARY_TASK_EXECUTOR)public voidasync() {

log.info("异步线程开始执行。。。");try{

Thread.sleep(10000);

}catch(InterruptedException e) {

e.printStackTrace();

}

log.info("异步线程执行结束。。。");

}

使用线程池实现多线程操作

实现方式有很多种，比如：CountDownLatch，CyclicBarrier，CompletionService等，此处使用CountDownLatch。

测试类：

@Testpublic voidtestAsyncThreads(){

log.info("主线程开始执行----------------");long start =System.currentTimeMillis();

taskService.completeWork();

log.info("主线程结束执行----------------,总耗时：{}ms",(System.currentTimeMillis()-start));

}

具体多线程处理方法：

importlombok.extern.slf4j.Slf4j;importorg.springframework.beans.factory.annotation.Autowired;importorg.springframework.stereotype.Service;importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.CountDownLatch;importjava.util.concurrent.Executor;/***@authorlipeiguang*/@Slf4j

@Servicepublic classTaskService {

@AutowiredprivateExecutor executor;public voidcompleteWork(){int threads = 10;

List list = new ArrayList<>(threads);

CountDownLatch countDownLatch= newCountDownLatch(threads);for(int i = 0; i < threads; i++){

executor.execute(()->{boolean b =buildHouse();

list.add(b);

countDownLatch.countDown();

});

}try{

countDownLatch.await();

}catch(InterruptedException e) {

e.printStackTrace();

}

list.forEach(x->{

log.info("执行结果:{}",x);

});

}public booleanbuildHouse(){

log.info("开始盖房子，当前线程：{}",Thread.currentThread().getName());try{int i = 2000;

Thread.sleep(i);

log.info("结束盖房子，当前线程：{},耗时：{}ms",Thread.currentThread().getName(),i);return true;

}catch(InterruptedException e) {

log.info("结束盖房子，当前线程：{}",Thread.currentThread().getName());return false;

}

执行日志如下：

2020-10-02 11:52:10.244 INFO 39124 --- [ main] com.example.demo.DemoApplicationTests : 主线程开始执行----------------

2020-10-02 11:52:10.246 INFO 39124 --- [ SalaryAsync-2] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-2

2020-10-02 11:52:10.247 INFO 39124 --- [ SalaryAsync-8] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-8

2020-10-02 11:52:10.246 INFO 39124 --- [ SalaryAsync-5] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-5

2020-10-02 11:52:10.247 INFO 39124 --- [ SalaryAsync-10] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-10

2020-10-02 11:52:10.247 INFO 39124 --- [ SalaryAsync-6] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-6

2020-10-02 11:52:10.246 INFO 39124 --- [ SalaryAsync-3] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-3

2020-10-02 11:52:10.246 INFO 39124 --- [ SalaryAsync-1] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-1

2020-10-02 11:52:10.247 INFO 39124 --- [ SalaryAsync-7] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-7

2020-10-02 11:52:10.248 INFO 39124 --- [ SalaryAsync-9] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-9

2020-10-02 11:52:10.246 INFO 39124 --- [ SalaryAsync-4] com.example.demo.service.TaskService : 开始盖房子，当前线程：SalaryAsync-4

2020-10-02 11:52:12.250 INFO 39124 --- [ SalaryAsync-10] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-10,耗时：2000ms2020-10-02 11:52:12.250 INFO 39124 --- [ SalaryAsync-8] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-8,耗时：2000ms2020-10-02 11:52:12.250 INFO 39124 --- [ SalaryAsync-5] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-5,耗时：2000ms2020-10-02 11:52:12.250 INFO 39124 --- [ SalaryAsync-6] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-6,耗时：2000ms2020-10-02 11:52:12.250 INFO 39124 --- [ SalaryAsync-2] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-2,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ SalaryAsync-3] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-3,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ SalaryAsync-9] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-9,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ SalaryAsync-1] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-1,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ SalaryAsync-7] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-7,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ SalaryAsync-4] com.example.demo.service.TaskService : 结束盖房子，当前线程：SalaryAsync-4,耗时：2000ms2020-10-02 11:52:12.251 INFO 39124 --- [ main] com.example.demo.service.TaskService : 执行结果:true

2020-10-02 11:52:12.251 INFO 39124 --- [ main] com.example.demo.service.TaskService : 执行结果:true

2020-10-02 11:52:12.251 INFO 39124 --- [ main] com.example.demo.DemoApplicationTests : 主线程结束执行----------------,总耗时：2007ms

创新先锋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 线程 spring_java springboot线程池以及多线程

线程和进程进程是资源分配的最小单位，线程是CPU调度的最小单位。是不是很抽象，做个简单比喻，进程=火车，线程=车厢，线程在进程里运行(单个的车厢是无法运行的)；不同进程之间数据很难共享，同一进程下的线程数据共享则很容易。多线程一个应用程序有多条执行路径(单线程：一个应用程序只有一条执行路径)。应用场景异步，有些功能无需同步执行，可以使用另外一个线程去执行。多个线程共同完成一个事情，缩短整体执行时间...
复制链接

扫一扫