程序员经验分享-hwhale

Spring系列之@EnableAsync & @Async 实现方法异步调用

2023-11-04

1、本文内容

详解 @EnableAsync & @Async，主要分下面几个点进行介绍。

  1. 作用

  2. 用法

  3. 获取异步执行结果

  4. 自定义异步执行的线程池

  5. 自定义异常处理

  6. 线程隔离

  7. 源码 & 原理

2、作用

spring容器中实现bean方法的异步调用。

比如有个logService的bean，logservice中有个log方法用来记录日志，当调用logService.log(msg)的时候，希望异步执行，那么可以通过@EnableAsync & @Async来实现。

3、用法

2步

  1. 需要异步执行的方法上面使用@Async注解标注，若bean中所有的方法都需要异步执行，可以直接将@Async加载类上。

  2. 将@EnableAsync添加在spring配置类上，此时@Async注解才会起效。

常见2种用法

  1. 无返回值的

  2. 可以获取返回值的

4、无返回值的

用法

方法返回值不是Future类型的，被执行时，会立即返回，并且无法获取方法返回值，如：

@Async
public void log(String msg) throws InterruptedException {
    System.out.println("开始记录日志," + System.currentTimeMillis());
    //模拟耗时2秒
    TimeUnit.SECONDS.sleep(2);
    System.out.println("日志记录完毕," + System.currentTimeMillis());
}

案例

实现日志异步记录的功能。

LogService.log方法用来异步记录日志，需要使用@Async标注

package com.javacode2018.async.demo1;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class LogService {
    @Async
    public void log(String msg) throws InterruptedException {
        System.out.println(Thread.currentThread() + "开始记录日志," + System.currentTimeMillis());
        //模拟耗时2秒
        TimeUnit.SECONDS.sleep(2);
        System.out.println(Thread.currentThread() + "日志记录完毕," + System.currentTimeMillis());
    }
}

来个spring配置类，需要加上@EnableAsync开启bean方法的异步调用.

package com.javacode2018.async.demo1;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.EnableAsync;

@ComponentScan
@EnableAsync
public class MainConfig1 {
}

测试代码

package com.javacode2018.async;

import com.javacode2018.async.demo1.LogService;
import com.javacode2018.async.demo1.MainConfig1;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.util.concurrent.TimeUnit;

public class AsyncTest {

    @Test
    public void test1() throws InterruptedException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(MainConfig1.class);
        context.refresh();
        LogService logService = context.getBean(LogService.class);
        System.out.println(Thread.currentThread() + " logService.log start," + System.currentTimeMillis());
        logService.log("异步执行方法!");
        System.out.println(Thread.currentThread() + " logService.log end," + System.currentTimeMillis());

        //休眠一下，防止@Test退出
        TimeUnit.SECONDS.sleep(3);
    }

}

运行输出

Thread[main,5,main] logService.log start,1595223990417
Thread[main,5,main] logService.log end,1595223990432
Thread[SimpleAsyncTaskExecutor-1,5,main]开始记录日志,1595223990443
Thread[SimpleAsyncTaskExecutor-1,5,main]日志记录完毕,1595223992443

前2行输出，可以看出logService.log立即就返回了，后面2行来自于log方法，相差2秒左右。

前面2行在主线程中执行，后面2行在异步线程中执行。

5、获取异步返回值

用法

若需取异步执行结果，方法返回值必须为Future类型，使用spring提供的静态方法org.springframework.scheduling.annotation.AsyncResult#forValue创建返回值，如：

public Future<String> getGoodsInfo(long goodsId) throws InterruptedException {
    return AsyncResult.forValue(String.format("商品%s基本信息!", goodsId));
}

案例

场景：电商中商品详情页通常会有很多信息：商品基本信息、商品描述信息、商品评论信息，通过3个方法来或者这几个信息。

这3个方法之间无关联，所以可以采用异步的方式并行获取，提升效率。

下面是商品服务，内部3个方法都需要异步，所以直接在类上使用@Async标注了，每个方法内部休眠500毫秒，模拟一下耗时操作。

package com.javacode2018.async.demo2;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

@Async
@Component
public class GoodsService {
    //模拟获取商品基本信息，内部耗时500毫秒
    public Future<String> getGoodsInfo(long goodsId) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(500);
        return AsyncResult.forValue(String.format("商品%s基本信息!", goodsId));
    }

    //模拟获取商品描述信息，内部耗时500毫秒
    public Future<String> getGoodsDesc(long goodsId) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(500);
        return AsyncResult.forValue(String.format("商品%s描述信息!", goodsId));
    }

    //模拟获取商品评论信息列表，内部耗时500毫秒
    public Future<List<String>> getGoodsComments(long goodsId) throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(500);
        List<String> comments = Arrays.asList("评论1", "评论2");
        return AsyncResult.forValue(comments);
    }
}

来个spring配置类，需要加上@EnableAsync开启bean方法的异步调用.

package com.javacode2018.async.demo2;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;

@ComponentScan
@EnableAsync
public class MainConfig2 {
}

测试代码

@Test
public void test2() throws InterruptedException, ExecutionException {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(MainConfig2.class);
    context.refresh();
    GoodsService goodsService = context.getBean(GoodsService.class);

    long starTime = System.currentTimeMillis();
    System.out.println("开始获取商品的各种信息");

    long goodsId = 1L;
    Future<String> goodsInfoFuture = goodsService.getGoodsInfo(goodsId);
    Future<String> goodsDescFuture = goodsService.getGoodsDesc(goodsId);
    Future<List<String>> goodsCommentsFuture = goodsService.getGoodsComments(goodsId);

    System.out.println(goodsInfoFuture.get());
    System.out.println(goodsDescFuture.get());
    System.out.println(goodsCommentsFuture.get());

    System.out.println("商品信息获取完毕,总耗时(ms)：" + (System.currentTimeMillis() - starTime));

    //休眠一下，防止@Test退出
    TimeUnit.SECONDS.sleep(3);
}

运行输出

开始获取商品的各种信息
商品1基本信息!
商品1描述信息!
[评论1, 评论2]
商品信息获取完毕,总耗时(ms)：525

3个方法总计耗时500毫秒左右。

如果不采用异步的方式，3个方法会同步执行，耗时差不多1.5秒，来试试，将GoodsService上的@Async去掉，然后再次执行测试案例，输出

开始获取商品的各种信息
商品1基本信息!
商品1描述信息!
[评论1, 评论2]
商品信息获取完毕,总耗时(ms)：1503

这个案例大家可以借鉴一下，按照这个思路可以去优化一下你们的代码，方法之间无关联的可以采用异步的方式，并行去获取，最终耗时为最长的那个方法，整体相对于同步的方式性能提升不少。

6、自定义异步执行的线程池

默认情况下，@EnableAsync使用内置的线程池来异步调用方法，不过我们也可以自定义异步执行任务的线程池。

有2种方式来自定义异步处理的线程池

方式1

在spring容器中定义一个线程池类型的bean，bean名称必须是taskExecutor

@Bean
public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(100);
    executor.setThreadNamePrefix("my-thread-");
    return executor;
}

方式2

定义一个bean，实现AsyncConfigurer接口中的getAsyncExecutor方法，这个方法需要返回自定义的线程池，案例代码：

package com.javacode2018.async.demo3;

import com.javacode2018.async.demo1.LogService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.lang.Nullable;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@EnableAsync
public class MainConfig3 {

    @Bean
    public LogService logService() {
        return new LogService();
    }

    /**
     * 定义一个AsyncConfigurer类型的bean，实现getAsyncExecutor方法，返回自定义的线程池
     *
     * @param executor
     * @return
     */
    @Bean
    public AsyncConfigurer asyncConfigurer(@Qualifier("logExecutors") Executor executor) {
        return new AsyncConfigurer() {
            @Nullable
            @Override
            public Executor getAsyncExecutor() {
                return executor;
            }
        };
    }

    /**
     * 定义一个线程池，用来异步处理日志方法调用
     *
     * @return
     */
    @Bean
    public Executor logExecutors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        //线程名称前缀
        executor.setThreadNamePrefix("log-thread-"); //@1
        return executor;
    }

}

@1自定义的线程池中线程名称前缀为log-thread-，运行下面测试代码

@Test
public void test3() throws InterruptedException {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(MainConfig3.class);
    context.refresh();
    LogService logService = context.getBean(LogService.class);
    System.out.println(Thread.currentThread() + " logService.log start," + System.currentTimeMillis());
    logService.log("异步执行方法!");
    System.out.println(Thread.currentThread() + " logService.log end," + System.currentTimeMillis());

    //休眠一下，防止@Test退出
    TimeUnit.SECONDS.sleep(3);
}

输出

Thread[main,5,main] logService.log start,1595228732914
Thread[main,5,main] logService.log end,1595228732921
Thread[log-thread-1,5,main]开始记录日志,1595228732930
Thread[log-thread-1,5,main]日志记录完毕,1595228734931

最后2行日志中线程名称是log-thread-，正是我们自定义线程池中的线程。

7、自定义异常处理

异步方法若发生了异常，我们如何获取异常信息呢？此时可以通过自定义异常处理来解决。

异常处理分2种情况

  1. 当返回值是Future的时候，方法内部有异常的时候，异常会向外抛出，可以对Future.get采用try..catch来捕获异常

  2. 当返回值不是Future的时候，可以自定义一个bean，实现AsyncConfigurer接口中的getAsyncUncaughtExceptionHandler方法，返回自定义的异常处理器

情况1：返回值为Future类型

用法

通过try..catch来捕获异常，如下

try {
    Future<String> future = logService.mockException();
    System.out.println(future.get());
} catch (ExecutionException e) {
    System.out.println("捕获 ExecutionException 异常");
    //通过e.getCause获取实际的异常信息
    e.getCause().printStackTrace();
} catch (InterruptedException e) {
    e.printStackTrace();
}

案例

LogService中添加一个方法，返回值为Future，内部抛出一个异常，如下：

@Async
public Future<String> mockException() {
    //模拟抛出一个异常
    throw new IllegalArgumentException("参数有误!");
}

测试代码如下

@Test
public void test5() throws InterruptedException {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(MainConfig1.class);
    context.refresh();
    LogService logService = context.getBean(LogService.class);
    try {
        Future<String> future = logService.mockException();
        System.out.println(future.get());
    } catch (ExecutionException e) {
        System.out.println("捕获 ExecutionException 异常");
        //通过e.getCause获取实际的异常信息
        e.getCause().printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //休眠一下，防止@Test退出
    TimeUnit.SECONDS.sleep(3);
}

运行输出

java.lang.IllegalArgumentException: 参数有误!
捕获 ExecutionException 异常
 at com.javacode2018.async.demo1.LogService.mockException(LogService.java:23)
 at com.javacode2018.async.demo1.LogService$$FastClassBySpringCGLIB$$32a28430.invoke(<generated>)
 at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)

情况2：无返回值异常处理

用法

当返回值不是Future的时候，可以自定义一个bean，实现AsyncConfigurer接口中的getAsyncUncaughtExceptionHandler方法，返回自定义的异常处理器，当目标方法执行过程中抛出异常的时候，此时会自动回调AsyncUncaughtExceptionHandler#handleUncaughtException这个方法，可以在这个方法中处理异常，如下：

@Bean
public AsyncConfigurer asyncConfigurer() {
    return new AsyncConfigurer() {
        @Nullable
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
            return new AsyncUncaughtExceptionHandler() {
                @Override
                public void handleUncaughtException(Throwable ex, Method method, Object... params) {
                    //当目标方法执行过程中抛出异常的时候，此时会自动回调这个方法，可以在这个方法中处理异常
                }
            };
        }
    };
}

案例

LogService中添加一个方法，内部抛出一个异常，如下：

@Async
public void mockNoReturnException() {
    //模拟抛出一个异常
    throw new IllegalArgumentException("无返回值的异常!");
}

来个spring配置类，通过AsyncConfigurer来自定义异常处理器AsyncUncaughtExceptionHandler

package com.javacode2018.async.demo4;

import com.javacode2018.async.demo1.LogService;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.lang.Nullable;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;

import java.lang.reflect.Method;
import java.util.Arrays;

@EnableAsync
public class MainConfig4 {

    @Bean
    public LogService logService() {
        return new LogService();
    }

    @Bean
    public AsyncConfigurer asyncConfigurer() {
        return new AsyncConfigurer() {
            @Nullable
            @Override
            public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
                return new AsyncUncaughtExceptionHandler() {
                    @Override
                    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
                        String msg = String.format("方法[%s],参数[%s],发送异常了，异常详细信息:", method, Arrays.asList(params));
                        System.out.println(msg);
                        ex.printStackTrace();
                    }
                };
            }
        };
    }

}

运行输出

方法[public void com.javacode2018.async.demo1.LogService.mockNoReturnException()],参数[[]],发送异常了，异常详细信息:
java.lang.IllegalArgumentException: 无返回值的异常!
 at com.javacode2018.async.demo1.LogService.mockNoReturnException(LogService.java:29)
 at com.javacode2018.async.demo1.LogService$$FastClassBySpringCGLIB$$32a28430.invoke(<generated>)
 at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)

8、线程池隔离

什么是线程池隔离？

一个系统中可能有很多业务，比如充值服务、提现服务或者其他服务，这些服务中都有一些方法需要异步执行，默认情况下他们会使用同一个线程池去执行，如果有一个业务量比较大，占用了线程池中的大量线程，此时会导致其他业务的方法无法执行，那么我们可以采用线程隔离的方式，对不同的业务使用不同的线程池，相互隔离，互不影响。

@Async注解有个value参数，用来指定线程池的bean名称，方法运行的时候，就会采用指定的线程池来执行目标方法。

使用步骤

  1. 在spring容器中，自定义线程池相关的bean

  2. @Async("线程池bean名称")

案例

模拟2个业务：异步充值、异步提现；2个业务都采用独立的线程池来异步执行，互不影响。

异步充值服务

package com.javacode2018.async.demo5;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class RechargeService {
    //模拟异步充值
    @Async(MainConfig5.RECHARGE_EXECUTORS_BEAN_NAME)
    public void recharge() {
        System.out.println(Thread.currentThread() + "模拟异步充值");
    }
}

异步提现服务

package com.javacode2018.async.demo5;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class CashOutService {
    //模拟异步提现
    @Async(MainConfig5.CASHOUT_EXECUTORS_BEAN_NAME)
    public void cashOut() {
        System.out.println(Thread.currentThread() + "模拟异步提现");
    }
}

spring配置类

注意@0、@1、@2、@3、@4这几个地方的代码，采用线程池隔离的方式，注册了2个线程池，分别用来处理上面的2个异步业务。

package com.javacode2018.async.demo5;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@EnableAsync //@0：启用方法异步调用
@ComponentScan
public class MainConfig5 {

    //@1：值业务线程池bean名称
    public static final String RECHARGE_EXECUTORS_BEAN_NAME = "rechargeExecutors";
    //@2：提现业务线程池bean名称
    public static final String CASHOUT_EXECUTORS_BEAN_NAME = "cashOutExecutors";

    /**
     * @3：充值的线程池，线程名称以recharge-thread-开头
     * @return
     */
    @Bean(RECHARGE_EXECUTORS_BEAN_NAME)
    public Executor rechargeExecutors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        //线程名称前缀
        executor.setThreadNamePrefix("recharge-thread-");
        return executor;
    }

    /**
     * @4: 充值的线程池，线程名称以cashOut-thread-开头
     *
     * @return
     */
    @Bean(CASHOUT_EXECUTORS_BEAN_NAME)
    public Executor cashOutExecutors() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        //线程名称前缀
        executor.setThreadNamePrefix("cashOut-thread-");
        return executor;
    }
}

测试代码

@Test
public void test7() throws InterruptedException {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(MainConfig5.class);
    context.refresh();

    RechargeService rechargeService = context.getBean(RechargeService.class);
    rechargeService.recharge();
    CashOutService cashOutService = context.getBean(CashOutService.class);
    cashOutService.cashOut();

    //休眠一下，防止@Test退出
    TimeUnit.SECONDS.sleep(3);
}

运行输出

Thread[recharge-thread-1,5,main]模拟异步充值
Thread[cashOut-thread-1,5,main]模拟异步提现

输出中可以看出2个业务使用的是不同的线程池执行的。

9、源码 & 原理

内部使用aop实现的，@EnableAsync会引入一个bean后置处理器：AsyncAnnotationBeanPostProcessor，将其注册到spring容器，这个bean后置处理器在所有bean创建过程中，判断bean的类上是否有@Async注解或者类中是否有@Async标注的方法，如果有，会通过aop给这个bean生成代理对象，会在代理对象中添加一个切面：org.springframework.scheduling.annotation.AsyncAnnotationAdvisor，这个切面中会引入一个拦截器：AnnotationAsyncExecutionInterceptor，方法异步调用的关键代码就是在这个拦截器的invoke方法中实现的，可以去看一下。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

spring系列

Spring

Java

后端

Spring系列之@EnableAsync & @Async 实现方法异步调用 的相关文章

随机推荐

  • 让VBS脚本也有GUI图形界面

    set ie wscript createobject internetexplorer application event 创建ie对象 ie menubar 0 取消菜单栏 ie addressbar 0 取消地址栏 ie toolba

  • js实现前端HTML操作用户文件的读写（已封装）

    readFile 第一个方法是 readFile 用于读取文件内容并以 Promise 对象的形式返回 它接受一个 File 对象和一个可选的编码格式参数 使用 FileReader 对象读取文件内容 当读取完成时调用 resolve 方法

  • RuntimeError: expected dtype Double but got dtype Float 问题解决

    利用Pytorch框架自己构建网络结构 在程序运行到 loss backward 的时候报错 RuntimeError expected dtype Double but got dtype Float validate dtype at

  • 万字长文讲述我是怎样保送清华的

    点击 小卡片 回复 1024 获取大厂面试指南 背景 大家好 我是石头哥 本篇是系列文章第 4 篇 前三篇如下 家穷应该读大学吗 寒门学子的奋斗史 一 第一篇回忆了自己读小学的场景 寒门学子的奋斗史 二 第二篇讲了自己就读的贫困山区中学的

  • Python RSA加密解密

    Python RSA加密解密 RSA是一种非对称加密算法 非对称加密需要公钥 publickey 和私钥 privatekey 消息传递前需要先生成公钥和私钥 发送方将待发送消息用公钥加密 发送给接收方 接收方收到消息后 用私钥解密 在这个

  • 学生信息管理系统

    学生信息管理系统 基于动态链表的增 删 改 查和文件的存储 实现对学生信息 姓名 性别 年龄 学号 电话 语文 数学 英语 的管理 存储学生信息的文件 define FILEPATH information txt 学生基本信息结构体 学生

  • 将用户“C:\Users\XXX”文件夹映射到其他盘符

    注意事项 在要改变用户 以xxx为例 时 系统XXX关闭 用微PE或安装好U盘的系统 进入U盘启动操作 确保映射稳定 主机的盘符与U盘启动下的盘符一致 其他的可以不一样 要将用户XXX移动到的盘符必须一致 不建议将整个用户文件夹 C Use

  • 网络通讯中的checksum算法

    网络通讯中的checksum算法 一 实验目的和任务 本实验要求复习Debian系统抓包工具的使用 本实验要求理解checksum算法原理和实现方法 二 实验设备介绍 1 软件需求 win7操作系统 VMware workstation u

  • latex第一段的首行缩进问题

    setlength parindent 2em 首行全部缩进2字符 但是在第一行使用没有效果 indent也是首行缩进 第一段第一行的缩进只能用 hspace 0 5em 来控制空格的多少 解决中文排版问题 hspace 0 5em 随着科

  • 复制微信公众号图片不能用，防盗链问题

    问题起因很简单 直接复制的公众号文章到网站 不单独处理图片 复制出来的文章图片因为微信防盗链设置不能显示出来 如下图 防盗链原理就是后端先拦截请求获取其中的referrer 将其和自身的白名单 本地域名等对比 符合条件的将通过 不符合的将会

  • Java：最小栈（）

    一 知识准备 1 栈 核心 先进后出 从栈顶入 栈顶出 栈的几种基本操作 void push int data 入栈 int pop 弹出栈顶元素 即 删除并返回最后一个入栈的元素 int peek 返回栈顶元素但不删除 boolean e

  • 2021-03-30 python离线安装openpyxl模块

    1 前言 最近Python项目需要用openpyxl对excel进行处理 引用到了openpyxl模块 但是客户的环境没有网 无法用pip安装openpyxl 因此需要离线安装 记录下遇到的问题及解决的办法 2 过程 能联网的话用pip 一

  • WEB安全-RCE代码及命令执行漏洞

    WEB安全 RCE代码及命令执行漏洞 摘要 RCE概述 远程代码执行 eval 案例 远程命令执行 system shell exec 与 exec 案例 靶场案例 墨者靶场黑盒功能点命令执行 应用功能 墨者靶场白盒代码及命令执行 代码分析

  • make编译内核驱动模块

    make编译内核驱动模块 方法一 obj m hello world o KDIR home july7 prj Firefly RK3308 kernel 内核源码路径 PWD shell pwd 获取当前目录的变量 all make C

  • java 获取当前服务器CPU,JVM,内存等信息

    借助于 Hyperic Sigar 是一个收集系统各项底层信息的工具集 没啥技术含量 参考 https support hyperic com display SIGAR Home 下载地址 http sourceforge net pro

  • #ifndef 与 #pragma once 的使用方法

    ifndef 与 pragma once 都能让头文件只编译一次 避免重复编译 新版本的代码建议使用 pragma once 这样只要编译一次就可以了 但是很多老编译器不支持该语法 很尴尬 ifndef则需要每次使用的时候进行一次编译 速度

  • 概率论【离散型随机变量】--猴博士爱讲课

    第二课 离散型随机变量 1 6 求分布律里的未知数 2 6 根据X的分布律写Y的分布律 一维随机变量函数的分布 注意 3 6 根据 X Y 的分布律写Z的分布律 4 6 根据 X Y 的分布律写边缘分布律 边缘分布 5 6 X与Y相互独立时

  • python训练预测_python中NARX的示例-训练和预测 - python

    是否有使用Python中的NARX模型训练和预测 推断数据的端到端示例 有图书馆PyNeurgen NARX PyNeurgen library 但是PyNeurgen的文档不是很完整 该OP似乎已经编写了Keras实现 但是代码缺少用于推

  • CLion2021.2配置qt环境

    文章参考文档 使用CLion开发Qt Qt5 9 1 CLion2020 3 Clion中Cmake构建出现复制文件错误的解决办法 Clion 创建 Qt UI Class 踩坑 文章目录 1 前言 2 QT安装与环境变量的配置 3 工具链

  • Spring系列之@EnableAsync & @Async 实现方法异步调用

    1 本文内容 详解 EnableAsync Async 主要分下面几个点进行介绍 作用 用法 获取异步执行结果 自定义异步执行的线程池 自定义异常处理 线程隔离 源码 原理 2 作用 spring容器中实现bean方法的异步调用 比如有个l

热门标签