多线程代码示例

最新推荐文章于 2025-12-16 16:02:25 发布
原创 最新推荐文章于 2025-12-16 16:02:25 发布 · 247 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

dubbo异步多线程调用

    public List<LotteryCategoryVo> selectChildrenAll(List<String> pids) {
        long start = System.currentTimeMillis();
        log.info("selectChildrenAll start:{}",start);
        List<Category> categories = null;
        AbstractAsyncBatchInvokeUtils<List<Category>, String> abstractAsyncBatchInvokeUtils = new AbstractAsyncBatchInvokeUtils<List<Category>, String>() {
            @Override
            public void invoke(String pid) {
                categoryService.selectChildren(Long.valueOf(pid));
            }
        };
        try {
        Iterable<List<String>> partition = Iterables.partition(pids, 10);
            for (List<String> e : partition) {
                List<List<Category>> list = abstractAsyncBatchInvokeUtils.asyncBatchInvoke(e, 100, 1);
                for (List<Category> categoryList : list) {
                    categories.addAll(categoryList);
                }
            }
        } catch (Exception e) {
            log.error("导出查询会员信息失败，错误信息为：{}", e.getMessage(), e);
            throw new GenericBusinessException("导出查询会员信息失败");
        }
        List<LotteryCategoryVo> result = convertCategoryVo(categories);
        log.info("selectChildrenAll end:{} end-start:{} ms",System.currentTimeMillis(),System.currentTimeMillis()-start);
        return result;
    }

/**
 * dubbo批量异步接口，调用者实现invoke方法，限制50条，超长的调用者自行分页
 *
 * todo 该方法存在优化点：需要依赖dubbo配置文件async=true ，如果能在RpcContext中修改RpcInvocation参数为异步可以在这里自定义参数将会摆脱配置文件的依赖
 * @author:zxd
 * @date: 9/3/21
 * @time: 4:26 PM
 */
@Slf4j
public abstract class AbstractAsyncBatchInvokeUtils<T, V> {

    /**
     * 策略：某异步线程异常，方法停止，向上抛出
     */
    public static final int UN_CATCH_EXCEPTION_HANDLER_STRATEGY = 0;

    /**
     * 策略：吞掉某异步线程异常
     */
    public static final int CATCH_EXCEPTION_HANDLER_STRATEGY = 1;

    /**
     * 入参params的长度限制，批量执行，
     */
    public static final int PARAM_SIZE_LIMIT = 50;


    /**
     * 基于dubbo消费者线程池异步消费方法的批量执行器，方法内是异步，对外返回的结果是同步的
     * 注意：dubbo方法的配置文件需要async=true
     * @param params params 参数集合
     * @param singleWaitTime 单线程等待时间，单位毫秒，为0则表示使用dubbo.xml设置的方法调用时间
     * @param handlerStrategyStatus 异常处理策略 NO_CATCH_EXCEPTION_HANDLER_STRATEGY 或者 CATCH_EXCEPTION_HANDLER_STRATEGY
     * @return List<T> 直接返回结果
     */
    public List<T> asyncBatchInvoke(Collection<V> params, long singleWaitTime, int handlerStrategyStatus)
            throws InterruptedException, ExecutionException, TimeoutException {
        if (CollectionUtils.isEmpty(params) || params.size() > PARAM_SIZE_LIMIT) {
            throw new BadParameterException("参数异常");
        }
        List<Future<T>> futureList = batchInvoke(params);
        List<T> list = Lists.newArrayList();
        for (Future<T> future : futureList) {
            // 某线程异常直接吞掉
            if (handlerStrategyStatus == CATCH_EXCEPTION_HANDLER_STRATEGY) {
                T t = null;
                Object[]  arguments = null;
                try {
                    FutureAdapter future1 = (FutureAdapter) future;
                    DefaultFuture defaultFuture = (DefaultFuture)future1.getFuture();
                    Request request = defaultFuture.getRequest();
                    RpcInvocation data = (RpcInvocation)request.getData();
                    arguments = data.getArguments();
                    if (singleWaitTime <= 0L){
                        t = future.get();
                    }else {
                        t = future.get(singleWaitTime, TimeUnit.MILLISECONDS);
                    }
                } catch (Exception e) {
                    if (log.isInfoEnabled()) {
                        log.info("AbstractAsyncBatchInvokeUtils.asyncBatchInvoke 批量方法执行报错，" +
                                        "失败线程参数arguments={},singleWaitTime={},handlerStrategyStatus={}",
                                JSON.toJSONString(arguments), singleWaitTime, handlerStrategyStatus, e);
                    }
                    Thread.currentThread().interrupt();
                }
                if (t != null) {
                    list.add(t);
                }
            } else if (handlerStrategyStatus == UN_CATCH_EXCEPTION_HANDLER_STRATEGY) {
                // 不吞掉异常
                T t = future.get(singleWaitTime, TimeUnit.MILLISECONDS);
                if (t != null) {
                    list.add(t);
                }
            }
        }
        log.info("AbstractAsyncBatchInvokeUtils.asyncBatchInvoke 结果返回result={}", JSON.toJSONString(list));
        return list;
    }

    /**
     * 具体执行的方法，调用者实现该方法的具体业务逻辑
     *
     * @param v 参数
     */
    public abstract void invoke(V v);

    /**
     * 基于dubbo消费者线程池异步消费方法的批量执行器，返回future类型结果，为异步的方法，调用者自行从future中拿结果
     *
     * @param params params 参数集合
     * @return  List<Future<T>> 返回future的集合结果
     */
    public List<Future<T>> asyncBatchInvoke(Collection<V> params) {
        if (CollectionUtils.isEmpty(params) || params.size() > PARAM_SIZE_LIMIT) {
            throw new BadParameterException("参数异常");
        }
        List<Future<T>> futureList = batchInvoke(params);
        return futureList;
    }

    /**
     * 批量批异步执行目标方法
     * @param params
     * @return 返回 future，使用者可以根据实际逻辑，先做其他事情再获取future中的结果，做到真正的异步
     * @throws Exception
     */
    private List<Future<T>> batchInvoke(Collection<V> params) {

        List<Future<T>> futureList = Lists.newArrayList();
        for (V param : params) {
            invoke(param);
            Future<T> future = RpcContext.getContext().getFuture();
            futureList.add(future);
        }
        return futureList;
    }



}


@Configuration
@EnableAsync
@SuppressWarnings("all")
public class ThreadPoolConfiguration {
    @Bean("lotteryCategoryTaskExecutor")
    public ThreadPoolTaskExecutor lotteryCategoryTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(20);
        threadPoolTaskExecutor.setKeepAliveSeconds(200);
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskExecutor;
    }
}

同步多线程调用：

    @Override
    public List<LotteryCategoryVo> selectChildrenAll(List<String> pids) {
        List<LotteryCategoryVo> result = new ArrayList<>();
        List<Future<List<LotteryCategoryVo>>> futureList = new ArrayList<>();
        for (String pid : pids) {
            Future<List<LotteryCategoryVo>> future = selectChildrenAllTaskExecutor.submit(CallableWrapper.of(() -> this.selectChildren(pid)));
            futureList.add(future);
        }

        futureList.stream().forEach((task) -> {
            try {
                List<LotteryCategoryVo> lotteryCategoryVos = task.get();
                result.addAll(lotteryCategoryVos);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
        return result;
    }


    @Bean("selectChildrenAllTaskExecutor")
    public ThreadPoolTaskExecutor selectChildrenAllTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setKeepAliveSeconds(200);
        threadPoolTaskExecutor.setMaxPoolSize(20);
        threadPoolTaskExecutor.setQueueCapacity(500);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskExecutor;
    }

    public LotteryCategoryQueryVo getCategory(String activityCode) {
        log.info("查询分类耗时：t1:{}", System.currentTimeMillis());

        LotteryCategoryRes lotteryCategoryRes = lotteryActivityService.queryCategory(activityCode);
        if (ObjectUtils.isEmpty(lotteryCategoryRes)) {
            return LotteryCategoryQueryVo.builder().isSelect(false).build();
        }

        List<String> levelOneSelect = lotteryCategoryRes.getLotteryCategory().getLevelOne();
        List<String> levelTwoSelect = lotteryCategoryRes.getLotteryCategory().getLevelTwo();
        List<String> levelThreeSelect = lotteryCategoryRes.getLotteryCategory().getLevelThree();
        List<String> levelFourSelect = lotteryCategoryRes.getLotteryCategory().getLevelFour();
        log.info("查询分类耗时：t3:{}", System.currentTimeMillis());

        Future<List<LotteryCategoryVo>> levelFourFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelThreeSelect)));
        Future<List<LotteryCategoryVo>> levelThreeFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelTwoSelect)));
        Future<List<LotteryCategoryVo>> levelTwoFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelOneSelect)));
        Future<List<LotteryCategoryVo>> levelOneFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectByLevel(1)));
        Future<Long> skuCountFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectSkuCount(LotteryCategoryRequest
                .builder()
                .categoryIds(levelFourSelect)
                .page(0)
                .size(0)
                .build())));


        Long skuCount = null;
        List<LotteryCategoryVo> levelOne = null;
        List<LotteryCategoryVo> levelTwo = null;
        List<LotteryCategoryVo> levelThree = null;
        List<LotteryCategoryVo> levelFour = null;
        try {
            skuCount = skuCountFuture.get();
            levelOne = levelOneFuture.get();
            levelTwo = levelTwoFuture.get();
            levelThree = levelThreeFuture.get();
            levelFour = levelFourFuture.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        log.info("查询分类耗时：t2:{}", System.currentTimeMillis());
        return LotteryCategoryQueryVo.builder()
                .id(lotteryCategoryRes.getId())
                .isSelect(true)
                .levelOne(levelOne)
                .levelTwo(levelTwo)
                .levelThree(levelThree)
                .levelFour(levelFour)
                .levelOneSelect(levelOneSelect)
                .levelTwoSelect(levelTwoSelect)
                .levelThreeSelect(levelThreeSelect)
                .levelFourSelect(levelFourSelect)
                .count(skuCount)
                .build();

    }

    public LotteryCategoryQueryVo getCategory(String activityCode) {
        log.info("查询分类耗时：t1:{}", System.currentTimeMillis());

        LotteryCategoryRes lotteryCategoryRes = lotteryActivityService.queryCategory(activityCode);
        if (ObjectUtils.isEmpty(lotteryCategoryRes)) {
            return LotteryCategoryQueryVo.builder().isSelect(false).build();
        }

        List<String> levelOneSelect = lotteryCategoryRes.getLotteryCategory().getLevelOne();
        List<String> levelTwoSelect = lotteryCategoryRes.getLotteryCategory().getLevelTwo();
        List<String> levelThreeSelect = lotteryCategoryRes.getLotteryCategory().getLevelThree();
        List<String> levelFourSelect = lotteryCategoryRes.getLotteryCategory().getLevelFour();
        log.info("查询分类耗时：t3:{}", System.currentTimeMillis());

        Future<List<LotteryCategoryVo>> levelFourFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelThreeSelect)));
        Future<List<LotteryCategoryVo>> levelThreeFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelTwoSelect)));
        Future<List<LotteryCategoryVo>> levelTwoFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectChildrenAll(levelOneSelect)));
        Future<List<LotteryCategoryVo>> levelOneFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectByLevel(1)));
        Future<Long> skuCountFuture = lotteryCategoryTaskExecutor.submit(CallableWrapper.of(() -> selectSkuCount(LotteryCategoryRequest
                .builder()
                .categoryIds(levelFourSelect)
                .page(0)
                .size(0)
                .build())));


        Long skuCount = null;
        List<LotteryCategoryVo> levelOne = null;
        List<LotteryCategoryVo> levelTwo = null;
        List<LotteryCategoryVo> levelThree = null;
        List<LotteryCategoryVo> levelFour = null;
        try {
            skuCount = skuCountFuture.get();
            levelOne = levelOneFuture.get();
            levelTwo = levelTwoFuture.get();
            levelThree = levelThreeFuture.get();
            levelFour = levelFourFuture.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        log.info("查询分类耗时：t2:{}", System.currentTimeMillis());
        return LotteryCategoryQueryVo.builder()
                .id(lotteryCategoryRes.getId())
                .isSelect(true)
                .levelOne(levelOne)
                .levelTwo(levelTwo)
                .levelThree(levelThree)
                .levelFour(levelFour)
                .levelOneSelect(levelOneSelect)
                .levelTwoSelect(levelTwoSelect)
                .levelThreeSelect(levelThreeSelect)
                .levelFourSelect(levelFourSelect)
                .count(skuCount)
                .build();

    }

    @Bean("lotteryCategoryTaskExecutor")
    public ThreadPoolTaskExecutor lotteryCategoryTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(20);
        threadPoolTaskExecutor.setKeepAliveSeconds(200);
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskExecutor;
    }

CountDownLatch写法多线程调用：

    public List<EnvelopeRainShopVO> checkShops(List<String> shopIds,String activityCode) {
        log.info("校验门店入参，活动代码为：{},门店为：{}",activityCode,shopIds);
        List<MissionMappingDO> byShopId = missionMappingDataMapperEx.findByShopId(shopIds, MissionBizTypeEnum.ENVELOPE_RAIN.getBizId());
        List<EnvelopeRainShopVO> res = Collections.synchronizedList(new ArrayList<>());
        String circuitBreakConfig = null;
        try {
            circuitBreakConfig = ConfigManager.getInstance().getConfig("ACTIVITY", "rain-check-shop-break-config");
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        // 降级开关
        if (Objects.equals("1", circuitBreakConfig)) {
            log.info("checkShops直接通过校验");
            return res;
        }
        if(CollectionUtils.isEmpty(byShopId)){
            return res;
        }

        //很多门店在同一个活动下
        AtomicBoolean flag = new AtomicBoolean(false);
        Map<String,ActivityInfo> activityInfoMap = new ConcurrentHashMap<>();
        CountDownLatch cdl = new CountDownLatch(byShopId.size());
        for (MissionMappingDO mission : byShopId) {
            redRainCheckShopTaskExecutor.submit(()->{
                try {
                    ActivityInfo activityInfo = activityInfoMap.get(mission.getRefId());
                    if (Objects.isNull(activityInfo)) {
                        activityInfo = activityCoreService.getActivityInfo(mission.getRefId());
                        if(Objects.isNull(activityInfo)){
                            return;
                        }
                        activityInfoMap.put(mission.getRefId(), activityInfo);
                    }

                    if (activityInfo.getActivityCode().equals(activityCode)) {
                        return;
                    }
                    Shop shopById = shopService.getAnyShopById(mission.getShopRef());
                    if(Objects.isNull(shopById)){
                        throw new GenericBusinessException(mission.getShopRef()+"门店不存在");
                    }
                    if (activityInfo.getStatus() == ActivityStatus.NOT_ENABLED
                            || activityInfo.getStatus() == ActivityStatus.NOT_START
                            || activityInfo.getStatus() == ActivityStatus.AVAILABLE
                            || activityInfo.getStatus() == ActivityStatus.AUDITING) {
                        res.add(EnvelopeRainShopVO.builder()
                                .shopId(mission.getShopRef())
                                .shopName(shopById.getShopName())
                                .activityCode(mission.getRefId())
                                .build());
                    }
                } catch (Exception e) {
                    flag.set(true);
                    log.error("RainMissionRuleServiceImpl.checkShops error",e);
                } finally {
                    cdl.countDown();
                }
            });
        }
        try {
            cdl.await();
        } catch (InterruptedException e) {
            log.error("RainMissionRuleServiceImpl.checkShops error",e);
        }
        if (flag.get()){
            throw new GenericBusinessException("门店校验错误");
        }
        Map<String,EnvelopeRainShopVO> map =new HashMap<>();
        res.stream().forEach(n->{
            if(!map.containsKey(n.getActivityCode())){
                map.put(n.getActivityCode(),n);
            }else {
                map.get(n.getActivityCode()).setShopName(map.get(n.getActivityCode()).getShopName()+","+n.getShopName());
                map.get(n.getActivityCode()).setShopId(map.get(n.getActivityCode()).getShopId()+","+n.getShopId());
            }
        });
        Set<String> keys = map.keySet();
        List<EnvelopeRainShopVO> res1 = new ArrayList<>();
        for(String key : keys){
            res1.add(map.get(key));
        }
        log.info("校验门店出参，已有活动的门店为：{}",res1);
        return res1;
    }


    @Bean
    public ThreadPoolTaskExecutor redRainCheckShopTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setKeepAliveSeconds(200);
        threadPoolTaskExecutor.setMaxPoolSize(10);
        threadPoolTaskExecutor.setQueueCapacity(500);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskExecutor;
    }
精选资源
QT5.12实现多线程代码示例
02-18
QT5.12实现多线程示例，逻辑功能如下： 点击Start A按钮开始打印字符“A”,同时按钮显示Stop A;点击Start B按钮开始打印字符“B”,同时按钮显示Stop B; 点击Stop A按钮停止字符“A”打印,点击Stop B按钮停止字符“B...
多线程多批次处理业务逻辑代码
damoneric_guo的博客
04-29 283
多线程多批次处理业务逻辑代码 private static final ExecutorService threadPool = Executors.newFixedThreadPool(10); public void sendNewsJob() throws Exception { // 查询需要推送的咨讯消息 List<NewsInfoDto> newsInfoDtos = newsInfoService.findWaitPushNews(); if (Collect
多线程详细解说，代码
wan23333的博客
12-07 257
多线程 进程: 就是可执行的应用程序. 线程: 进程的执行单元,可以理解为进程的一条执行路径. 线程和进程关系: 进程是执行中的程序,进程本身不会运行，是线程的容器。一个程序至少有一个进程，一个进程至少有一个线程. 多线程: 进程有多个执行路径. 原理: CPU做着高效的切换.多线程的执行具有随机性和延迟性. 线程状态： 1）就绪：指线程具备运行的所
java多线程详解及代码实现
....
03-18 3172
java中的多线程详解及代码实现 一. 基本概念及实现方式 基本概念: 1. 进程 进程是独立的应用程序,占用cpu资源和物理内存 2. 线程 线程是进程中虚拟的时间片,所谓的多线程并发实际上就是时间片的轮转或者抢占 第一种实现方式:继承Thread类 // 创建当前类的对象,并且调用run()方法 public class ExtendsThread extends...
多线程的三种实现代码
yuxialuozi的博客
07-09 885
该类实现了Runnable接口，并重写了run()方法，在其中编写线程的任务逻辑。在上述代码中，我们定义了一个自定义线程类MyThread，该类继承了Thread类，并重写了Thread类的run()方法。需要注意的是，在多线程编程中，不要直接调用run()方法，而是通过start()方法来启动线程，因为直接调用run()方法只会在当前线程中以普通方法的方式执行，而不会启动一个新的线程。需要注意的是，在使用实现Runnable接口的方式时，线程的任务逻辑必须在run()方法中实现，而不是直接在类中编写。
java 多线程&对业务代码进行封装——66
爱的叹息的专栏
06-25 411
前面示例是在自定义的MyThread类中处理业务，而业务代码要尽量放在Service业务类中进行处理，这样代码更加标准
多线程编程示例
02-25
在IT领域，多线程编程是一项关键技能，尤其是在性能优化和并发处理方面。本文将深入探讨多线程编程的基础知识，以帮助初学者快速入门。 首先，我们需要理解什么是多线程。多线程是指在一个进程中同时执行多个独立的...
深入浅出java多线程代码示例
06-29
本文将深入浅出地探讨Java多线程的相关知识点，通过具体代码示例帮助你理解和掌握这一核心技能。 一、线程的创建与启动 在Java中，有三种方式创建线程：实现Runnable接口、继承Thread类以及使用ExecutorService。`...
POSIX规范多线程代码示例
06-05
在这个名为"POSIX规范多线程代码示例"的压缩包中，你将找到六个使用C++的POSIX线程库（pthread）编写的示例，它们逐步展示了如何在Linux和Windows环境下（使用Visual Studio，需添加-lpthread链接选项）创建和管理多...
多线程编程示例源代码
07-27
多线程编程示例代码，包含CreateThread _beginthread AFXbeginThread 3个API的示例
Java多线程执行处理业务时间太久解决方法代码示例
08-28
主要介绍了Java多线程执行处理业务时间太久解决方法代码示例的相关资料,具有一定借鉴价值，需要的朋友可以参考下。
关于Dubbo异步调用的优化
03-04
对原有的dubbo远程调用的异步的缺陷性进行了优化方案
Java常用业务代码-线程篇
菜鸟先飞
06-05 529
本篇文章将Java线程中常见的功能进行整理，涉及点：join、yield、isAlive方法、synchronized的使用、生产者-消费者模式(wait/notify实现和阻塞队列实现)、Lock+Condition模拟阻塞队列、线程同步工具、模拟死锁程序、jstack寻找死锁程序。 join join类似于同步，当A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行(如下代码)， 但是B线程必须已经调用start()方法，否则join就会失效 public st
java 线程通信原理_Dubbo-多线程通信原理
weixin_36472962的博客
02-17 360
本文代码摘录的时候，将一些与本流程无关的内容去掉了，如有需要请看源码。如果大家对Dubbo RPC原理原理感兴趣，可以看我之前写过的另外一篇博客《Dubbo RPC源码解读》。一、 思考与目标1. 思考并发情况下，dubbo的RPC模型如下图所示：如图所示，Consumer端可能同时有多个线程调用Provider的服务，此时Provider会启动多个线程来分别处理这些并发调用，处理完以后将数据返回...
dubbo 多连接,多线程池.
a50295866的博客
08-21 950
1. consumer 多连接 Dubbo protocol options: <dubbo:protocolname=“dubbo” port=“9090” server=“netty” client=“netty” codec=“dubbo” serialization=“hessian2” charset=“UTF-8” threadpool=“fixed” thre...
【Java多线程】总结（一）线程的创建 线程方法 附详细（）代码（更新
qq_54184658的博客
04-01 686
进程：是指一个内存中正在运行的应用程序。每个进程都有自己的内存空间和系统资源，一个进程可以有多个线程。 线程：是一个顺序控制流，是一条执行路径。 单线程：一个进程如果只有一条执行路径，则称为单线程程序； 多线程：一个进程有多个执行路径，则称为多线程程序； 进程和线程的区别总结： 进程是操作系统资源分配的基本单位，线程是处理机调度的基本单位 线程是轻量级进程，在引入线程的操作系统中，通常一个进程有多个线程 多线程的实现方式： 继承Thread类： public class ThreadD.
Dubbo-多线程通信原理
weixin_34232363的博客
11-26 723
本文代码摘录的时候，将一些与本流程无关的内容去掉了，如有需要请看源码。 如果大家对Dubbo RPC原理原理感兴趣，可以看我之前写过的另外一篇博客《 Dubbo RPC源码解读》。 一、 思考与目标 1. 思考 并发情况下，dubbo的RPC模型如下图所示： 如图所示，Consumer端可能同时有...
车载系统应用开发集成系统API
最新发布
yangyulong0622的博客
12-16 315
车载开发中，为了快速迭代常将系统应用剥离为普通应用开发，但调用系统API时反射效率低。解决方法是通过集成framework.jar，但会遇到编译报错问题。通用方案是在gradle中配置bootstrapClasspath引入jar包。当使用高版本JDK时，必须强制指定模块使用JDK8并关闭lint检查才能生效。关键步骤：先加载jar包到工程，再设置模块JDK版本为1.8。
java 多线程代码示例
07-27
下面是一个简单的Java多线程代码示例： ```java public class MyThread extends Thread { public void run() { // 线程执行的代码 System.out.println("Thread running"); } } public class Main { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); // 启动线程 } } ``` 这个例子中，我们创建了一个继承自Thread类的自定义线程类MyThread，并重写了run()方法，在run()方法中定义了线程要执行的代码。在主程序中，我们创建了一个MyThread对象，并调用start()方法来启动线程。当线程启动后，它会自动调用run()方法中的代码。运行该程序，你会看到输出结果为"Thread running"。这就是一个简单的Java多线程代码示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值