Java异步子线程读取主线程参数的若干好玩场景

leehao

发布于 2025-02-11 11:09:41

8000

代码可运行

文章被收录于专栏：leehaoleehao

运行总次数：0

代码可运行

在开发过程中，我们难免会因为性能、实时响应等，需要异步处理的一些事务，并且在子线程中有时我们还需要获取主线程相关的参数。下面有若干方案可以实现上述场景，但会出现一定的问题。

场景1-基础场景

在主线程中开启子线程，在子线程中获取主线程的参数。重点：子线程中逻辑处理时间较短，在主线程结束前获取主线程的参数。

package com.lihao.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author lihao
 */
@RestController
@RequestMapping("/test1")
public class Test1 {

    /**
     * 自定义线程池
     */
    private ExecutorService executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors(),
            5,
            TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(100),
            Thread::new,
            new ThreadPoolExecutor.AbortPolicy());

    @GetMapping("/asyncTest")
    public String asyncTest(HttpServletRequest request) {
        request.setAttribute("key1","value1");
        // 异步处理任务
        executor.submit(
                () -> doExe(request)
        );
        return "OK";
    }

    public void doExe(HttpServletRequest request){
        System.out.println("值：" + request.getAttribute("key1"));
    }
}

执行结果：

值：value1

我们可以正常拿到主线程的参数。

场景2-场景1的变种

在主线程中开启子线程，在子线程中获取主线程的参数。重点：子线程在执行一段时间后再获取主线程的参数，这个时候主线程已执行完成了。

    @GetMapping("/asyncTest")
    public String asyncTest(HttpServletRequest request) {
        request.setAttribute("key1","value1");
        // 异步处理任务
        executor.submit(
                () -> doExe(request,1000L)
        );
        return "OK";
    }

    public void doExe(HttpServletRequest request,long sleepTime){
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("值：" + request.getAttribute("key1"));
    }

执行结果：

值：null

由于子线程sleep了一秒，这个时候主线程已经执行完成，子线程如果想继续获取主线程的参数，就会拿不到值。

场景3-场景1的完善

在主线程中开启子线程，在子线程中获取主线程的参数。重点：子线程在执行一段时间后再获取主线程的参数，主线程需要等待子线程执行完成后，再结束。

    @GetMapping("/asyncTest")
    public String asyncTest(HttpServletRequest request) {
        request.setAttribute("key1","value1");
        // 异步处理任务
        Future<?> future = executor.submit(
                () -> doExe(request, 10000L)
        );
        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
        return "OK";
    }

    public void doExe(HttpServletRequest request,long sleepTime){
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("值：" + request.getAttribute("key1"));
    }

虽然子线程执行时间较长，但仍可以获取主线程的参数，主线程在子线程执行完成后再结束。主要技术：通过future.get();来使主线程阻塞。缺点：主线程等待时间较长，消息无法实时返回，需要等待子线程执行完成后再返回。

场景4-场景1、2、3的优化

在主线程中开启子线程，在子线程中获取主线程的参数。重点：子线程在执行一段时间后再获取主线程的参数，主线程无需要等待子线程执行完成，可立即结束。

    @GetMapping("/asyncTest")
    public String asyncTest(HttpServletRequest request) {
        request.setAttribute("key1","value1");

        // 开启异步
        AsyncContext asyncContext = request.startAsync();
        executor.submit(
                () -> doExe(asyncContext,request, 10000L)
        );
        return "OK";
    }

    public void doExe(AsyncContext asyncContext,HttpServletRequest request,long sleepTime){
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("值：" + request.getAttribute("key1"));
        asyncContext.complete();
    }

虽然子线程执行时间较长，但仍可以获取主线程的参数，主线程无需等待子线程执行完成，可立即返回。

核心技术点：