获取双异步返回值时，如何保证主线程不阻塞？

在这里插入图片描述

目录

    • 一、前情提要
    • 二、JDK8的CompletableFuture
      • 1、ForkJoinPool
      • 2、从ForkJoinPool和ThreadPoolExecutor探索CompletableFuture和Future的区别
    • 三、通过CompletableFuture优化 “通过Future获取异步返回值”
      • 1、通过Future获取异步返回值关键代码
        • （1）将异步方法的返回值改为```Future<Integer>```，将返回值放到```new AsyncResult<>();```中；
        • （2）通过```Future<Integer>.get()```获取返回值：
      • 2、通过CompletableFuture获取异步返回值关键代码
        • （1）将异步方法的返回值改为 int
        • （2）通过```completableFuture.get()```获取返回值
      • 3、效率对比
        • （1）测试环境
        • （2）统计四种情况下10万数据入库时间
        • （3）设置核心线程数
          • 自定义ForkJoinPool线程池
          • 自定义线程池
        • （4）统计分析
    • 四、通过CompletableFuture.allOf解决阻塞主线程问题
      • 1、语法
      • 2、代码实例
    • 五、CompletableFuture中花俏的语法糖
      • 1、runAsync
      • 2、supplyAsync
    • 六、顺序执行异步任务
      • 1、thenRun
      • 2、thenAccept
      • 3、thenApply
    • 七、CompletableFuture合并任务
    • 八、CompletableFuture VS Future总结
      • 在BUG中磨砺，在优化中成长

大家好，我是哪吒。

一、前情提要

在上一篇文章中，使用双异步后，如何保证数据一致性？，通过Future获取异步返回值，轮询判断Future状态，如果执行完毕或已取消，则通过get()获取返回值，get()是阻塞的方法，因此会阻塞当前线程，如果通过new Runnable()执行get()方法，那么还是需要返回AsyncResult，然后再通过主线程去get()获取异步线程返回结果。

写法很繁琐，还会阻塞主线程。

下面是FutureTask异步执行流程图：

在这里插入图片描述

二、JDK8的CompletableFuture

1、ForkJoinPool

Java8中引入了CompletableFuture，它实现了对Future的全面升级，可以通过回调的方式，获取异步线程返回值。

CompletableFuture的异步执行通过ForkJoinPool实现， 它使用守护线程去执行任务。

ForkJoinPool在于可以充分利用多核CPU的优势，把一个任务拆分成多个小任务，把多个小任务放到多个CPU上并行执行，当多个小任务执行完毕后，再将其执行结果合并起来。

Future的异步执行是通过ThreadPoolExecutor实现的。

在这里插入图片描述

2、从ForkJoinPool和ThreadPoolExecutor探索CompletableFuture和Future的区别

  1. ForkJoinPool中的每个线程都会有一个队列，而ThreadPoolExecutor只有一个队列，并根据queue类型不同，细分出各种线程池；
  2. ForkJoinPool在使用过程中，会创建大量的子任务，会进行大量的gc，但是ThreadPoolExecutor不需要，因为ThreadPoolExecutor是任务分配平均的；
  3. ThreadPoolExecutor中每个异步线程之间是相互独立的，当执行速度快的线程执行完毕后，它就会一直处于空闲的状态，等待其它线程执行完毕；
  4. ForkJoinPool中每个异步线程之间并不是绝对独立的，在ForkJoinPool线程池中会维护一个队列来存放需要执行的任务，当线程自身任务执行完毕后，它会从其它线程中获取未执行的任务并帮助它执行，直至所有线程执行完毕。

因此，在多线程任务分配不均时，ForkJoinPool的执行效率更高。但是，如果任务分配均匀，ThreadPoolExecutor的执行效率更高，因为ForkJoinPool会创建大量子任务，并对其进行大量的GC，比较耗时。

三、通过CompletableFuture优化 “通过Future获取异步返回值”

1、通过Future获取异步返回值关键代码

（1）将异步方法的返回值改为Future<Integer>，将返回值放到new AsyncResult<>();中；
@Async("async-executor")
public void readXls(String filePath, String filename) {
    try {
    	// 此代码为简化关键性代码
        List<Future<Integer>> futureList = new ArrayList<>();
        for (int time = 0; time < times; time++) {
            Future<Integer> sumFuture = readExcelDataAsyncFutureService.readXlsCacheAsync();
            futureList.add(sumFuture);
        }
    }catch (Exception e){
        logger.error("readXlsCacheAsync---插入数据异常：",e);
    }
}

@Async("async-executor")
public Future<Integer> readXlsCacheAsync() {
    try {
        // 此代码为简化关键性代码
        return new AsyncResult<>(sum);
    }catch (Exception e){
        return new AsyncResult<>(0);
    }
}
（2）通过Future<Integer>.get()获取返回值：
public static boolean getFutureResult(List<Future<Integer>> futureList, int excelRow) {
    int[] futureSumArr = new int[futureList.size()];
    for (int i = 0;i<futureList.size();i++) {
        try {
            Future<Integer> future = futureList.get(i);
            while (true) {
                if (future.isDone() && !future.isCancelled()) {
                    Integer futureSum = future.get();
                    logger.info("获取Future返回值成功"+"----Future:" + future
                            + ",Result:" + futureSum);
                    futureSumArr[i] += futureSum;
                    break;
                } else {
                    logger.info("Future正在执行---获取Future返回值中---等待3秒");
                    Thread.sleep(3000);
                }
            }
        } catch (Exception e) {
            logger.error("获取Future返回值异常: ", e);
        }
    }
    
    boolean insertFlag = getInsertSum(futureSumArr, excelRow);
    logger.info("获取所有异步线程Future的返回值成功，Excel插入结果="+insertFlag);
    return insertFlag;
}

2、通过CompletableFuture获取异步返回值关键代码

（1）将异步方法的返回值改为 int
@Async("async-executor")
public void readXls(String filePath, String filename) {
	List<CompletableFuture<Integer>> completableFutureList = new ArrayList<>();
   	for (int time = 0; time < times; time++) {
    	// 此代码为简化关键性代码
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
	        @Override
	        public Integer get() {
	            return readExcelDbJdk8Service.readXlsCacheAsyncMybatis();
	        }
	    }).thenApply((result) -> {// 回调方法
	        return thenApplyTest2(result);// supplyAsync返回值 * 1
	    }).thenApply((result) -> {
	        return thenApplyTest5(result);// thenApply返回值 * 1
	    }).exceptionally((e) -> { // 如果执行异常:
	        logger.error("CompletableFuture.supplyAsync----异常：", e);
	        return null;
	    });
	
	    completableFutureList.add(completableFuture);
    }
}

@Async("async-executor")
public int readXlsCacheAsync() {
    try {
        // 此代码为简化关键性代码
        return sum;
    }catch (Exception e){
        return -1;
    }
}
（2）通过completableFuture.get()获取返回值
public static boolean getCompletableFutureResult(List<CompletableFuture<Integer>> list, int excelRow){
    logger.info("通过completableFuture.get()获取每个异步线程的插入结果----开始");

    int sum = 0;
    for (int i = 0; i < list.size(); i++) {
        Integer result = list.get(i).get();
        sum += result;
    }

    boolean insertFlag = excelRow == sum;
    logger.info("全部执行完毕，excelRow={}，入库={}, 数据是否一致={}",excelRow,sum,insertFlag);
    return insertFlag;
}

3、效率对比

（1）测试环境
  1. 12个逻辑处理器的电脑；
  2. Excel中包含10万条数据；
  3. Future的自定义线程池，核心线程数为24；
  4. ForkJoinPool的核心线程数为24；
（2）统计四种情况下10万数据入库时间
  1. 不获取异步返回值
  2. 通过Future获取异步返回值
  3. 通过CompletableFuture获取异步返回值，默认ForkJoinPool线程池的核心线程数为本机逻辑处理器数量，测试电脑为12；
  4. 通过CompletableFuture获取异步返回值，修改ForkJoinPool线程池的核心线程数为24。

备注：因为CompletableFuture不阻塞主线程，主线程执行时间只有2秒，表格中统计的是异步线程全部执行完成的时间。

（3）设置核心线程数

将核心线程数CorePoolSize设置成CPU的处理器数量，是不是效率最高的？

// 获取CPU的处理器数量
int curSystemThreads = Runtime.getRuntime().availableProcessors() * 2;// 测试电脑是24

因为在接口被调用后，开启异步线程，执行入库任务，因为测试机最多同时开启24线程处理任务，故将10万条数据拆分成等量的24份，也就是10万/24 = 4166，那么我设置成4200，是不是效率最佳呢？

测试的过程中发现，好像真的是这样的。

自定义ForkJoinPool线程池
@Autowired
@Qualifier("asyncTaskExecutor")
private Executor asyncTaskExecutor;

@Override
public void readXls(String filePath, String filename) {
 	List<CompletableFuture<Integer>> completableFutureList = new ArrayList<>();
    for (int time = 0; time < times; time++) {
		CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
	        @Override
	        public Integer get() {
	            try {
	                return readExcelDbJdk8Service.readXlsCacheAsync(sheet, row, start, finalEnd, insertBuilder);
	            } catch (Exception e) {
	                logger.error("CompletableFuture----readXlsCacheAsync---异常：", e);
	                return -1;
	            }
	        };
	    },asyncTaskExecutor);
	
	    completableFutureList.add(completableFuture);
	}

	// 不会阻塞主线程
    CompletableFuture.allOf(completableFutureList.toArray(new CompletableFuture[completableFutureList.size()])).whenComplete((r,e) -> {
        try {
            int insertSum = getCompletableFutureResult(completableFutureList, excelRow);
        } catch (Exception ex) {
            return;
        }
    });
}
自定义线程池
/**
 * 自定义异步线程池
 */
@Bean("asyncTaskExecutor")
public AsyncTaskExecutor asyncTaskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    //设置线程名称
    executor.setThreadNamePrefix("asyncTask-Executor");
    //设置最大线程数
    executor.setMaxPoolSize(200);
    //设置核心线程数
    executor.setCorePoolSize(24);
    //设置线程空闲时间，默认60
    executor.setKeepAliveSeconds(200);
    //设置队列容量
    executor.setQueueCapacity(50);
    /**
     * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
     * 通常有以下四种策略：
     * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
     * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
     * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
     * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
     */
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
}

在这里插入图片描述

（4）统计分析

效率对比：

③通过CompletableFuture获取异步返回值（12线程） < ②通过Future获取异步返回值 < ④通过CompletableFuture获取异步返回值（24线程） < ①不获取异步返回值

不获取异步返回值时性能最优，这不废话嘛~

核心线程数相同的情况下，CompletableFuture的入库效率要优于Future的入库效率，10万条数据大概要快4秒钟，这还是相当惊人的，优化的价值就在于此。

在这里插入图片描述

四、通过CompletableFuture.allOf解决阻塞主线程问题

1、语法

CompletableFuture.allOf(CompletableFuture的可变数组).whenComplete((r,e) -> {})。

2、代码实例

getCompletableFutureResult方法在 “3.2.2 通过completableFuture.get()获取返回值”。

// 不会阻塞主线程
CompletableFuture.allOf(completableFutureList.toArray(new 		CompletableFuture[completableFutureList.size()])).whenComplete((r,e) -> {
    logger.info("全部执行完毕，解决主线程阻塞问题~");
    try {
        int insertSum = getCompletableFutureResult(completableFutureList, excelRow);
    } catch (Exception ex) {
        logger.error("全部执行完毕，解决主线程阻塞问题，异常：", ex);
        return;
    }
});

// 会阻塞主线程
//getCompletableFutureResult(completableFutureList, excelRow);

logger.info("CompletableFuture----会阻塞主线程吗？");

在这里插入图片描述

五、CompletableFuture中花俏的语法糖

1、runAsync

runAsync 方法不支持返回值。

可以通过runAsync执行没有返回值的异步方法。

不会阻塞主线程。

// 分批异步读取Excel内容并入库
int finalEnd = end;
CompletableFuture.runAsync(() -> readExcelDbJdk8Service.readXlsCacheAsyncMybatis();

2、supplyAsync

supplyAsync也可以异步处理任务，传入的对象实现了Supplier接口。将Supplier作为参数并返回CompletableFuture结果值，这意味着它不接受任何输入参数，而是将result作为输出返回。

会阻塞主线程。

supplyAsync()方法关键代码：

int finalEnd = end;
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        return readExcelDbJdk8Service.readXlsCacheAsyncMybatis();
    }
});

@Override
public int readXlsCacheAsyncMybatis() {
    // 不为人知的操作
   	// 返回异步方法执行结果即可
	return 100;
}

六、顺序执行异步任务

1、thenRun

thenRun()不接受参数，也没有返回值，与runAsync()配套使用，恰到好处。

// JDK8的CompletableFuture
CompletableFuture.runAsync(() -> readExcelDbJdk8Service.readXlsCacheAsyncMybatis())
.thenRun(() -> logger.info("CompletableFuture----.thenRun()方法测试"));

在这里插入图片描述

2、thenAccept

thenAccept()接受参数，没有返回值。

supplyAsync + thenAccept

  1. 异步线程顺序执行
  2. supplyAsync的异步返回值，可以作为thenAccept的参数使用
  3. 不会阻塞主线程
CompletableFuture.supplyAsync(new Supplier<Integer>() {
    @Override
    public Integer get() {
        return readExcelDbJdk8Service.readXlsCacheAsyncMybatis();
    }
}).thenAccept(x -> logger.info(".thenAccept()方法测试：" + x));

在这里插入图片描述

但是，此时无法通过completableFuture.get()获取supplyAsync的返回值了。

3、thenApply

thenApply在thenAccept的基础上，可以再次通过completableFuture.get()获取返回值。

supplyAsync + thenApply，典型的链式编程。

  1. 异步线程内方法顺序执行
  2. supplyAsync 的返回值，作为第 1 个thenApply的参数，进行业务处理
  3. 第 1 个thenApply的返回值，作为第 2 个thenApply的参数，进行业务处理
  4. 最后，通过future.get()方法获取最终的返回值
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
	@Override
    public Integer get() {
        return readExcelDbJdk8Service.readXlsCacheAsyncMybatis();
    }
}).thenApply((result) -> {
    return thenApplyTest2(result);// supplyAsync返回值 * 2
}).thenApply((result) -> {
    return thenApplyTest5(result);// thenApply返回值 * 5
});

logger.info("readXlsCacheAsyncMybatis插入数据 * 2 * 5 = " + completableFuture.get());

在这里插入图片描述

七、CompletableFuture合并任务

  1. thenCombine，多个异步任务并行处理，有返回值，最后合并结果返回新的CompletableFuture对象；
  2. thenAcceptBoth，多个异步任务并行处理，无返回值；
  3. acceptEither，多个异步任务并行处理，无返回值；
  4. applyToEither，，多个异步任务并行处理，有返回值；

CompletableFuture合并任务的代码实例，这里就不多赘述了，一些语法糖而已，大家切记陷入低水平勤奋的怪圈。

八、CompletableFuture VS Future总结

本文中以下几个方面对比了CompletableFuture和Future的差异：

  1. ForkJoinPool和ThreadPoolExecutor的实现原理，探索了CompletableFuture和Future的差异；
  2. 通过代码实例的形式简单介绍了CompletableFuture中花俏的语法糖；
  3. 通过CompletableFuture优化了 “通过Future获取异步返回值”；
  4. 通过CompletableFuture.allOf解决阻塞主线程问题。

Future提供了异步执行的能力，但Future.get()会通过轮询的方式获取异步返回值，get()方法还会阻塞主线程。

轮询的方式非常消耗CPU资源，阻塞的方式显然与我们的异步初衷背道而驰。

JDK8提供的CompletableFuture实现了Future接口，添加了很多Future不具备的功能，比如链式编程、异常处理回调函数、获取异步结果不阻塞不轮询、合并异步任务等。

获取异步线程结果后，我们可以通过添加事务的方式，实现Excel入库操作的数据一致性。

异步多线程情况下如何实现事务？

有的小伙伴可能会说：

这还不简单？添加@Transactional注解，如果发生异常或入库数据量不符，直接回滚就可以了~

那么，真的是这样吗？我们下期见~


在BUG中磨砺，在优化中成长

使用双异步后，从 191s 优化到 2s

增加索引 + 异步 + 不落地后，从 12h 优化到 15 min

使用懒加载 + 零拷贝后，程序的秒开率提升至99.99%

性能优化2.0，新增缓存后，程序的秒开率不升反降


🏆文章收录于：100天精通Java从入门到就业

全网最细Java零基础手把手入门教程，系列课程包括：Java基础、Java8新特性、Java集合、高并发、性能优化等，适合零基础和进阶提升的同学。

🏆哪吒多年工作总结：Java学习路线总结，搬砖工逆袭Java架构师。

华为OD机试 2023B卷题库疯狂收录中，刷题点这里

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

k8s的图形化工具--rancher

k8s的图形化工具--rancher

什么是rancher&#xff1f; rancher是一个开源的企业级多集群的k8s管理平台 rancher和k8s的区别 都是为了容器的调度和编排系统&#xff0c;但是rancher不仅能够调度&#xff0c;还能管理k8s集群&#xff0c;自带监控&#xff08;普罗米修斯&#xff09; 实验部署 实验架构…
阅读更多...
大语言模型推理提速：TensorRT-LLM 高性能推理实践

大语言模型推理提速：TensorRT-LLM 高性能推理实践

作者&#xff1a;顾静 TensorRT-LLM 如何提升 LLM 模型推理效率 大型语言模型&#xff08;Large language models,LLM&#xff09;是基于大量数据进行预训练的超大型深度学习模型。底层转换器是一组神经网络&#xff0c;这些神经网络由具有 self-attention 的编码器和解码器组…
阅读更多...
基于Java+SpringMvc+vue+element实现上海汽车博物馆平台

基于Java+SpringMvc+vue+element实现上海汽车博物馆平台

基于JavaSpringMvcvueelement实现上海汽车博物馆平台 &#x1f345; 作者主页 央顺技术团队 &#x1f345; 欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; &#x1f345; 文末获取源码联系方式 &#x1f4dd; &#x1f345; 查看下方微信号获取联系方式 承接各种定制系统 …
阅读更多...
《Visual Tree Convolutional Neural Network in Image Classification》阅读笔记

《Visual Tree Convolutional Neural Network in Image Classification》阅读笔记

论文标题 《Visual Tree Convolutional Neural Network in Image Classification》 图像分类中的视觉树卷积神经网络 作者 Yuntao Liu、Yong Dou、Ruochun Jin 和 Peng Qiao 来自国防科技大学并行和分布式处理国家实验室 初读 摘要 问题&#xff1a; 在图像分类领域&…
阅读更多...
JCL中常用的DD语句

JCL中常用的DD语句

JCL中的DD语句介绍 ​ DD语句&#xff0c;主要定义数据集用的&#xff0c;也叫做DATASET DEFINE&#xff0c;分为定义设备的UNIT、VOLUME、SPACE&#xff0c;定义数据集的DSN、DISP、DCB,详细可以看英文版的《MVS JCL Reference》&#xff0c;还有一些特殊的DD&#xff0c;暂时…
阅读更多...
hdu1195 Open the lock 双向广度优先搜索

hdu1195 Open the lock 双向广度优先搜索

D-BFS 双向广度优先搜索 从起点和终点同时开始搜索&#xff0c;直到两个搜索的点相交&#xff0c;得到最短路径 Code: // D-BFS //by:MuQY #include <iostream> #include <algorithm> #include <string.h> #include <queue> #include <string> …
阅读更多...
redis + 拦截器 ：防止数据重复提交

redis + 拦截器 ：防止数据重复提交

1.项目用到,不是核心 我们干系统开发,不免要考虑一个点&#xff0c;数据的重复提交。 我想我们之前如果要校验数据重复提交要求&#xff0c;会怎么干?会在业务层&#xff0c;对数据库操作&#xff0c;查询数据是否存在,存在就禁止插入数据; 但是吧,我们每次crud操作都会连接…
阅读更多...
Conda 使用environment.yml创建一个新的Python项目

Conda 使用environment.yml创建一个新的Python项目

Conda系列&#xff1a; 翻译: Anaconda 与 miniconda的区别Miniconda介绍以及安装Conda python运行的包和环境管理 入门Conda python管理环境environments 一 从入门到精通Conda python管理环境environments 二 从入门到精通Conda python管理环境environments 三 从入门到精通…
阅读更多...
luceda ipkiss教程 58：输出器件的版图和三维模型

luceda ipkiss教程 58：输出器件的版图和三维模型

在ipkiss中&#xff0c;通过visualize_3d_povray可以输出包含器件的三维模型参数的.pov文件&#xff0c;再通过POV-Ray&#xff08;免费软件&#xff0c;下载地址&#xff1a;https://www.povray.org/download/&#xff09;就可以查看器件的三维模型。 如&#xff1a; 代码如…
阅读更多...
账号定位基础

账号定位基础

1.账号定位流程 定位体系 &#xff08;1&#xff09;商业定位 ①商业定位-带货 ②商业定位-引流 ③商业定位-接广告 ④商业定位-直播打赏 &#xff08;2&#xff09;内容定位 内容定位分为&#xff1a;主题IP、人物IP &#xff08;2-1&#xff09;主题IP ①有用处 ②有兴…
阅读更多...
144基于matlab的平面桁架结构的总体刚度矩阵计算

144基于matlab的平面桁架结构的总体刚度矩阵计算

基于matlab的平面桁架结构的总体刚度矩阵计算&#xff0c;最后以图形形式显示出桁架结构&#xff0c;程序已调通&#xff0c;可直接运行。 144matlab 平面桁架 有限元分析 总体刚度 (xiaohongshu.com)
阅读更多...
0125-2-Vue深入学习1—mustache模板引擎原理

0125-2-Vue深入学习1—mustache模板引擎原理

[mustache] 是 “胡子”的意思&#xff0c;因为它的嵌入标记 {{ }} 旋转过来很像[胡子]&#xff0c;Vue中的 {{ }} 语法也引用了mustache&#xff0c;这也是我深入学习的目的。 1、原始js方式使 数据 变为视图 <ul id"list"></ul><script>var arr …
阅读更多...
Git常用命令介绍

Git常用命令介绍

Git 是一个开源的分布式版本控制系统&#xff0c;用于敏捷高效地处理任何或小或大的项目 一、Git的安装 安装包下载地址&#xff1a;https://gitforwindows.org/ 国内的镜像地址&#xff1a;https://npm.taobao.org/mirrors/git-for-windows/ 完成安装之后&#xff0c;在开…
阅读更多...
面试常问的Spring AOP底层原理

面试常问的Spring AOP底层原理

AOP底层原理可以划分成四个阶段&#xff1a;创建代理对象阶段、拦截目标对象阶段、调用代理对象阶段、调用目标对象阶段 第一阶段&#xff1a;创建代理对象阶段 通过getBean&#xff08;&#xff09;方法创建Bean实例根据AOP的配置匹配目标类的类名&#xff0c;判断是否满足切…
阅读更多...
wfuzz网站模糊测试

wfuzz网站模糊测试

https://github.com/xmendez/wfuzz Wfuzz: The Web fuzzer — Wfuzz 2.1.4 documentatio n 一、wfuzz介绍 WFuzz是基于Python开发的 Web安全模糊测试工具。可以将其理解为Fuzz一款暴力破解工具。根据用户提供的字典&#xff0c;获取web站点的敏感目录和信息。 Wfuzz 提供了一个…
阅读更多...
小程序样例3：根据日历创建待办事项

小程序样例3：根据日历创建待办事项

基本功能 1、待办事项查看 选择不同的日期显示不同的待办: 2、选择日期后 新增事项&#xff1a; 3. 点击事项&#xff0c;查看详情 4、删除事项&#xff1a;删除事项3之后&#xff0c;剩余事项2 5、点击日期可以选择更多的月&#xff1a; 实现思路&#xff1a; 1、数据结构&a…
阅读更多...
开始学习Vue2（axios和Vuex）

开始学习Vue2（axios和Vuex）

一、Axios 1、Axios 简介 Axios 是一个基于 promise 网络请求库 &#xff0c;作用于node.j s 和浏 览器中。它是 isomorphic 的(即同一套代码可以运行在浏览器 和 node.js 中)。在服务端它使用原生 node.js http 模块, 而在 客户端 (浏览端) 则使用 XMLHttpRequests。 …
阅读更多...
通俗易懂理解SegNet语义分割模型

通俗易懂理解SegNet语义分割模型

重要说明&#xff1a;本文从网上资料整理而来&#xff0c;仅记录博主学习相关知识点的过程&#xff0c;侵删。 一、参考资料 深度学习之图像分割—— SegNet基本思想和网络结构以及论文补充 一文带你读懂 SegNet&#xff08;语义分割&#xff09; 二、相关介绍 1. 上采样(…
阅读更多...
关于爬虫爬取网页时遇到的乱码问题的解决方案。

关于爬虫爬取网页时遇到的乱码问题的解决方案。

目录 前言解决措施 前言 最近&#xff0c;我像爬取一下三国演义这本书籍的全部内容。 网站的网址为&#xff1a;https://www.shicimingju.com/book/sanguoyanyi.html 但是我爬取出来的结果是这样的 会遇到乱码。 经过我多方面的调试发现&#xff0c;就是网页的编码和我pycha…
阅读更多...
mysql8版本批量造4000个数据SQL

mysql8版本批量造4000个数据SQL

需求&#xff1a; 测试工作中修改单需要构造单元下4000个组合的数据&#xff0c;写个博客来记录&#xff0c;其他类似的可以举一反三。 具体sql&#xff1a; 实现1个产品1个单元下插入4000个组合数据 思路&#xff1a; 在MySQL 8中实现循环插入4000条具有不同主键的记录&a…
阅读更多...
最新文章

Copyright @ 2022~2023