SpringBoot异步线程父子线程数据传递的5种方式

于 2024-08-04 22:27:11 发布
阅读量937 收藏 13
点赞数 6
分类专栏： spring boot 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30614345/article/details/137044515
版权

SpringBoot异步线程父子线程数据传递的5种方式

1、ThreadLocal+TaskDecorator

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

/**
 * @author tom
 * 使用ThreadLocal存储共享的数据变量，如登录的用户信息
 */
public class UserUtils {

    private static final ThreadLocal<String> userLocal = new ThreadLocal<>();

    public static String getUserId() {
        return userLocal.get();
    }

    public static void setUserId(String userId) {
        userLocal.set(userId);
    }

    public static void clear() {
        userLocal.remove();
    }

}

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

import org.springframework.core.task.TaskDecorator;

/**
 * @author tom
 * 线程池修饰类
 */
public class CustomTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 获取主线程中的请求信息(我们的用户信息也放在里面)
        String robotId = UserUtils.getUserId();
        return () -> {
            try {
                // 将主线程的请求信息,设置到子线程中
                UserUtils.setUserId(robotId);
                // 执行子线程,这一步不要忘了
                runnable.run();
            } finally {
                // 线程结束,清空这些信息,否则可能造成内存泄漏
                UserUtils.clear();
            }
        };
    }
}

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class VisibleThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private void showThreadPoolInfo(String prefix) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
        if (null == threadPoolExecutor) {
            return;
        }
        log.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]", this.getThreadNamePrefix(), prefix, threadPoolExecutor.getTaskCount(), threadPoolExecutor.getCompletedTaskCount(), threadPoolExecutor.getActiveCount(), threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class ExecutorConfig {

    @Bean(name = "asyncServiceExecutor1")
    public Executor asyncServiceExecutor() {
        log.info("start asyncServiceExecutor------------");
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用可视化运行状态的线程池
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        // 配置核心线程数
        executor.setCorePoolSize(2);
        // 配置最大线程数
        executor.setMaxPoolSize(2);
        // 配置队列大小
        executor.setQueueCapacity(60);
        // 配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("my-thread");
        // rejection-policy: 当pool已经达到max size的时候,如何处理新任务
        // CALLER_RUNS: 不在新线程中执行任务,而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 增加线程池修饰类
        executor.setTaskDecorator(new CustomTaskDecorator());
        // 执行初始化
        executor.initialize();
        log.info("end asyncServiceExecutor------------");
        return executor;
    }
}

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

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

import java.util.concurrent.CompletableFuture;

/**
 * @author tom
 */
@Slf4j
@Service("asyncServiceImpl1")
public class AsyncServiceImpl {

    /**
     * 使用ThreadLocal方式传递
     * 带有返回值
     *
     * @throws InterruptedException
     */
    @Async("asyncServiceExecutor1")
    public CompletableFuture<String> executeValueAsync1() {
        log.info("start executeValueAsync");
        System.out.println("异步线程执行返回结果......");
        log.info("end executeValueAsync");
        return CompletableFuture.completedFuture(UserUtils.getUserId());
    }

}

package com.example.parentchildthreadspassingdata.threadLocal_taskDecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author tom
 */
@Slf4j
@RestController
public class Test1Controller {

    private AsyncServiceImpl asyncService;

    @Autowired
    @Qualifier(value = "asyncServiceImpl1")
    public void setAsyncService(AsyncServiceImpl asyncService) {
        this.asyncService = asyncService;
    }

    /**
     * 使用ThreadLocal+TaskDecorator的方式
     *
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @GetMapping("/test1")
    public String test1() throws ExecutionException, InterruptedException {
        UserUtils.setUserId("123456");
        CompletableFuture<String> completableFuture = asyncService.executeValueAsync1();
        String s = completableFuture.get();
        log.info("result {}", s);
        return s;
    }
}

2、RequestContextHolder+TaskDecorator

package com.example.parentchildthreadspassingdata.requestcontextholder_taskdecorator;

import org.springframework.core.task.TaskDecorator;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

/**
 * @author tom
 * 线程池修饰类
 */
public class CustomTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 获取主线程中的请求信息(我们的用户信息也放在里面)
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return () -> {
            try {
                // 将主线程的请求信息,设置到子线程中
                RequestContextHolder.setRequestAttributes(attributes);
                // 执行子线程,这一步不要忘了
                runnable.run();
            } finally {
                // 线程结束,清空这些信息,否则可能造成内存泄漏
                RequestContextHolder.resetRequestAttributes();
            }
        };
    }
}

package com.example.parentchildthreadspassingdata.requestcontextholder_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class VisibleThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private void showThreadPoolInfo(String prefix) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
        if (null == threadPoolExecutor) {
            return;
        }
        log.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]", this.getThreadNamePrefix(), prefix, threadPoolExecutor.getTaskCount(), threadPoolExecutor.getCompletedTaskCount(), threadPoolExecutor.getActiveCount(), threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}

package com.example.parentchildthreadspassingdata.requestcontextholder_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class ExecutorConfig {

    @Bean(name = "asyncServiceExecutor2")
    public Executor asyncServiceExecutor() {
        log.info("start asyncServiceExecutor------------");
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用可视化运行状态的线程池
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        // 配置核心线程数
        executor.setCorePoolSize(2);
        // 配置最大线程数
        executor.setMaxPoolSize(2);
        // 配置队列大小
        executor.setQueueCapacity(60);
        // 配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("my-thread");
        // rejection-policy: 当pool已经达到max size的时候,如何处理新任务
        // CALLER_RUNS:不在新线程中执行任务,而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //增加线程池修饰类
        executor.setTaskDecorator(new CustomTaskDecorator());
        // 执行初始化
        executor.initialize();
        log.info("end asyncServiceExecutor------------");
        return executor;
    }
}

package com.example.parentchildthreadspassingdata.requestcontextholder_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import java.util.concurrent.CompletableFuture;

/**
 * @author tom
 */
@Slf4j
@Service("asyncServiceImpl2")
public class AsyncServiceImpl {

    /**
     * 使用RequestAttributes获取主线程传递的数据
     *
     * @return
     * @throws InterruptedException
     */
    @Async("asyncServiceExecutor2")
    public CompletableFuture<String> executeValueAsync2(){
        log.info("start executeValueAsync");
        System.out.println("异步线程执行返回结果......");
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        Object userId = attributes.getAttribute("userId", 0);
        log.info("end executeValueAsync");
        return CompletableFuture.completedFuture(userId.toString());
    }

}

package com.example.parentchildthreadspassingdata.requestcontextholder_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author tom
 */
@Slf4j
@RestController
public class Test2Controller {

    private AsyncServiceImpl asyncService;

    @Autowired
    @Qualifier(value = "asyncServiceImpl2")
    public void setAsyncService(AsyncServiceImpl asyncService) {
        this.asyncService = asyncService;
    }

    /**
     * RequestContextHolder+TaskDecorator的方式
     *
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @GetMapping("/test2")
    public String test2() throws InterruptedException, ExecutionException {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        attributes.setAttribute("userId", "123456", 0);
        CompletableFuture<String> completableFuture = asyncService.executeValueAsync2();
        String s = completableFuture.get();
        log.info("result {}", s);
        return s;
    }
}

3、MDC+TaskDecorator

package com.example.parentchildthreadspassingdata.mdc_taskdecorator;

import org.slf4j.MDC;
import org.springframework.core.task.TaskDecorator;

/**
 * @author tom
 * 线程池修饰类
 */
public class MdcTaskDecorator implements TaskDecorator {

    @Override
    public Runnable decorate(Runnable runnable) {
        // 获取主线程中的请求信息(我们的用户信息也放在里面)
        String userId = MDC.get("userId");
        return () -> {
            try {
                // 将主线程的请求信息,设置到子线程中
                MDC.put("userId", userId);
                // 执行子线程,这一步不要忘了
                runnable.run();
            } finally {
                // 线程结束,清空这些信息,否则可能造成内存泄漏
                MDC.clear();
            }
        };
    }
}

package com.example.parentchildthreadspassingdata.mdc_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class VisibleThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private void showThreadPoolInfo(String prefix) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
        if (null == threadPoolExecutor) {
            return;
        }
        log.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]", this.getThreadNamePrefix(), prefix, threadPoolExecutor.getTaskCount(), threadPoolExecutor.getCompletedTaskCount(), threadPoolExecutor.getActiveCount(), threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}

package com.example.parentchildthreadspassingdata.mdc_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class ExecutorConfig {

    @Bean(name = "asyncServiceExecutor3")
    public Executor asyncServiceExecutor() {
        log.info("start asyncServiceExecutor------------");
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用可视化运行状态的线程池
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        // 配置核心线程数
        executor.setCorePoolSize(2);
        // 配置最大线程数
        executor.setMaxPoolSize(2);
        // 配置队列大小
        executor.setQueueCapacity(60);
        // 配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("my-thread");
        // rejection-policy: 当pool已经达到max size的时候,如何处理新任务
        // CALLER_RUNS: 不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //增加MDC的线程池修饰类
        executor.setTaskDecorator(new MdcTaskDecorator());
        //执行初始化
        executor.initialize();
        log.info("end asyncServiceExecutor------------");
        return executor;
    }
}

package com.example.parentchildthreadspassingdata.mdc_taskdecorator;

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

import java.util.concurrent.CompletableFuture;

/**
 * @author tom
 */
@Slf4j
@Service("asyncServiceImpl3")
public class AsyncServiceImpl {

    /**
     * 使用MDC获取主线程传递的数据
     *
     * @return
     * @throws InterruptedException
     */
    @Async("asyncServiceExecutor3")
    public CompletableFuture<String> executeValueAsync3() {
        log.info("start executeValueAsync");
        System.out.println("异步线程执行返回结果......");
        log.info("end executeValueAsync");
        return CompletableFuture.completedFuture(MDC.get("userId"));
    }
}

package com.example.parentchildthreadspassingdata.mdc_taskdecorator;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.MDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author tom
 */
@Slf4j
@RestController
public class Test3Controller {

    private AsyncServiceImpl asyncService;

    @Autowired
    @Qualifier(value = "asyncServiceImpl3")
    public void setAsyncService(AsyncServiceImpl asyncService) {
        this.asyncService = asyncService;
    }

    /**
     * 使用MDC+TaskDecorator方式
     * 本质也是ThreadLocal+TaskDecorator方式
     *
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @GetMapping("/test3")
    public String test3() throws InterruptedException, ExecutionException {
        MDC.put("userId", "123456");
        CompletableFuture<String> completableFuture = asyncService.executeValueAsync3();
        String s = completableFuture.get();
        log.info("result {}", s);
        return s;
    }
}

4、InheritableThreadLocal

package com.example.parentchildthreadspassingdata.inheritablethreadlocal;

/**
 * @author tom
 * 使用InheritableThreadLocal存储线程之间共享的数据变量，如登录的用户信息
 */
public class UserInheritableUtils {

    private static final InheritableThreadLocal<String> userLocal = new InheritableThreadLocal<>();

    public static String getUserId() {
        return userLocal.get();
    }

    public static void setUserId(String userId) {
        userLocal.set(userId);
    }

    public static void clear() {
        userLocal.remove();
    }

}

package com.example.parentchildthreadspassingdata.inheritablethreadlocal;

import com.example.parentchildthreadspassingdata.mdc_taskdecorator.VisibleThreadPoolTaskExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class ExecutorConfig {

    @Bean(name = "asyncServiceExecutor4")
    public Executor asyncServiceExecutor() {
        log.info("start asyncServiceExecutor------------");
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用可视化运行状态的线程池
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        // 配置核心线程数
        executor.setCorePoolSize(2);
        // 配置最大线程数
        executor.setMaxPoolSize(2);
        // 配置队列大小
        executor.setQueueCapacity(60);
        // 配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("my-thread");
        // rejection-policy: 当pool已经达到max size的时候,如何处理新任务
        // CALLER_RUNS: 不在新线程中执行任务,而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
        log.info("end asyncServiceExecutor------------");
        return executor;
    }
}

package com.example.parentchildthreadspassingdata.inheritablethreadlocal;

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

import java.util.concurrent.CompletableFuture;

/**
 * @author
 */
@Slf4j
@Service("asyncServiceImpl4")
public class AsyncServiceImpl {

    /**
     * 使用InheritableThreadLocal获取主线程传递的数据
     *
     * @return
     * @throws InterruptedException
     */
    @Async("asyncServiceExecutor4")
    public CompletableFuture<String> executeValueAsync4() {
        log.info("start executeValueAsync");
        System.out.println("异步线程执行返回结果......");
        log.info("end executeValueAsync");
        return CompletableFuture.completedFuture(UserInheritableUtils.getUserId());
    }
}

package com.example.parentchildthreadspassingdata.inheritablethreadlocal;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author tom
 */
@Slf4j
@RestController
public class Test4Controller {

    private AsyncServiceImpl asyncService;

    @Autowired
    @Qualifier(value = "asyncServiceImpl4")
    public void setAsyncService(AsyncServiceImpl asyncService) {
        this.asyncService = asyncService;
    }

    /**
     * 使用InheritableThreadLocal方式
     *
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @GetMapping("/test4")
    public String test4() throws InterruptedException, ExecutionException {
        UserInheritableUtils.setUserId("123456");
        CompletableFuture<String> completableFuture = asyncService.executeValueAsync4();
        String s = completableFuture.get();
        log.info("result {}", s);
        return s;
    }
}

5、TransmittableThreadLocal

package com.example.parentchildthreadspassingdata.transmittablethreadlocal;

import com.alibaba.ttl.TransmittableThreadLocal;

/**
 * @author tom
 * 使用TransmittableThreadLocal存储线程之间共享的数据变量,如登录的用户信息
 */
public class UserTransmittableUtils {

    private static final TransmittableThreadLocal<String> userLocal = new TransmittableThreadLocal<>();

    public static String getUserId() {
        return userLocal.get();
    }

    public static void setUserId(String userId) {
        userLocal.set(userId);
    }

    public static void clear() {
        userLocal.remove();
    }
}

package com.example.parentchildthreadspassingdata.transmittablethreadlocal;

import com.example.parentchildthreadspassingdata.mdc_taskdecorator.VisibleThreadPoolTaskExecutor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author tom
 */
@Slf4j
public class ExecutorConfig {

    @Bean(name = "asyncServiceExecutor5")
    public Executor asyncServiceExecutor() {
        log.info("start asyncServiceExecutor------------");
        // ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 使用可视化运行状态的线程池
        ThreadPoolTaskExecutor executor = new VisibleThreadPoolTaskExecutor();
        // 配置核心线程数
        executor.setCorePoolSize(2);
        // 配置最大线程数
        executor.setMaxPoolSize(2);
        // 配置队列大小
        executor.setQueueCapacity(60);
        // 配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("my-thread");
        // rejection-policy:当pool已经达到max size的时候,如何处理新任务
        // CALLER_RUNS: 不在新线程中执行任务,而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 执行初始化
        executor.initialize();
        log.info("end asyncServiceExecutor------------");
        return executor;
    }
}

package com.example.parentchildthreadspassingdata.transmittablethreadlocal;

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

import java.util.concurrent.CompletableFuture;

/**
 * @author tom
 */
@Slf4j
@Service("asyncServiceImpl5")
public class AsyncServiceImpl {

    /**
     * 使用TransmittableThreadLocal获取主线程传递的数据
     *
     * @return
     * @throws InterruptedException
     */
    @Async("asyncServiceExecutor5")
    public CompletableFuture<String> executeValueAsync5() {
        log.info("start executeValueAsync");
        System.out.println("异步线程执行返回结果......");
        log.info("end executeValueAsync");
        return CompletableFuture.completedFuture(UserTransmittableUtils.getUserId());
    }
}

package com.example.parentchildthreadspassingdata.transmittablethreadlocal;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * @author tom
 */
@RestController
@Slf4j
public class Test5Controller {

    private AsyncServiceImpl asyncService;

    @Autowired
    @Qualifier(value = "asyncServiceImpl5")
    public void setAsyncService(AsyncServiceImpl asyncService) {
        this.asyncService = asyncService;
    }

    /**
     * 使用TransmittableThreadLocal方式
     *
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @GetMapping("/test5")
    public String test5() throws InterruptedException, ExecutionException {
        UserTransmittableUtils.setUserId("123456");
        CompletableFuture<String> completableFuture = asyncService.executeValueAsync5();
        String s = completableFuture.get();
        log.info("result {}", s);
        return s;
    }
}

5、方案对比

方案1，方案2，方案3主要是借助 TaskDecorator 进行父子线程之间传递数据。其中 MDC 方案主要借鉴于 MDC

的日志跟踪的思想来实现。

方案4和方案5使用 InheritableThreadLocal 和 TransmittableThreadLocal 来实现，其中

TransmittableThreadLocal 是阿里 InheritableThreadLocal 进行优化封装。

本人推荐使用方案5。

242030
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#多线程传递参数及任务用法示例
01-20
总的来说，C#中的多线程和任务机制提供了一种高效的方式来并发执行操作。通过传递参数给线程或任务，我们可以定制每个线程或任务的行为。在实际应用中，需要注意线程安全和同步问题，避免竞态条件和死锁的发生。了解...
用这4招 优雅的实现Spring Boot 异步线程间数据传递
竹林幽深
09-22 572
上述列举了4种方案，陈某这里推荐方案2和方案4，其中两种方案的缺点非常明显，实际开发中也是采用的方案2或者方案4另外陈某的知识星球开通了，加入只需199元，星球回馈的价值巨大，目前更新了码猿慢病云管理实战项目、Spring全家桶实战系列、亿级数据分库分表实战、DDD微服务实战专栏、我要进大厂、Spring，Mybatis等框架源码、架构实战22讲、精尽RocketMQ等....更多介绍。
父子线程如何共享数据？
最新发布
qq_30064799的博客
01-25 608
使用InheritableThreadLocal类。
【并发编程】（十一）父子线程数据共享——InheritableThreadLocal原理
积木成林，聚沙成塔
03-03 4455
文章目录1.InheritableThreadLocal的作用1.1.父子线程的定义2.父线程向子线程传递数据2.1.InheritableThreadLocal的使用.2.2.父子线程数据共享的实现原理2.2.1.InheritableThreadLocal类2.2.2.如何实现数据共享2.2.3.childValue()方法3.线程池中的线程数据传递失效 1.InheritableThreadLocal的作用 在前面的博客《线程安全的代码及ThreadLocal的使用》中说到了ThreadLocal可以
springBoot异步线程，父子线程数据传递的5种姿势
m0_73311735的博客
09-16 1425
上面的的方案你学会了么。
SpringBoot父子线程数据共享问题解决方案
weixin_52195362的博客
01-29 1889
SpringBoot父子线程数据共享
【Java】子线程共享父线程数据
qq_53070263的博客
02-20 855
使用InheritableThreadLocal来实现子线程访问父线程的局部变量
Python中进程和线程的区别详解
09-21
- **交互**：同一进程内的线程可以直接访问彼此的数据；不同进程间通信需要通过中间媒介。 #### 五、常见概念解析 1. **并发与并行**： - **并发**：多个任务看似同时进行，实际上是由CPU快速切换执行的结果。 -...
操作系统中多线程之间通信
12-21
5. **消息队列（Message Queue）**：线程通过发送和接收消息来通信，消息队列负责存储和传递消息，确保消息的顺序和完整性。 6. **管道（Pipe）**：无名管道是半双工的通信方式，数据只能单向流动，适用于父子进程...
19266036.rar_进程与线程_C/C++_
08-09
- **管道（Pipe）**：简单、快速的数据传递方式，适合父子进程间的通信。 - **共享内存**：多进程可以直接访问同一段内存，效率高但需要同步机制。 - **消息队列**：有序的数据交换，可实现异步通信。 - **套接字...
多个线程之间共享数据的方式
04-19
NULL 博文链接：https://903497571.iteye.com/blog/1869428
php swoole多进程/多线程用法示例【基于php7nts版】
10-16
`write`和`read`方法用于父子进程间的数据通信。 对于多线程（Multi-Thread），在PHP中，原生支持的线程扩展pthreads适用于非NTS（Non Thread Safe）版本的PHP。由于你使用的是PHP7nts版本，因此无法直接使用...
源码讲解ThreadLocal父子线程通信问题（图+文+源码）
天然玩家的博客
01-04 1310
（1）ThreadLocal无法获取父线程数据，ThreadLocal获取数据时直接通过线程的threadLcoals属性获取ThreadLocalMap，由于Thread初始化时没有针对threadLocals进行操作，在子线程中，无法获取父线程的数据； （2）InheritableThreadLocal可以获取父线程数据，InheritableThreadLocal获取数据时通过线程的inheritableThreadLcoals属性获取ThreadLocalMap，由于Thread初始化时...
父子线程通信方式总结
dafeigecsdn的博客
08-18 349
因为InheritableThreadLocal插入数据的时机为new 线程是插入的，因此这个可以使用。阿里开源框架transmittable-thread-local。1、父子线程结合线程池使用。2、父子线程不适用线程池。
一文搞懂 ThreadLocal 内部工作原理解析，父子线程数据传递场景应用
weixin_44985305的博客
02-12 660
TLAB 原理内存实现，ThreadLocal 应用场景。源码层面讲解内存泄露出现原因
ThreadLocal父子间通信的四种解决方案
一零贰肆的博客
02-19 1714
ThreadLocal 是存储在线程栈帧中的一块数据存储区域，其可以做到线程与线程之间的读写隔离。但是在我们的日常场景中，经常会出现父线程需要向子线程中传递消息，而 ThreadLocal 仅能在当前线程上进行数据缓存，这里就介绍4种父子间通信问题;
父子线程间值传递
QFann的博客
08-02 1718
父子线程间值传递 在项目中经常会遇到一个线程横跨若干个方法调用,需要传递对象上下文（context）,例如用户信息session等， 如果将对象进行方法传参，需要给每一个方法增加一个参数，这就存在过度传参的问题. 或者调用一些已经存在的方法,有其他调用方,这时我们就不能随意修改方法传参.所以一般都是采用ThreadLocal来进行线程上下文传递。 ThreadLocal的作用主要是做数据隔离，填充的数据只属于当前线程，对别的线程而言是相对隔离的。 ThreadLocal<Integer> thr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值