多线程事务回滚方法

news2025/2/21 20:58:20

多线程事务回滚方法

    • 介绍
    • 案例演示
      • 线程池配置
      • 异常类
      • 实体类
      • 控制层
      • 业务层
      • mapper
      • 工具类
      • 验证
    • 解决方案
      • 使用sqlSession控制手动提交事务
        • SqlSessionTemplate注入容器中
        • 改造业务层
        • 验证
        • 成功操作示例业务层改造

介绍

1.最近有一个大数据量插入的操作入库的业务场景，需要先做一些其他修改操作，然后在执行插入操作，由于插入数据可能会很多，用到多线程去拆分数据并行处理来提高响应时间，如果有一个线程执行失败，则全部回滚。

2.在spring中可以使用@Transactional注解去控制事务，使出现异常时会进行回滚，在多线程中，这个注解则不会生效，如果主线程需要先执行一些修改数据库的操作，当子线程在进行处理出现异常时，主线程修改的数据则不会回滚，导致数据错误。

案例演示

下面是事务不成功案例演示。

线程池配置

package com.mry.rollback.config;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池配置
 */
public class ExecutorConfig {

    private static int maxPoolSize = Runtime.getRuntime().availableProcessors();
    private volatile static ExecutorService executorService;
    public static ExecutorService getThreadPool() {
        if (executorService == null){
            synchronized (ExecutorConfig.class){
                if (executorService == null){
                    executorService =  newThreadPool();
                }
            }
        }
        return executorService;
    }

    private static  ExecutorService newThreadPool(){
        int queueSize = 500;
        int corePool = Math.min(5, maxPoolSize);
        return new ThreadPoolExecutor(corePool, maxPoolSize, 10000L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(queueSize),new ThreadPoolExecutor.AbortPolicy());
    }

    private ExecutorConfig(){}

}

异常类

package com.mry.rollback.exception;

import lombok.Data;

/**
 * 异常类
 */
@Data
public class ServiceException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    private String msg;

    private int code = 500;

    public ServiceException(String msg) {
        super(msg);
        this.msg = msg;
    }

    public ServiceException(String msg, Throwable e) {
        super(msg, e);
        this.msg = msg;
    }

    public ServiceException(String msg, int code) {
        super(msg);
        this.msg = msg;
        this.code = code;
    }

    public ServiceException(String msg, int code, Throwable e) {
        super(msg, e);
        this.msg = msg;
        this.code = code;
    }

}

实体类

package com.mry.rollback.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.ToString;
import java.util.Date;

@ToString
@Data
@TableName("employee")
public class Employee {

    private Integer employeeId;
    private Integer age;
    private String employeeName;
    private Date birthDate;
    private Integer gender;
    private String idNumber;
    private Date createTime;
    private Date updateTime;
    private Integer status;
}

控制层

package com.mry.rollback.controller;

import com.mry.rollback.entity.Employee;
import com.mry.rollback.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

@Slf4j
@RestController
@RequestMapping("/sys")
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @GetMapping("/add")
    public String batchAddEmployee(){

        int size = 10;
        List<Employee> employeeDOList = new ArrayList<>(size);
        for (int i = 0; i<size;i++){
            Employee employee = new Employee();
            employee.setEmployeeName("lol"+i);
            employee.setAge(18);
            employee.setGender(1);
            employee.setBirthDate(Calendar.getInstance().getTime());
            employee.setIdNumber(i+"XX");
            employee.setStatus(1);
            employee.setCreateTime(Calendar.getInstance().getTime());
            employee.setUpdateTime(Calendar.getInstance().getTime());
            employeeDOList.add(employee);
        }
        try {
            employeeService.saveThread(employeeDOList);
            System.out.println("添加成功");
        }catch (Exception e){
            e.printStackTrace();
        }

        return "添加成功";
    }

}

业务层

package com.mry.rollback.service;

import com.mry.rollback.entity.Employee;
import java.util.List;

public interface EmployeeService {

    public void saveThread(List<Employee> employeeList);
}


package com.mry.rollback.service.impl;

import com.mry.rollback.config.ExecutorConfig;
import com.mry.rollback.entity.Employee;
import com.mry.rollback.exception.ServiceException;
import com.mry.rollback.mapper.EmployeeMapper;
import com.mry.rollback.service.EmployeeService;
import com.mry.rollback.util.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;

@Slf4j
@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    @Override
    @Transactional
    public void saveThread(List<Employee> employeeList) {

        try {
            //先做删除操作,如果子线程出现异常,此操作不会回滚
            employeeMapper.delete(null);
            //获取线程池
            ExecutorService service = ExecutorConfig.getThreadPool();
            //拆分数据,拆分5份
            List<List<Employee>> lists = ThreadUtil.averageAssign(employeeList, 5);
            //执行的线程
            Thread []threadArray = new Thread[lists.size()];
            //监控子线程执行完毕,再执行主线程,要不然会导致主线程关闭,子线程也会随着关闭
            CountDownLatch countDownLatch = new CountDownLatch(lists.size());
            AtomicBoolean atomicBoolean = new AtomicBoolean(true);
            for (int i =0;i<lists.size();i++){
                if (i==lists.size()-1){
                    atomicBoolean.set(false);
                }
                List<Employee> list  = lists.get(i);
                threadArray[i] =  new Thread(() -> {
                    try {
                        //最后一个线程抛出异常
                        if (!atomicBoolean.get()){
                            throw new ServiceException("出现异常",001);
                        }
                        //批量添加,mybatisPlus中自带的batch方法
                        employeeMapper.saveBatchEmployee(list);
                    }finally {
                        countDownLatch.countDown();
                    }

                });
            }
            for (int i = 0; i <lists.size(); i++){
                service.execute(threadArray[i]);
            }
            //当子线程执行完毕时,主线程再往下执行
            countDownLatch.await();
            System.out.println("添加完毕");
        }catch (Exception e){
            log.info("error",e);
            throw new ServiceException("出现异常",002);
        }finally {
            //connection.close();
        }

    }
}

mapper

package com.mry.rollback.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mry.rollback.entity.Employee;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface EmployeeMapper extends BaseMapper<Employee> {

    @Insert("<script>" +
            "insert into employee (age, employee_name, birth_date, gender, id_number, create_time, update_time, status) " +
            "values " +
            "<foreach collection='employeeList' item='employee' index='index' separator=','>" +
            "(#{employee.age}, #{employee.employeeName}, #{employee.birthDate}, #{employee.gender}, #{employee.idNumber}, #{employee.createTime}, #{employee.updateTime}, #{employee.status})" +
            "</foreach>" +
            "</script>")
    public void saveBatchEmployee(@Param("employeeList") List<Employee> employeeList);

}

工具类

package com.mry.rollback.util;

import java.util.ArrayList;
import java.util.List;

public class ThreadUtil {

    /**
     * 平均拆分list方法.
     * @param source
     * @param n
     * @param <T>
     * @return
     */
    public static <T> List<List<T>> averageAssign(List<T> source,int n){
        List<List<T>> result=new ArrayList<List<T>>();
        int remaider=source.size()%n;
        int number=source.size()/n;
        int offset=0;//偏移量
        for(int i=0;i<n;i++){
            List<T> value=null;
            if(remaider>0){
                value=source.subList(i*number+offset, (i+1)*number+offset+1);
                remaider--;
                offset++;
            }else{
                value=source.subList(i*number+offset, (i+1)*number+offset);
            }
            result.add(value);
        }
        return result;
    }

}

验证

1.数据库中存在一条数据：
在这里插入图片描述
2.请求接口：http://127.0.0.1:8866/sys/add
3.控制信息：
在这里插入图片描述
4.数据库信息：
在这里插入图片描述
注意：可以发现子线程组执行时，有一个线程执行失败，其他线程也会抛出异常，但是主线程中执行的删除操作，没有回滚，@Transactional注解没有生效。

解决方案

使用sqlSession控制手动提交事务

SqlSessionTemplate注入容器中

package com.mry.rollback.config;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;

/**
 * 获取sqlSession
 */
@Component
public class SqlContext {

    @Resource
    private SqlSessionTemplate sqlSessionTemplate;

    public SqlSession getSqlSession(){
        SqlSessionFactory sqlSessionFactory = sqlSessionTemplate.getSqlSessionFactory();
        return sqlSessionFactory.openSession();
    }

}

改造业务层

package com.mry.rollback.service.impl;

import com.mry.rollback.config.ExecutorConfig;
import com.mry.rollback.config.SqlContext;
import com.mry.rollback.entity.Employee;
import com.mry.rollback.exception.ServiceException;
import com.mry.rollback.mapper.EmployeeMapper;
import com.mry.rollback.service.EmployeeService;
import com.mry.rollback.util.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;

@Slf4j
@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    @Resource
    SqlContext sqlContext;

    @Override
    public void saveThread(List<Employee> employeeList) throws SQLException {

        // 获取数据库连接,获取会话(内部自有事务)
        SqlSession sqlSession = sqlContext.getSqlSession();
        Connection connection = sqlSession.getConnection();
        try {
            // 设置手动提交
            connection.setAutoCommit(false);
            //获取mapper
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            //先做删除操作
            employeeMapper.delete(null);
            //获取执行器
            ExecutorService service = ExecutorConfig.getThreadPool();
            List<Callable<Integer>> callableList  = new ArrayList<>();
            //拆分list
            List<List<Employee>> lists= ThreadUtil.averageAssign(employeeList, 5);
            AtomicBoolean atomicBoolean = new AtomicBoolean(true);
            for (int i =0;i<lists.size();i++){
                if (i==lists.size()-1){
                    atomicBoolean.set(false);
                }
                List<Employee> list  = lists.get(i);
                //使用返回结果的callable去执行,
                Callable<Integer> callable = () -> {
                    //让最后一个线程抛出异常
                    if (!atomicBoolean.get()){
                        throw new ServiceException("出现异常",001);
                    }
                    return employeeMapper.saveBatchEmployee(list);
                };
                callableList.add(callable);
            }
            //执行子线程
            List<Future<Integer>> futures = service.invokeAll(callableList);
            for (Future<Integer> future:futures) {
                //如果有一个执行不成功,则全部回滚
                if (future.get()<=0){
                    connection.rollback();
                    return;
                }
            }
            connection.commit();
            System.out.println("添加完毕");
        }catch (Exception e){
            connection.rollback();
            log.info("error",e);
            throw new ServiceException("出现异常",002);
        }finally {
            connection.close();
        }

    }
}

验证

1.数据库中存在一条数据：
在这里插入图片描述

2.请求接口：http://127.0.0.1:8877/sys/add
3.控制信息：
在这里插入图片描述

4.数据库信息：
在这里插入图片描述
注意：删除操作的数据回滚了，数据库中的数据依旧存在，说明事务成功了。

成功操作示例业务层改造

package com.mry.rollback.service.impl;

import com.mry.rollback.config.ExecutorConfig;
import com.mry.rollback.config.SqlContext;
import com.mry.rollback.entity.Employee;
import com.mry.rollback.exception.ServiceException;
import com.mry.rollback.mapper.EmployeeMapper;
import com.mry.rollback.service.EmployeeService;
import com.mry.rollback.util.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;

@Slf4j
@Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    @Resource
    SqlContext sqlContext;

    @Override
    public void saveThread(List<Employee> employeeList) throws SQLException {
        // 获取数据库连接,获取会话(内部自有事务)
        SqlSession sqlSession = sqlContext.getSqlSession();
        Connection connection = sqlSession.getConnection();
        try {
            // 设置手动提交
            connection.setAutoCommit(false);
            EmployeeMapper employeeMapper = sqlSession.getMapper(EmployeeMapper.class);
            //先做删除操作
            employeeMapper.delete(null);
            ExecutorService service = ExecutorConfig.getThreadPool();
            List<Callable<Integer>> callableList  = new ArrayList<>();
            List<List<Employee>> lists=ThreadUtil.averageAssign(employeeList, 5);
            for (int i =0;i<lists.size();i++){
                List<Employee> list  = lists.get(i);
                Callable<Integer> callable = () -> employeeMapper.saveBatchEmployee(list);
                callableList.add(callable);
            }
            //执行子线程
            List<Future<Integer>> futures = service.invokeAll(callableList);
            for (Future<Integer> future:futures) {
                if (future.get()<=0){
                    connection.rollback();
                    return;
                }
            }
            connection.commit();
            System.out.println("添加完毕");
        }catch (Exception e){
            connection.rollback();
            log.info("error",e);
            throw new ServiceException("出现异常",002);
            // throw new ServiceException(ExceptionCodeEnum.EMPLOYEE_SAVE_OR_UPDATE_ERROR);
        }

    }


}

控制台日志输出：
在这里插入图片描述

数据库中数据：
在这里插入图片描述

注意：删除的删除了，添加的添加成功了，测试成功。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Matcher: Segment Anything with One Shot Using All-Purpose Feature Matching 论文精读

Matcher: Segment Anything with One Shot Using All-Purpose Feature Matching 论文精读

Matcher: Segment Anything with One Shot Using All-Purpose Feature Matching 论文链接&#xff1a;[2305.13310] Matcher: Segment Anything with One Shot Using All-Purpose Feature Matching (arxiv.org) 代码链接&#xff1a;aim-uofa/Matcher: Matcher: Segment Anyt…
阅读更多...
STM32 HAL库开发——基础篇

STM32 HAL库开发——基础篇

目录 一、基础知识 1.1 Cortex--M系列介绍 1.2 什么是stm32 1.3 数据手册查看 1.4 最小系统和 IO 分配 1.4.1 电源电路 1.4.2 复位电路 1.4.3 BOOT 启动电路 1.4.4 晶振电路 1.4.5 下载调试电路 1.4.6 串口一键下载电路 1.4.7 IO 分配 1.4.8 总结 1.5 开发工…
阅读更多...
Spring：Spring框架中的核心类 ③

Spring：Spring框架中的核心类 ③

一、解读思想 1、用轮廓解读体系。 2、关注细节&#xff0c;不执着细节。 二、核心类设计 1、 容器接口和实现类 ApplicationContext 接口&#xff08;容器&#xff09; ①.读取配置文件 ②.注解形成bean 哪种形式的bean统一核心管理使用中心类。 2、 ApplicationCont…
阅读更多...
MySQL 子查询

MySQL 子查询

文章目录 子查询单行子查询多行子查询相关子查询 exists 子查询 所谓子查询就是 select 查询语句中还有 select 查询语句&#xff0c;里面的称为子查询或内查询&#xff0c;外面的称为主查询或外查询。 根据查询结果记录数量&#xff0c;子查询可以分为两类&#xff1a; 单行…
阅读更多...
机器学习 | 分类问题

机器学习 | 分类问题

目录 一、K近邻算法 二、决策树 1.一些原理介绍 2.决策树案例与实践 三、距离 一、K近邻算法 我们引入accuracy_score&#xff0c;利用score()的方法评估准确性。k近邻算法中的k是一个超参数&#xff0c;需要事先进行定义。 k值得选取经验做法是一般低于训练样本得平方根…
阅读更多...
排书 dfs 迭代加深 IDA* 剪枝 java

排书 dfs 迭代加深 IDA* 剪枝 java

&#x1f351; 算法题解专栏 &#x1f351; 排书 给定 n n n 本书&#xff0c;编号为 1 ∼ n 1 \sim n 1∼n。 在初始状态下&#xff0c;书是任意排列的。 在每一次操作中&#xff0c;可以抽取其中连续的一段&#xff0c;再把这段插入到其他某个位置。 我们的目标状态是把…
阅读更多...
【云原生-K8s】k8s可视化管理界面安装配置及比较【Kuboard篇】

【云原生-K8s】k8s可视化管理界面安装配置及比较【Kuboard篇】

总览 安装了k8s控制面板&#xff0c;方便日常的问题处理&#xff0c;查看资源状态信息&#xff0c;也可以增加子账号进行开放给其他人员使用&#xff0c;减少命令操作&#xff0c;提升工作效率 前置条件 须有一个正常使用的k8s集群附k8s v1.23版本搭建&#xff1a;https://…
阅读更多...
amis框架实现sdk中使用tsx

amis框架实现sdk中使用tsx

1.开发过程中&#xff0c;由于自己和同事用的不同方式使用&#xff0c;本人使用react搭建的amis框架&#xff0c;同事用sdk使用方式搭建 2.开发过程中遇到问题&#xff0c;如果需求中出现amis无法满足的组件&#xff0c;需要自己进行自定义组件&#xff0c;而不同使用方式的am…
阅读更多...
JVM内存变化分析实战

JVM内存变化分析实战

最近在一次项目压力测试时&#xff0c;监测到JVM内存明显的变化&#xff0c;由于之前开发工作中没有涉及到JVM相关的问题分析&#xff0c;所以特此借这个机会学习和记录。项目使用的JDK版本为 OpenJdk 1.8&#xff0c;虚拟机为 HotSpot。 1. 内存变化情况 在压力测试进行2H48…
阅读更多...
Java008——Java关键字和标识符的简单认识

Java008——Java关键字和标识符的简单认识

一、Java关键字 围绕以下3点介绍&#xff1a; 1、什么是Java关键字&#xff1f; 2、Java有哪些关键字&#xff1f; 3、Java关键字的作用&#xff1f; 4、Java关键字的使用&#xff1f;后面文章再做介绍 1.1、什么是Java关键字&#xff1f; 定义&#xff1a;被Java语言赋予了…
阅读更多...
github开源化课程体系推荐 浙江大学 计算机考研必备408资料汇总 北京大学计算机系资料整理

github开源化课程体系推荐 浙江大学 计算机考研必备408资料汇总 北京大学计算机系资料整理

github漫游指南 github漫游指南 *所有开源课程资料网站整理在文末 什么是GitHub Wiki 百科上是这么说的 GitHub 是一个共享虚拟主机服务&#xff0c;用于存放使用Git版本控制的软件代码和内容项目。它由GitHub公司&#xff08;曾称Logical Awesome&#xff09;的开发者Chr…
阅读更多...
【手撕Spring源码】深度理解SpringMVC【下】

【手撕Spring源码】深度理解SpringMVC【下】

文章目录 控制器方法执行流程ControllerAdvice 之 ModelAttribute返回值处理器MessageConverterControllerAdvice 之 ResponseBodyAdviceBeanNameUrlHandlerMapping 与 SimpleControllerHandlerAdapterRouterFunctionMapping 与 HandlerFunctionAdapterSimpleUrlHandlerMapping…
阅读更多...
Elasticsearch：节点角色 - node roles

Elasticsearch：节点角色 - node roles

你可能已经知道 Elasticsearch 集群由一个或多个节点组成。 每个节点将数据存储在分片上&#xff0c;每个分片存储在一个节点上。 到目前为止&#xff0c;你看到的每个节点都至少存储了一个分片&#xff0c;但值得注意的是&#xff0c;节点并不总是必须存储分片。 这是因为每个…
阅读更多...
【Unity3D】运动模糊特效

【Unity3D】运动模糊特效

1 运动模糊原理 开启混合&#xff08;Blend&#xff09;后&#xff0c;通过 Alpha 通道控制当前屏幕纹理与历史屏幕纹理进行混合&#xff0c;当有物体运动时&#xff0c;就会将当前位置的物体影像与历史位置的物体影像进行混合&#xff0c;从而实现运动模糊效果&#xff0c;即模…
阅读更多...
javascript基础二十二：举例说明你对尾递归的理解，有哪些应用场景

javascript基础二十二：举例说明你对尾递归的理解，有哪些应用场景

一、递归 递归&#xff08;英语&#xff1a;Recursion&#xff09; 在数学与计算机科学中&#xff0c;是指在函数的定义中使用函数自身的方法 在函数内部&#xff0c;可以调用其他函数。如果一个函数在内部调用自身本身&#xff0c;这个函数就是递归函数 其核心思想是把一个大型…
阅读更多...
Redis高级数据结构之GEO

Redis高级数据结构之GEO

GEO的介绍 Redis3.2版本提供了GEO地址位置信息定位的功能。支持存储地理位置信息来实现诸如摇一摇&#xff0c;附近位置这类地理位置信息的功能。 Redis也是使用业界比较通用的地理位置距离排序算法GeoHash算法。将二维的经纬度坐标数据映射到一维的整数&#xff0c;将所有元素…
阅读更多...
1.项目环境部署操作

1.项目环境部署操作

第一步 将资料中提供虚拟机压缩包, 解压到一个没有中文没有空格, 以及磁盘空间相对充足的磁盘中(大于100GB) 第二步 修改VMware的网卡设置: 统一修改为 88网段, 网关为192.168.88.2 vm虚拟机 windows系统 第三步 将两台项目虚拟机挂载到VMware上
阅读更多...
Kubernetes学习笔记-开发应用的最佳实践（2）20230604

Kubernetes学习笔记-开发应用的最佳实践（2）20230604

三、确保所有的客户端请求都得到了妥善处理 如何在pod启动的时候&#xff0c;确保所有的连接都被妥善处理了 1、在pod启动时避免客户端连接断开 当个pod启动的时候&#xff0c;他以服务端点的方式提供给所有的服务&#xff0c;这些服务的标签选择器和pod的标签匹配。pod需要…
阅读更多...
【简单实用框架】【读Excel表】【可移植】

【简单实用框架】【读Excel表】【可移植】

☀️博客主页&#xff1a;CSDN博客主页 &#x1f4a8;本文由 我是小狼君 原创&#xff0c;首发于 CSDN&#x1f4a2; &#x1f525;学习专栏推荐&#xff1a;面试汇总 ❗️游戏框架专栏推荐&#xff1a;游戏实用框架专栏 ⛅️点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd;&…
阅读更多...
【算法思维】-- 贪心算法

【算法思维】-- 贪心算法

OJ须知&#xff1a; 一般而言&#xff0c;OJ在1s内能接受的算法时间复杂度&#xff1a;10e8 ~ 10e9之间&#xff08;中值5*10e8&#xff09;。在竞赛中&#xff0c;一般认为计算机1秒能执行 5*10e8 次计算。 时间复杂度取值范围o(log2n)大的离谱O(n)10e8O(nlog(n))10e6O(nsqrt(…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023