Java 多线程优化与测试

原创 已于 2023-08-09 16:57:19 修改 · 439 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
于 2023-06-05 13:49:21 首次发布

耗时对比

t1: 耗时: 885739
t2: 耗时: 58548 | 耗时: 39284 | 耗时: 37096
t2_1: 耗时: 46900 | 耗时: 42319 | 耗时: 32841
t3: 耗时: 63848 | 耗时: 64668 | 耗时: 60082
t3_1: 耗时: 108355 | 耗时: 153665 | 耗时: 100006 

/**
     * 单线程
     */
    @Operation(summary = "单线程")
    @GetMapping("/t1")
    public AjaxResult<?> t1(){
        movieInformationUtil.main1();
        return AjaxResult.success();
    }

    /**
     * 多线程 使用切块分区使用多线程
     */
    @Operation(summary = "多线程 使用切块分区使用多线程")
    @GetMapping("/t2")
    public AjaxResult<?> t2(){
        movieInformationUtil.main2();
        return AjaxResult.success();
    }

    /**
     * 多线程 main2优化 使用批量插入
     */
    @Operation(summary = "多线程 main2优化 使用批量插入")
    @GetMapping("/t2_1")
    public AjaxResult<?> t2_1(){
        movieInformationUtil.main2_1();
        return AjaxResult.success();
    }

    /**
     * 多线程 可能会有遗漏 会有bug
     */
    @Operation(summary = "多线程 可能会有遗漏 会有bug")
    @GetMapping("/t3")
    public AjaxResult<?> t3(){
        movieInformationUtil.main3();
        return AjaxResult.success();
    }

    /**
     * 多线程 使用CountDownLatch等待全部线程执行完毕 解决main3遗漏问题
     */
    @Operation(summary = "多线程 使用CountDownLatch等待全部线程执行完毕 解决main3遗漏问题")
    @GetMapping("/t3_1")
    public AjaxResult<?> t3_1(){
        movieInformationUtil.main3_1();
        return AjaxResult.success();
    }

<!--多线程谷歌list分割-->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>32.0.0-jre</version>
</dependency>

package com.cn.crawlers.movieCrawler;

import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.cn.domain.MovieInformation;
import com.cn.domain.MovieType;
import com.cn.service.MovieInformationService;
import com.cn.service.MovieTypeService;
import com.cn.utils.ImgUtil;
import com.google.common.collect.Lists;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
     * 单线程
     */
    public void main1() {
        int[] i = {0};
        long l1 = System.currentTimeMillis();
        // 获取电影信息
        QueryWrapper<MovieInformation> informationQueryWrapper = new QueryWrapper<>();
        List<MovieInformation> movieList = movieInformationService.list(informationQueryWrapper);

        for (MovieInformation item : movieList) {
            //String base64 = ImgUtil.imageToBase64(imgUrl);
            //item.setCoverUrlBase64(StringUtils.isBlank(base64) ? imgUrl : base64);
            try {
                Thread.sleep(10);
                item.setCoverUrlBase64(String.valueOf(System.currentTimeMillis()));
                movieInformationService.updateById(item);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log.info("当前数量{},线程名称: {}", i[0]++, Thread.currentThread().getName());
        }

        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("耗时: " + l);
    }

    /**
     * 多线程 使用切块分区使用多线程
     */
    public void main2() {
        int[] i = {0};
        long l1 = System.currentTimeMillis();
        // 获取电影信息
        QueryWrapper<MovieInformation> informationQueryWrapper = new QueryWrapper<>();
        List<MovieInformation> movieList = movieInformationService.list(informationQueryWrapper);

        // 获取分区大小
        List<List<MovieInformation>> partition = Lists.partition(movieList, movieList.size() / 20);

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(partition.size());
        CountDownLatch countDownLatch = new CountDownLatch(partition.size());

        for (List<MovieInformation> items : partition) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    for (MovieInformation item : items) {
                        String imgUrl = item.getCoverUrl();
                        try {
                            Thread.sleep(10);
                            item.setCoverUrlBase64(String.valueOf(System.currentTimeMillis()));
                            movieInformationService.updateById(item);
                            log.info("当前数量{},线程名称: {}", i[0]++, Thread.currentThread().getName());
                        } catch (Exception e) {
                            log.error("出bug了 -- {}", imgUrl);
                        }
                    }
                    countDownLatch.countDown();
                }
            });
        }

        // 等待所有的线程执行完毕
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        // 关闭线程池
        executorService.shutdown();
        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("耗时: " + l);
    }

    /**
     * 多线程 main2优化 使用批量插入
     */
    public void main2_1() {
        int[] i = {0};
        long l1 = System.currentTimeMillis();
        // 获取电影信息
        QueryWrapper<MovieInformation> informationQueryWrapper = new QueryWrapper<>();
        List<MovieInformation> movieList = movieInformationService.list(informationQueryWrapper);

        // 获取分区大小
        List<List<MovieInformation>> partition = Lists.partition(movieList, movieList.size() / 20);

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(partition.size());
        CountDownLatch countDownLatch = new CountDownLatch(partition.size());

        for (List<MovieInformation> items : partition) {
            executorService.execute(new Runnable() {
                List<MovieInformation> addList = new ArrayList<>();

                @Override
                public void run() {
                    for (MovieInformation item : items) {
                        String imgUrl = item.getCoverUrl();
                        try {
                            Thread.sleep(10);
                            item.setCoverUrlBase64(String.valueOf(System.currentTimeMillis()));
                            addList.add(item);
                            log.info("当前数量{},线程名称: {}", i[0]++, Thread.currentThread().getName());
                        } catch (Exception e) {
                            log.error("出bug了 -- {}", imgUrl);
                        }
                    }
                    log.info("SQL更新了,更新数量{}", addList.size());
                    movieInformationService.updateBatchById(addList);
                    countDownLatch.countDown();
                }
            });
        }

        // 等待所有的线程执行完毕
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        // 关闭线程池
        executorService.shutdown();
        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("耗时: " + l);
    }


    /**
     * 多线程 可能会有遗漏 会有bug
     */
    public void main3() {
        int[] i = {0};
        long l1 = System.currentTimeMillis();
        // 获取电影信息
        QueryWrapper<MovieInformation> informationQueryWrapper = new QueryWrapper<>();
        List<MovieInformation> movieList = movieInformationService.list(informationQueryWrapper);

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        List<Future<MovieInformation>> futures = new ArrayList<>();

        try {
            // 提交所有任务，并获取所有任务的执行结果
            for (MovieInformation item : movieList) {
                Future<MovieInformation> submit = executorService.submit(() -> {
                    Thread.sleep(10);
                    item.setCoverUrlBase64(String.valueOf(System.currentTimeMillis()));
                    log.info("当前数量{},线程名称: {}", i[0]++, Thread.currentThread().getName());
                    return item;
                });
                futures.add(submit);
            }

            for (Future<MovieInformation> future : futures) {
                MovieInformation movieInformation = future.get();
                movieInformationService.updateById(movieInformation);
            }

        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }

        // 关闭线程池
        executorService.shutdown();
        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("耗时: " + l);
    }

    /**
     * 多线程 使用CountDownLatch等待全部线程执行完毕 解决main3遗漏问题
     */
    public void main3_1() {
        int[] i = {0};
        long l1 = System.currentTimeMillis();
        // 获取电影信息
        QueryWrapper<MovieInformation> informationQueryWrapper = new QueryWrapper<>();
        List<MovieInformation> movieList = movieInformationService.list(informationQueryWrapper);

        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(20);

        List<Future<MovieInformation>> futures = new ArrayList<>();
        CountDownLatch countDownLatch = new CountDownLatch(movieList.size());

        try {
            // 提交所有任务，并获取所有任务的执行结果
            for (MovieInformation item : movieList) {
                Future<MovieInformation> submit = executorService.submit(() -> {
                    Thread.sleep(10);
                    item.setCoverUrlBase64(String.valueOf(System.currentTimeMillis()));
                    countDownLatch.countDown();
                    log.info("当前数量{},线程名称: {}", i[0]++, Thread.currentThread().getName());
                    return item;
                });
                futures.add(submit);
            }

            // 等待所有的线程执行完毕
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            for (Future<MovieInformation> future : futures) {
                MovieInformation movieInformation = future.get();
                movieInformationService.updateById(movieInformation);
            }

        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }

        // 关闭线程池
        executorService.shutdown();
        long l2 = System.currentTimeMillis();
        long l = l2 - l1;
        System.out.println("耗时: " + l);
    }

[Java多线程性能测试]Executors+Runnable+CyclicBarrier+HttpClient性能测试自动化工具
fen_fen的专栏
04-25 2087
d Java多线程Executors+Runnable+CyclicBarrier+HttpClient性能测试自动化工具 作者：HMF 2021/04/17 1.JAVA 性能测试自动化架构图 2.Java 性能测试背景 2.1性能测试代码目的 1、能够用代码编写自动化工具对客户端进行性能测试。 2、减少挨个执行，收集和统计数据的人工成本。 1).减少挨个执行性能命令的人工成本。 2).减少人工收集数据和统计数据的人工成本。 3).减少从管理平台新增客户端，下载客户端，安装客户.
java多线程测试websocket demo(使用文件流)
weixin_44808225的博客
01-25 1623
这个demo主要是利用Java多线程来测试WebSocket通信。首先，创建一个WebSocket服务器和客户端，然后使用多线程来模拟多个客户端同时连接服务器进行通信。通过多线程测试，可以验证WebSocket通信的并发性能和稳定性。同时，可以通过多线程测试来模拟不同场景下的并发请求，以便对WebSocket服务器进行压力测试和性能优化。整个demo会包括创建WebSocket服务器和客户端的代码，以及多线程测试的代码实现。通过这个demo，可以更好地了解WebSocket通信的多线程测试方法和实现。
Java——关于实现多线程的测试小题，帮助我们更好的理解多线程的使用方法
m0_52479012的博客
10-25 1407
多线程习题小结，新手必须掌握，接近于真实的开发环境
【JavaSE】多线程常见案例
weixin_44258092的博客
04-11 1238
首先介绍了懒汉模式的多线程实现方式，其次介绍了标准库中的阻塞队列、定时器和线程池的使用，并利用编程实现了基于阻塞队列的生产者消费者模型、功能简单的定时器和线程池。
java多线程-1-测试一个多线程程序
m0_75138009的博客
10-01 931
多线程：在等待线程的时间，处理其他线程，提高计算机处理效率以减小资源的占用。线程：操作系统能够进行运算调度的最小单位，包含在进程之中。进程：程序的基本执行实体。测试线程1: 花下的晚风。测试线程1: 花下的晚风。测试线程1: 花下的晚风。测试线程1: 花下的晚风。测试线程2: 花下的晚风。测试线程2: 花下的晚风。测试线程1: 花下的晚风。测试线程2: 花下的晚风。测试线程2: 花下的晚风。测试线程1: 花下的晚风。测试线程1: 花下的晚风。测试线程1: 花下的晚风。测试线程2: 花下的晚风。
Java多线程：五个常见陷阱与性能优化实战（附压力测试数据）
最新发布
gg15935728460的博客
06-30 1730
学习编程是一个循序渐进的过程，会遇到挫折。遇到难题时，分解问题，逐个击破，不要轻易放弃。享受解决问题的乐趣。Java生态非常活跃（尤其是Spring生态），新技术、新版本不断涌现。保持好奇心和学习习惯。尝试回答别人的问题（能巩固知识），参与开源项目（即使是修复小bug或文档），是提升的绝佳途径。这是永恒不变的真理。再多的理论，不写代码都是空谈。写代码是检验理解的唯一标准。学习Java就像种一棵树🌳，基础是根，面向对象是主干，核心API是枝干，框架和工具是繁茂的枝叶。
Java21和Java8性能优化详细对比
驴大毛的博客
11-15 3629
本文将详细对比java21和java8这两个版本在性能优化方面的差异
JVM——基准测试框架 JMH 拓展
从知识输入到知识输出
05-21 1006
JVM——基准测试框架 JMH 拓展：从基础到实战的深度解析
Java多线程——并发程序的测试
松仔Log的博客
02-21 1324
相比于串行程序，并发程序潜在的错误发生是随机的，并发测试分为。
Java如何通过Thread创建多线程测试程序（不包括线程池）
天然玩家的博客
04-22 3690
- Java通过Thread创建线程可分为4类： （1）继承Thread，重写run方法； （2）在Thread中写方法，构建Runnable类型，通过`::`或者`()->`构建； （3）实现Runnable接口，重写run方法； （4）实现Callable接口，重写call方法。 - 前三类无法获取方法返回值，第四类可以获取方法返回值。 - 启动线程使用start方法，该方法执行时有两个线程工作，即调用start的当前线程和调用run方法的其他线程（new Thread创建的线程）。
java 多线程测试_java多线程——并发测试
weixin_26937243的博客
02-12 1746
这是多线程系列第六篇，其他请关注以下：编写并发程序时候，可以采取和串行程序相同的编程方式。唯一的难点在于，并发程序存在不确定性，这种不确定性会令程序出错的地方远比串行程序多，出现的方式也没有固定规则。这对程序的应用会造成一些困难，那么如何在测试中，尽可能的暴露出这些问题，并且了解其性能瓶颈，这也是对开发者带来新的挑战。本篇基于多线程知识，梳理一些多线程测试需要掌握的方法和原则，以期望可能的在开发阶...
Java多线程的测试
weixin_43345286的博客
08-15 1651
Java多线程的测试 一、通过继承Thread类方式创建线程 步骤：创建一个Thread类，或者一个Thread子类的对象，即通过继承Thread类的方式创建线程类，重写run()方法。 例子：线程1和线程2竞争获取cpu资源，两者获得cpu资源具有不确定性，是随机获取资源的 package com.imooc.thread; class MyThread extends Threa...
Java开发之多线程包含代码调试【面试篇 持续更新】
GSCY
09-14 859
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、多线程知识分布二、线程的基础知识1. 线程与进程的区别2. 并行和并发有什么区别① 单核CPU② 多核CPU③ 总结（现在都是多核CPU，在多核CPU下）3. 创建线程的方式有哪些① 继承Thread类② 实现runnable接口③ 实现Callable接口④ 线程池创建线程⑤ runable和callable有什么区别⑥ run()和start()有什么区别⑦ 总结4. 线程包含哪些状态，状态直接如何变化的① 状态的变化
Java 多线程 测试
风信子
04-14 2119
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
java多线程使用详解与案例，超详细
热门推荐
languageStudent的博客
03-14 3万+
java多线程使用 java使用多线程的三种方式： 继承Thread类，并重写run方法。 实现Runnable接口，重写run方法 实现Callable<返回值>接口，重写call方法 实例如下 继承Thread class test extends Thread{ @Override public void run() { System.out.println("你好啊"); } } 开始启动线程： new test().start() 实现R
Java多线程.线程检测
记录 分享 成就
04-20 1667
visualVM VisualVM是JDK自带的一款全能型性能监控和故障分析工具，包括对CPU使用、JVM堆内存消耗、线程、类加载的实时监控，内存dump文件分析，垃圾回收运行情况的可视化分析等，对故障排查和性能调优很有帮助。在windows中安装JDK后，VisualVM位于%JAVA_HOME%/bin/下，直接执行jvisualvm.exe即可，也可以配置远程监控JVM，VisualVM连接远程服务器有两种方式：JMX和jstatd，两种方式都不能完美支持所有功能，例如JMX不支持VisualGC，
Java学习-20 多线程
yanzidong的博客
02-20 1014
进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。当多个线程共同操作共享的资源时，线程间通过某种方式相互告知自己的状态，以相互协调，并避免无效的资源争夺。
多线程和CPU的关系
weixin_30516243的博客
09-10 812
什么是CPU （1） Central Progressing Unit 中央处理器，是一块超大规模的集成电路，是一台计算机的运算核心和控制核心。 （2） CPU包括 运算器，高速缓冲存储器，总线。 （3） 它的工作，主要是解释计算机中的指令，和处理计算机软件中的数据。它在计算机中起着最重要的作用，构成了系统的控制中心，对各个应用程序...
java多线程并发之旅-35-并发程序的测试
04-02 1万+
并发程序的测试 编写并发程序时候，可以采取和串行程序相同的编程方式。唯一的难点在于，并发程序存在不确定性，这种不确定性会令程序出错的地方远比串行程序多，出现的方式也没有固定规则。这对程序的应用会造成一些困难，那么如何在测试中，尽可能的暴露出这些问题，并且了解其性能瓶颈，这也是对开发者带来新的挑战。 本篇基于多线程知识，梳理一些多线程测试需要掌握的方法和原则，以期望可能的在开发阶段，就暴露出并发程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值