java springboot线程池以及多线程

线程和进程

进程是资源分配的最小单位，线程是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

使用线程池实现异步

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.Executor;

/**
 * 使用demo
 * @author lipeiguang
 */
@Slf4j
@Api(tags = {"异步线程测试"})
@RestController
public class ExecutorDemo {
    //使用时通过注解
    /**
     * 如果是多线程，可以直接使用这个executor
     */
    @Resource(name = TaskExecutorConstant.SALARY_TASK_EXECUTOR)
    private Executor executor;

    @Autowired
    private ServiceDemo serviceDemo;

    @ApiOperation("异步测试")
    @GetMapping("/test/async")
    public String testAsync(){
        log.info("主线程开始执行。。。。");
        serviceDemo.async();
        log.info("主线程结束执行。。。。");
        return "success";
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

/**
 * @author lipeiguang
 */
@Service
@Slf4j
public class ServiceDemo {
    /**
     * 如果只是想异步执行，也可以通过如下注解
     */
    @Async(TaskExecutorConstant.SALARY_TASK_EXECUTOR)
    public void async() {
        log.info("异步线程开始执行。。。");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("异步线程执行结束。。。");
    }
}

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

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

测试类：

@Test
    public void testAsyncThreads(){
        log.info("主线程开始执行----------------");
        long start = System.currentTimeMillis();
        taskService.completeWork();
        log.info("主线程结束执行----------------,总耗时：{}ms",(System.currentTimeMillis()-start));
    }

具体多线程处理方法：

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;

/**
 * @author lipeiguang
 */
@Slf4j
@Service
public class TaskService {
    @Autowired
    private Executor executor;

    public void completeWork(){
        int threads = 10;
        List<Boolean> list = new ArrayList<>(threads);
        CountDownLatch countDownLatch = new CountDownLatch(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 boolean buildHouse(){
        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,耗时：2000ms
2020-10-02 11:52:12.250  INFO 39124 --- [  SalaryAsync-8] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-8,耗时：2000ms
2020-10-02 11:52:12.250  INFO 39124 --- [  SalaryAsync-5] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-5,耗时：2000ms
2020-10-02 11:52:12.250  INFO 39124 --- [  SalaryAsync-6] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-6,耗时：2000ms
2020-10-02 11:52:12.250  INFO 39124 --- [  SalaryAsync-2] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-2,耗时：2000ms
2020-10-02 11:52:12.251  INFO 39124 --- [  SalaryAsync-3] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-3,耗时：2000ms
2020-10-02 11:52:12.251  INFO 39124 --- [  SalaryAsync-9] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-9,耗时：2000ms
2020-10-02 11:52:12.251  INFO 39124 --- [  SalaryAsync-1] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-1,耗时：2000ms
2020-10-02 11:52:12.251  INFO 39124 --- [  SalaryAsync-7] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-7,耗时：2000ms
2020-10-02 11:52:12.251  INFO 39124 --- [  SalaryAsync-4] com.example.demo.service.TaskService     : 结束盖房子，当前线程：SalaryAsync-4,耗时：2000ms
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.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.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.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.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.service.TaskService     : 执行结果:true
2020-10-02 11:52:12.251  INFO 39124 --- [           main] com.example.demo.DemoApplicationTests    : 主线程结束执行----------------,总耗时：2007ms

本文链接：https://www.cnblogs.com/lipg/p/13760812.html

java springboot线程池以及多线程

线程和进程

多线程

应用场景

线程池

什么是线程池

为什么要用线程池

实现方式

使用线程池实现异步

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

java springboot线程池以及多线程的更多相关文章

随机推荐

热门专题

目录导航