SpringBoot中使用@Async实现异步调用

SpringBoot中使用@Async实现异步调用

什么是异步调用?异步调用对应的是同步调用，同步调用指程序按照定义顺序依次执行，每一行程序都必须等待上

一行程序执行完成之后才能执行；异步调用指程序在顺序执行时，不等待异步调用的语句返回结果就执行后面的程

序。

1、pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.5.6</version><relativePath/></parent><groupId>com.async</groupId><artifactId>spring-boot-async</artifactId><version>0.0.1-SNAPSHOT</version><name>spring-boot-async</name><description>Spring Boot 中使用@Async实现异步调用，加速任务执行！</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

2、同步调用

下面通过一个简单示例来直观的理解什么是同步调用。

定义 Task 类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）。

package com.async;import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;import java.util.Random;/*** @author zhangshixing* @date 2021年10月29日 14:41*/@Slf4j
@Component
public class AsyncTasks {public static Random random = new Random();public void doTaskOne() throws Exception {log.info("开始做任务一");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务一，耗时：" + (end - start) + "毫秒");}public void doTaskTwo() throws Exception {log.info("开始做任务二");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务二，耗时：" + (end - start) + "毫秒");}public void doTaskThree() throws Exception {log.info("开始做任务三");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务三，耗时：" + (end - start) + "毫秒");}}

在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.concurrent.CompletableFuture;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {@Autowiredprivate AsyncTasks asyncTasks;@Testpublic void test() throws Exception {asyncTasks.doTaskOne();asyncTasks.doTaskTwo();asyncTasks.doTaskThree();}}

执行单元测试，可以看到类似如下输出：

开始做任务一
完成任务一，耗时：8577毫秒
开始做任务二
完成任务二，耗时：185毫秒
开始做任务三
完成任务三，耗时：3702毫秒

任务一、任务二、任务三顺序的执行完了，换言之doTaskOne、doTaskTwo、doTaskThree三个函数顺序的执行

完成。

3、异步调用

上述的同步调用虽然顺利的执行完了三个任务，但是可以看到执行时间比较长，若这三个任务本身之间不存在依赖

关系，可以并发执行的话，同步调用在执行效率方面就比较差，可以考虑通过异步调用的方式来并发执行。

在Spring Boot中，我们只需要通过使用@Async注解就能简单的将原来的同步函数变为异步函数，Task类改在为

如下模式：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;import java.util.Random;/*** @author zhangshixing* @date 2021年10月29日 15:28*/
@Slf4j
@Component
public class AsyncTasks1 {public static Random random = new Random();@Asyncpublic void doTaskOne() throws Exception {log.info("开始做任务一");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务一，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskTwo() throws Exception {log.info("开始做任务二");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务二，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskThree() throws Exception {log.info("开始做任务三");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务三，耗时：" + (end - start) + "毫秒");}}

为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：

package com.async;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;@EnableAsync
@SpringBootApplication
public class SpringBootAsyncApplication {public static void main(String[] args) {SpringApplication.run(SpringBootAsyncApplication.class, args);}}

在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.concurrent.CompletableFuture;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {@Autowiredprivate AsyncTasks1 asyncTasks1;@Testpublic void test1() throws Exception {asyncTasks1.doTaskOne();asyncTasks1.doTaskTwo();asyncTasks1.doTaskThree();}}

执行单元测试，可以看到类似如下输出：

开始做任务二
开始做任务一

此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：

  • 没有任何任务相关的输出

  • 有部分任务相关的输出

  • 乱序的任务相关的输出

原因是目前doTaskOne、doTaskTwo、doTaskThree三个函数的时候已经是异步执行了。主程序在异步调用

之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束

了，导致了不完整或是没有输出任务相关内容的情况。

注：@Async所修饰的函数不要定义为static类型，这样异步调用不会生效。

为了让doTaskOne、doTaskTwo、doTaskThree能正常结束，假设我们需要统计一下三个任务并发执行共耗时多

少，这就需要等到上述三个函数都完成调动之后记录时间，并计算结果。那么我们如何判断上述三个异步调用是否

已经执行完成呢？我们需要使用CompletableFuture<T>来返回异步调用的结果：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;import java.util.Random;
import java.util.concurrent.CompletableFuture;/*** @author zhangshixing* @date 2021年10月29日 15:47*/
@Slf4j
@Component
public class AsyncTasks2 {public static Random random = new Random();@Asyncpublic CompletableFuture<String> doTaskOne() throws Exception {log.info("开始做任务一");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务一，耗时：" + (end - start) + "毫秒");return CompletableFuture.completedFuture("任务一完成");}@Asyncpublic CompletableFuture<String> doTaskTwo() throws Exception {log.info("开始做任务二");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务二，耗时：" + (end - start) + "毫秒");return CompletableFuture.completedFuture("任务二完成");}@Asyncpublic CompletableFuture<String> doTaskThree() throws Exception {log.info("开始做任务三");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务三，耗时：" + (end - start) + "毫秒");return CompletableFuture.completedFuture("任务三完成");}}

按照如上方式改造一下其他两个异步函数之后，下面我们改造一下测试用例，让测试在等待完成三个异步调用之后

来做一些其他事情。

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.concurrent.CompletableFuture;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {@Autowiredprivate AsyncTasks2 asyncTasks2;@Testpublic void test2() throws Exception {long start = System.currentTimeMillis();CompletableFuture<String> task1 = asyncTasks2.doTaskOne();CompletableFuture<String> task2 = asyncTasks2.doTaskTwo();CompletableFuture<String> task3 = asyncTasks2.doTaskThree();CompletableFuture.allOf(task1, task2, task3).join();long end = System.currentTimeMillis();log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");}}

看看我们做了哪些改变：

  • 在测试用例一开始记录开始时间
  • 在调用三个异步函数的时候，返回CompletableFuture<String>类型的结果对象
  • 通过CompletableFuture.allOf(task1, task2, task3).join()实现三个异步任务都结束之前的阻塞效果
  • 三个任务都完成之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。

执行一下上述的单元测试，可以看到如下结果：

开始做任务二
开始做任务一
完成任务二，耗时：5375毫秒
开始做任务三
完成任务一，耗时：6298毫秒
完成任务三，耗时：9388毫秒
任务全部完成，总耗时：14780毫秒

可以看到，通过异步调用，让任务一、二、三并发执行，有效的减少了程序的总运行时间。

4、千万不要这样使用@Async注解

在实际的项目中，对于一些用时比较长的代码片段或者函数，我们可以采用异步的方式来执行，这样就不会影响整

体的流程了。比如我在一个用户请求中需要上传一些文件，但是上传文件的耗时会相对来说比较长，这个时候如果

上传文件的成功与否不影响主流程的话，就可以把上传文件的操作异步化，在spring boot中比较常见的方式就是

把要异步执行的代码片段封装成一个函数，然后在函数头使用@Async注解，就可以实现代码的异步执行（当然首

先得在启动类上加上@EnableAsync注解了）。

下面这里主要讲解使用 @Async 注解中遇到的一个坑。

那么这个坑是什么呢?就是如果你在同一个类里面调用一个自己的被@Async修饰的函数时，这个函数将不会被异

步执行，它依然是同步执行的，下面来演示一下。

记得在启动类上加上@EnableAsync注解。

package com.async;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;@EnableAsync
@SpringBootApplication
public class SpringBootAsyncApplication {public static void main(String[] args) {SpringApplication.run(SpringBootAsyncApplication.class, args);}}

然后再新建一个类Task，用来放三个异步任务doTaskOne、doTaskTwo、doTaskThree：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;import java.util.Random;/*** @author zhangshixing* @date 2021年10月29日 15:28*/
@Slf4j
@Component
public class AsyncTasks1 {public static Random random = new Random();@Asyncpublic void doTaskOne() throws Exception {log.info("开始做任务一");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务一，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskTwo() throws Exception {log.info("开始做任务二");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务二，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskThree() throws Exception {log.info("开始做任务三");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();log.info("完成任务三，耗时：" + (end - start) + "毫秒");}}

在单元测试类上注入Task，在测试用例上测试这三个方法的执行过程：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests1 {@AutowiredAsyncTasks1 asyncTasks1;@Testvoid contextLoads() throws Exception {asyncTasks1.doTaskOne();asyncTasks1.doTaskTwo();asyncTasks1.doTaskThree();Thread.sleep(10000);}
}

为了让这三个方法执行完，我们需要再单元测试用例上的最后一行加上一个延时，不然等函数退出了，异步任务还

没执行完。

我们启动看看效果：

开始做任务一
开始做任务二
完成任务二，耗时：314毫秒
开始做任务三
完成任务一，耗时：1365毫秒
完成任务三，耗时：3376毫秒

我们看到三个任务确实是异步执行的，那我们再看看错误的使用方法。

我们在测试类里面把这三个函数再写一遍，并在测试用例上调用测试类自己的方法：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.annotation.Async;import java.util.Random;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests2 {public static Random random = new Random();@Testvoid contextLoads() throws Exception {doTaskOne();doTaskTwo();doTaskThree();Thread.sleep(10000);}@Asyncpublic void doTaskOne() throws Exception {System.out.println("开始做任务一");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskTwo() throws Exception {System.out.println("开始做任务二");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");}@Asyncpublic void doTaskThree() throws Exception {System.out.println("开始做任务三");long start = System.currentTimeMillis();Thread.sleep(random.nextInt(10000));long end = System.currentTimeMillis();System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");}
}

我们再看看效果：

开始做任务一
完成任务一，耗时：1332毫秒
开始做任务二
完成任务二，耗时：7568毫秒
开始做任务三
完成任务三，耗时：1419毫秒

它们竟然是顺序执行的！也就是同步执行，并没有达到异步的效果。

5、用@Async会内存溢出?看看你的线程池配置了没?

上面我们介绍了如何使用@Async注解来创建异步任务，我可以用这种方法来实现一些并发操作，以加速任务的执

行效率。但是，如果只是如前文那样直接简单的创建来使用，可能还是会碰到一些问题。存在有什么问题呢?先来

思考下，下面的这个接口，通过异步任务加速执行的实现，是否存在问题或风险呢?

package com.async.controller;import com.async.AsyncTasks2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.concurrent.CompletableFuture;/*** @author zhangshixing* @date 2021年10月30日 9:15*/
@RestController
public class HelloController {@Autowiredprivate AsyncTasks2 asyncTasks;@GetMapping("/hello")public String hello() throws Exception {// 将可以并行的处理逻辑，拆分成三个异步任务同时执行CompletableFuture<String> task1 = asyncTasks.doTaskOne();CompletableFuture<String> task2 = asyncTasks.doTaskTwo();CompletableFuture<String> task3 = asyncTasks.doTaskThree();CompletableFuture.allOf(task1, task2, task3).join();return "Hello World";}
}

虽然，从单次接口调用来说，是没有问题的。但当接口被客户端频繁调用的时候，异步任务的数量就会大量增长：

3 x n（n为请求数量），如果任务处理不够快，就很可能会出现内存溢出的情况。那么为什么会内存溢出呢？根本

原因是由于Spring Boot默认用于异步任务的线程池是这样配置的：

在这里插入图片描述

图中我标出的两个重要参数是需要关注的：

  • queueCapacity：缓冲队列的容量，默认为INT的最大值（2的31次方-1）。

  • maxSize：允许的最大线程数，默认为INT的最大值（2的31次方-1）。

所以，默认情况下，一般任务队列就可能把内存给堆满了。所以，我们真正使用的时候，还需要对异步任务的执行

线程池做一些基础配置，以防止出现内存溢出导致服务不可用的问题。

5.1 配置默认线程池

默认线程池的配置很简单，只需要在配置文件中完成即可，主要有以下这些参数：

spring.task.execution.pool.core-size=2
spring.task.execution.pool.max-size=5
spring.task.execution.pool.queue-capacity=10
spring.task.execution.pool.keep-alive=60s
spring.task.execution.pool.allow-core-thread-timeout=true
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
spring.task.execution.thread-name-prefix=task-

具体配置含义如下：

  • spring.task.execution.pool.core-size：线程池创建时的初始化线程数，默认为8

  • spring.task.execution.pool.max-size：线程池的最大线程数，默认为int最大值

  • spring.task.execution.pool.queue-capacity：用来缓冲执行任务的队列，默认为int最大值

  • spring.task.execution.pool.keep-alive：线程终止前允许保持空闲的时间

  • spring.task.execution.pool.allow-core-thread-timeout：是否允许核心线程超时

  • spring.task.execution.shutdown.await-termination：是否等待剩余任务完成后才关闭应用

  • spring.task.execution.shutdown.await-termination-period：等待剩余任务完成的最大时间

  • spring.task.execution.thread-name-prefix：线程名的前缀，设置好了之后可以方便我们在日志中

    查看处理任务所在的线程池

5.2 动手试一试

首先，在没有进行线程池配置之前，可以先执行一下单元测试：

package com.async;import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.concurrent.CompletableFuture;@Slf4j
@SpringBootTest
class SpringBootAsyncApplicationTests {@Autowiredprivate AsyncTasks2 asyncTasks2;@Testpublic void test2() throws Exception {long start = System.currentTimeMillis();CompletableFuture<String> task1 = asyncTasks2.doTaskOne();CompletableFuture<String> task2 = asyncTasks2.doTaskTwo();CompletableFuture<String> task3 = asyncTasks2.doTaskThree();CompletableFuture.allOf(task1, task2, task3).join();long end = System.currentTimeMillis();log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");}}

由于默认线程池的核心线程数是8，所以3个任务会同时开始执行，日志输出是这样的：

开始做任务一
开始做任务二
开始做任务三
完成任务二，耗时：770毫秒
完成任务一，耗时：7859毫秒
完成任务三，耗时：9598毫秒
任务全部完成，总耗时：9611毫秒

接着，可以尝试在配置文件中增加如下的线程池配置

spring.task.execution.pool.core-size=2
spring.task.execution.pool.max-size=5
spring.task.execution.pool.queue-capacity=10
spring.task.execution.pool.keep-alive=60s
spring.task.execution.pool.allow-core-thread-timeout=true
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
spring.task.execution.thread-name-prefix=task-

日志输出的顺序会变成如下的顺序：

开始做任务二          
开始做任务一
完成任务二，耗时：185毫秒
开始做任务三
完成任务一，耗时：2762毫秒
完成任务三，耗时：4307毫秒
任务全部完成，总耗时：4510毫秒
  • 任务一和任务二会马上占用核心线程，任务三进入队列等待。
  • 任务二完成，释放出一个核心线程，任务三从队列中移出，并占用核心线程开始处理。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/284420.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

LeedCode刷题---二分查找类问题

LeedCode刷题---二分查找类问题

顾得泉&#xff1a;个人主页 个人专栏&#xff1a;《Linux操作系统》 《C/C》 《LeedCode刷题》 键盘敲烂&#xff0c;年薪百万&#xff01; 一、二分查找 题目链接&#xff1a;二分查找 题目描述 给定一个 n 个元素有序的&#xff08;升序&#xff09;整型数组 nums 和一…
阅读更多...
《LeetCode力扣练习》代码随想录——字符串（KMP算法学习补充——针对next数组构建的回退步骤进行解释）

《LeetCode力扣练习》代码随想录——字符串（KMP算法学习补充——针对next数组构建的回退步骤进行解释）

《LeetCode力扣练习》代码随想录——字符串&#xff08;KMP算法学习补充——针对next数组构建的回退步骤进行解释&#xff09; 学习路径 代码随想录&#xff1a;28. 实现 strStr() CSDN&#xff1a;【详解】KMP算法——多图&#xff0c;多例子&#xff08;c语言&#xff09; …
阅读更多...
unity—UGUI 点击按钮后，持续点击空格键会持续出发按钮

unity—UGUI 点击按钮后，持续点击空格键会持续出发按钮

在unity开发当中&#xff0c;使用UGUI开发&#xff0c;无论是你代码绑定按钮事件&#xff0c;还是在Inspector窗口直接拖拽绑定的事件&#xff0c;点击按钮事件后&#xff0c;按空格键都会再次执行相关的方法。 默认情况下&#xff0c;Unity将空格键映射为UI按钮的Submit提交操…
阅读更多...
【Hive_03】单行函数、聚合函数、窗口函数、自定义函数、炸裂函数

【Hive_03】单行函数、聚合函数、窗口函数、自定义函数、炸裂函数

1、函数简介2、单行函数2.1 算术运算函数2.2 数值函数2.3 字符串函数&#xff08;1&#xff09;substring 截取字符串&#xff08;2&#xff09;replace 替换&#xff08;3&#xff09;regexp_replace 正则替换&#xff08;4&#xff09;regexp 正则匹配&#xff08;5&#xff…
阅读更多...
如何应用基础故障编排?

如何应用基础故障编排?

基础故障编排是保障系统稳定性和可用性的关键环节。通过有效应用基础故障编排&#xff0c;组织能够更快速、更智能地应对系统故障&#xff0c;从而提升业务的可靠性和竞争力。本文将介绍如何应用基础故障编排! 1、选择合适的工具&#xff1a; 选择适合组织需求的基础故障编排工…
阅读更多...
CUDA C：线程、线程块与线程格

CUDA C：线程、线程块与线程格

相关阅读 CUDA Chttps://blog.csdn.net/weixin_45791458/category_12530616.html?spm1001.2014.3001.5482 第一百篇博客&#xff0c;写点不一样的。 当核函数在主机端被调用时&#xff0c;它会被转移到设备端执行&#xff0c;此时设备会根据核函数的调用格式产生对应的线程(…
阅读更多...
linux：认识权限信息、修改权限（含演示）

linux：认识权限信息、修改权限（含演示）

权限细节 总共分为10个槽位 如下图所示&#xff1a; 序号1&#xff0c;表示文件、文件夹的权限控制信息 序号2&#xff0c;表示文件、文件夹所属用户 序号3&#xff0c;表示文件、文件夹所属用户组 举例:drwxr-xr-x表示: 1、这是一个文件夹&#xff0c;首字母d表示&#x…
阅读更多...
C++面向对象（OOP）编程-模板

C++面向对象（OOP）编程-模板

本文主要讲解C的模板&#xff0c;其中包括模板的分类&#xff0c;函数模板和类模板&#xff0c;以及类模板与友元函数关系引起的几种关系。强调提供代码来搞懂C模板这一泛型编程手段。 目录 1 C模板 2 模板的本质 3 模板分类 4 函数模板 4.1 函数模板定义格式 4.2 函数模…
阅读更多...
欧盟健身单车出口BS EN ISO 20957安全报告测试

欧盟健身单车出口BS EN ISO 20957安全报告测试

固定的训练器材.第10部分:带固定轮或无自由飞轮的训练自行车.附加特定安全要求和试验方法 作为欧洲固定式健身器材&#xff08;儿童用固定式健身器材不在此范围&#xff09;通用安全要求和测试方法的标准&#xff0c;涉及固定式健身器材精度、使用场所分类定义、稳定性、安全间…
阅读更多...
SV-GWAS：基于首个番茄超级泛基因组图谱的结构变异

SV-GWAS：基于首个番茄超级泛基因组图谱的结构变异

全基因组关联分析&#xff08;GWAS&#xff09;是定位性状相关基因的有力工具&#xff0c;被广泛用于识别影响表型变异的候选基因组位点。然而&#xff0c;通常GWAS的研究过程主要依赖于单核苷酸变异&#xff08;SNPs&#xff09;的信息与表型相关联&#xff0c;而忽略了具有更…
阅读更多...
【WinDbg】学习以及在CTF中解题

【WinDbg】学习以及在CTF中解题

1、Windbg介绍 Windbg是一款Window强大的调试器&#xff0c;可以调试0和3环的程序。 在实际开发中&#xff0c;可以调试我们的错误程序&#xff0c;从而定位关键代码&#xff0c;进行程序代码修复。 WinDbg 是一种调试器工具&#xff0c;由微软公司开发&#xff0c;用于分析…
阅读更多...
SpringBoot使用@DS配置 多数据源 【mybatisplus druid datasource mysql】

SpringBoot使用@DS配置 多数据源 【mybatisplus druid datasource mysql】

项目最近需要使用多数据源&#xff0c;不同的mapper分别读取不同的链接&#xff0c;本项目使用了mybatisplus druid 来配置多数据源&#xff0c;基于mysql数据库。 目录 1.引入依赖 ​2.配置文件 application.yaml 3.Mapper中使用DS切换数据源 4.使用DS的注意事项 1.引入依…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023