性能优化-如何爽玩多线程来开发

前言

多线程大家肯定都不陌生，理论滚瓜烂熟，八股天花乱坠，但是大家有多少在代码中实践过呢？很多人在实际开发中可能就用用@Async，new Thread()。线程池也很少有人会自己去建，默认的随便用用。在工作中大家对于多线程开发，大多是用在异步，比如发消息，但是对于提效这块最重要的优势却很少有人涉及。因此本篇文章会结合我自己的工作场景带大家去发掘项目中的多线程场景，让你的代码快如闪电。
最后会有我对自己三个多月来写的十篇原创文章的个人总结，希望读者大大能耐心看完本篇，一定会有所收获。

多线程普及

多线程解决了什么问题？带来了什么问题？

Cpu为了均衡与内存的速度差异，增加了缓存–导致了可见性问题
操作系统增加了进程和线程，分时复用CPU，进而均衡CPU与IO设备的速度差异–导致了原子性问题
编译程序优化指令排序(JVM指令重排序)–导致了有序性问题

可见性问题–线程A修改共享变量，修改后CPU缓存中的数据没有及时同步到内存，线程B读取了内存中老数据
原子性问题–多个线程增加数据，有几个线程挂了，这数据就少了
有序性问题–经典的对象创建三步，堆中分配内存–>初始化–>变量指向内存地址，如果排序重排会出现132，导致没有初始化的对象被创建

JVM提供了什么工具去解决线程不安全问题？Java代码有哪些实现思路？

JVM提供了三个关键词，synchronized、volatile、final和JMM(线程操作内存规范，例如8个happen before原则)
Java代码实践可从三方面入手

  • 同步：synchronized和ReentrantLock
  • 非同步：CAS(CPU原语，依赖硬件)
  • 线程安全：局部变量(虚拟机栈或者本地方法栈，线程私有)和ThreadLocal(本地线程变量副本，空间换安全，每个线程一份)

如何开启线程？

基础的Thread、runable、callable，进阶的ThreadExecutor和Future，以及JDK8的终极武器CompletableFuture

线程间如何协作？

基础

  1. volatile和synchronized关键字
    1. volatile关键字用来修饰共享变量，保证了共享变量的可见性，任何线程需要读取时都要到内存中读取（确保获得最新值）。
    2. synchronized关键字确保只能同时有一个线程访问方法或者变量，保证了线程访问的可见性和排他性。
  2. 等待/通知机制–指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B 调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而 执行后续操作
  3. 管道输入/输出流
    1. 管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要 用于线程之间的数据传输，而传输的媒介为内存。
    2. 管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、 PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。
  4. join()方法–如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才 从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时 时间里没有终止，那么将会从该超时方法中返回。
  5. ThreadLocal–即线程本地变量（每个线程都有自己唯一的一个哦），是一个以ThreadLocal对象为键、任意对象为值的存储结构。底层是一个ThreadLocalMap来存储信息，key是弱引用，value是强引用，所以使用完毕后要及时清理(尤其使用线程池时)。

进阶
有JDK5开始提供的Semaphore(信号量)、CyclicBarrier、CountDownLatch以及JDK8的CompletableFuture

场景实战

多线程处理场景

并行聚合处理数据

以下案例主要运用CompletableFuture.allOf()方法，将原本串行的操作改为并行。本案例相对比较常规，算是CompletableFuture的基本操作，其他特性就不一一介绍了。

AtomicReference<List<SellOrderList>> orderLists = new AtomicReference<>();
AtomicReference<List<InternationalSalesList>> salesLists = new AtomicReference<>();
AtomicReference<Map<String, BigDecimal>> productMap = new AtomicReference<>();
.........
//逻辑A
CompletableFuture<Void> orderListCom =
        CompletableFuture.runAsync(() -> {
            orderLists.set(sellOrderListService.lambdaQuery()
                    .ge(SellOrderList::getOrderCreateDate, startDate)
                    .le(SellOrderList::getOrderCreateDate, endDate)
                    .eq(SellOrderList::getIsDelete, 0).list());
        });
CompletableFuture<Void> productCom = CompletableFuture.runAsync(() -> {//逻辑B});
CompletableFuture<Void> euLineCom = CompletableFuture.runAsync(() -> {//逻辑C});
//汇总线程操作
CompletableFuture.allOf(orderListCom, productCom, euCloudCom).handle((res, e) -> {
    if (e != null) {
        log.error("客户订单定时任务聚合数据异常", e);
    } else {
        try {
        //获取全部数据后处理数据
            aggregateData(customerList, saleMonth, orderLists, salesLists, productMap, euLineList, asLineList,
                    euCloudList, asCloudList, itemMap, deliveryMap, parities);
        } catch (Exception ex) {
            log.error("客户订单处理数据异常", ex);
        }
    }
    return null;
});

修改for循环为并行操作

这里借鉴了parallelStream流的思路，将串行的for循环分割成多个集合后，对分割后的集合进行循环。这应该是最普遍的多线程应用场景了，需要注意的是线程池需要自定义大小、不安全的集合例如ArrayList并行add时需要加锁，加好日志就完事了。

@Autowired
@Qualifier("ioDenseExecutor")
private ThreadPoolTaskExecutor ioDense;
//自建线程池，ForkJoinPool默认的太小，一般是逻辑CPU数量-1
int logicCpus = Runtime.getRuntime().availableProcessors();
ForkJoinPool forkJoinPool = new ForkJoinPool(logicCpus * 80);
//指定集合大小，避免频繁扩容
List<RedundantErpSl> slAddList = new ArrayList<>(50000);
//谷歌提供工具类切分集合--import com.google.common.collect.Lists; 
List<List<SlErpDTO>> partition = Lists.partition(slErpList, 1000);
int finalLastStatus = lastStatus;
CompletableFuture<Void> handle = CompletableFuture.allOf(partition.stream().map(addPartitionList ->
                CompletableFuture.runAsync(() -> {
                    for (SlErpDTO slErp : addPartitionList) {
                        //TODO 逻辑处理
                        synchronized (slAddList) {
                            //ArrayList线程不安全，多线程会出现数据覆盖，体现为数据丢失
                            slAddList.add(sl);
                        }
                    }
                }, ioDense)).toArray(CompletableFuture[]::new))
        .whenComplete((res, e) -> {
            if (e != null) {
                log.error("多线程组装数据失败", e);
            } else {
                try {
                    //进一步处理循环后的结果
                    slService.batchSchedule(versionNum, slAddList);
                } catch (Exception ex) {
                    log.error("批量插入失败", ex);
                }
            }
        });
handle.join();

List转Map解除嵌套循环

一个常见的场景，当我们需要判断当前数据的唯一值是否在数据库存在从而判断是新增还是修改时，常规做法是：

for(X x:待新增或者修改的数据){
    String xKey=x.getKey();//key为当前数据的唯一值
    for(Y y:数据库中的数据){
        if(Objects.equals(xKey,yKey)){
            update;//相等就修改        
        }else{
            add;//不等就新增        
        }
    } 
}

循环套循环，时间复杂度O(n²)，性能肯定是比较差的，那怎么改造呢？如果能确定key是唯一值，就拿优化神器Map来操作，算法里面常见的优化手段。我们把唯一值key作为键，输出对象作为值那么上面的代码就可以改造为：

public Map<String, SafeRule> list2Map() {
    List<SafeRule> ruleList = lambdaQuery().eq(SafeRule::getIsDelete, 0).list();
    return ruleList.stream().collect(Collectors.toMap(e -> e.getBigClass() + e.getSmallClass(),
Function.identity()));
}
for(X x:待新增或者修改的数据){
    String xKey=x.getKey();//key为当前数据的唯一值
    Map<String, SafeRule> map=list2Map();
        if(map.get(xKey)!=null){
            update;//相等就修改        
        }else{
            add;//不等就新增        
        }
    } 
}

引入Map之后，第二个嵌套的循环就干掉了，换成了单次循环来组装Map，时间复杂度降为O(n)。此方法仅适用于每行数据拥有唯一值，不然stream在组装时会提示重复key。
修改Map遍历为并行操作
既然for循环能转换，那么map遍历必然也能通过多线程改造。

/**
 * 将map切成段--工具类
 *
 * @param splitMap 被切段的map
 * @param splitNum 每段的大小
 */
public static <k, v> List<Map<k, v>> mapSplit(Map<k, v> splitMap, int splitNum) {
    if (splitMap == null || splitNum <= 0) {
        List<Map<k, v>> list = new ArrayList<>();
        list.add(splitMap);
        return list;
    }
    Set<k> keySet = splitMap.keySet();
    Iterator<k> iterator = keySet.iterator();
    int i = 1;
    List<Map<k, v>> total = new ArrayList<>();
    Map<k, v> tem = new HashMap<>();
    while (iterator.hasNext()) {
        k next = iterator.next();
        tem.put(next, splitMap.get(next));
        if (i == splitNum) {
            total.add(tem);
            tem = new HashMap<>();
            i = 0;
        }
        i++;
    }
    if (!CollectionUtils.isEmpty(tem)) {
        total.add(tem);
    }
    return total;
}
//代码示例
Map<String, List<BudgetErpDTO>> materialMap = materialList.parallelStream()
                .collect(Collectors.groupingBy(e -> e.getInvOrgId() + "-" + e.getItemId() + "-" + e.getVendorId()));
        List<Map<String, List<BudgetErpDTO>>> mapList = MapUtil.mapSplit(materialMap, 50);
        CompletableFuture<Void> handle =
                CompletableFuture.allOf(mapList.stream().map(splitMap -> CompletableFuture.runAsync(() -> {
                            splitMap.forEach((identity, list) -> {
							//业务操作
                            });
                        }, ioDense)).toArray(CompletableFuture[]::new))
                        .exceptionally(e -> {
                            log.error("多线程组装数据失败", e);
                            return null;
                        });

上面提供了一个切分的工具类，以及Map改造的代码，总体还是非常简单，思路和for循环的改造是差不多的

多线程新增

我个人在开发中会使用一些小工具来提高开发效率，接下来公开一个我常用的批量插入的小工具，这个小工具最开始是同事给我的，然后我做了优化和扩充，主要是扩充了多线程以及service块的代码。

总览

该工具类用于生成复制可用的代码，这里需要提前指定一些固定变量。除了entity和serviceName需要根据实际情况变化之外，方法名和参数名可以不变。生成了四个方法，分别是mapper类中的方法、mapper.xml中的foreach批量插入代码、普通无事务的多线程批量插入代码、多线程事务代码

//批量方法名，对应mapper和xml中id
String methodName = "batchSchedule";
//mapper参数名称
String paramName = "addList";
//实际代码里面的service命名
String serviceName = "baseInfoService";
Class<?> entity = BudgetBase.class;
//批量插入
printMapper(entity.getSimpleName(), methodName, paramName);
printXml(entity, methodName, paramName);
//普通多线程批量插入，无事务
printSave(entity.getSimpleName(), serviceName, paramName, 1000);
//多线程事务，慎用
printAddTransaction(entity.getSimpleName(), paramName, 1000);

mapper方法

xml批量插入语句

多线程批量插入

这个多线程插入其实就是我上面多线程处理场景中for循环改造的变种，将集合拆分进行并行批量插入

if (CollectionUtils.isNotEmpty(addList)) {
     List<List<BudgetBase>> partition = Lists.partition(addList, 1000);
            CompletableFuture.allOf(partition.stream().map(addPartitionList ->
                                    CompletableFuture.runAsync(() -> baseInfoService.getBaseMapper().batchSchedule(addPartitionList)))
                            .toArray(CompletableFuture[]::new))
                    .exceptionally(e -> {
                        log.error("多线程处理异常", e);
                        return null;
                    });
        }

花里胡哨-多线程事务提交

这个才是本文的重点，接下来我会详细介绍我在开发中遇到的坑和知识点，敲黑板了啊，重点来了！
我写的这个多线程事务本质就是根据2PC理论手写了一个分布式事务，涉及到多线程、Spring事务、ThreadLocal、LockSupport这些知识点，在线上一定要慎重使用，最好不用，可作炫技用，秀就完了。

深刻理解Spring事务、ThreadLocal

从头说起，既然是多线程事务，那自然不能使用注解@Transactional去开启事务，Spring事务采用ThreadLocal来做线程隔离，ThreadLocalMap内部key为当前线程的ThreadLocal对象，也可以当作以当前线程为key，value也是个map，看源码可以知道，map里面key为数据源，value为数据库连接。

当然上来看源码，肯定认识不够深刻，接下来是一段错误代码示范，充分展示了理解上面那段话的重要性。我的第一次失败就是如下一段代码，首先肯定是能运行的，不能运行的例子我就不给了，先来看看这段代码。

//存储事务集合
List<TransactionStatus> traStatusList = new ArrayList<>();
//最外部更新或者删除时手动创建一个新事务
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
TransactionStatus statusStart = transactionManager.getTransaction(def);
traStatusList.add(statusStart);
//外部DML操作
lambdaUpdate().set(RedundantErpSl::getIsDelete, 1).set(RedundantErpSl::getUpdateTime, new Date())
        .eq(RedundantErpSl::getVersionNum, versionNumber).eq(RedundantErpSl::getIsDelete, 0).update();
List<List<RedundantErpSl>> partition = Lists.partition(RedundantErpSlList, 1000);
try {
    CompletableFuture<Void> future = CompletableFuture.allOf(partition.stream().map(addPartitionList ->
                    CompletableFuture.runAsync(() -> {
                        //Spring事务内部由ThreadLocal存储事务绑定信息，因此需要每个线程新开一个事务
                        DefaultTransactionDefinition defGo = new DefaultTransactionDefinition();
                        defGo.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                        defGo.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
                        TransactionStatus statusGo = transactionManager.getTransaction(defGo);
                        //ArrayList线程不安全，多线程会出现数据覆盖，体现为数据丢失
                        synchronized (traStatusList) {
                            traStatusList.add(statusGo);
                        }
                        getBaseMapper().batchSchedule(addPartitionList);
                    })).toArray(CompletableFuture[]::new))
            .exceptionally(e -> {
                log.error("批量导入出现异常", e);
                //向外抛出异常，确保最外面catch回滚
                throw new PtmException(e.getMessage());
            });
    future.join();
    for (TransactionStatus status : traStatusList) {
        transactionManager.commit(status);
    }
} catch (Exception e) {
    log.error("批量导入出现异常回滚开始", e);
    for (TransactionStatus status : traStatusList) {
        transactionManager.rollback(status);
    }
}

先说说这个错误例子我当时开发的思路，手动开启事务后，在每个线程操作开始的时候都创建一个事务，Spring事务传播级别用的TransactionDefinition.PROPAGATION_REQUIRES_NEW，即默认创建新事务。隔离级别一开始没改，然后我就尝试着操作了一下，好家伙批量新增的时候直接锁了。
查看正在锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCKS;

查看等待锁的事务 SELECT * FROM INFORMATION_SCHEMA.INNODB_LOCK_WAITS;

异常如下图，锁超时异常

第一次看见下图这个错的时候，我是疑惑的，没有当回事，以为是多数据源的问题。我项目里有直连Oracle和MySQL两种关系型数据库，当时怀疑是多数据源事务没有正确解绑导致的问题。
:::info
PS：事实上这个坑给足了我提示，根本原因就是多线程事务解绑失败，但是我理解出现了偏差，为后文埋下了伏笔。
:::

我当时一看有锁，这我能惯着，马上修改事务隔离级别为TransactionDefinition.ISOLATION_READ_COMMITTED读已提交(MySQL默认事务隔离级别为可重复读，这里下调了一级，总共四级)。顺利插入但还是报上面这个错，错误位置是下面这个循环提交时报的，第二次循环的时候一定会报错。

for (TransactionStatus status : traStatusList) {
    transactionManager.commit(status);
}

当时一度以为是多数据源的问题，但是Debug后发现resource里面只有一个数据源key，解绑一次后就没了，第二个循环解绑的时候就报上面这个错，因为找不到可以解绑的key了。我就很疑惑，为啥就一个数据源key，我不是在别的线程开了事务嘛，按理说开了多少个线程就有多少个事务，这个问题困扰了我大概一天左右的时间。然后我想到了Spring事务的实现原理ThreadLocal，然后联想到我的多线程开启事务，再看到我在主线程里面进行傻叉循环解绑，我瞬间为梦想窒息。
所以破案了，我在主线程是操作不了子线程事务，这也是代码报key找不到的原因，因为用主线程做key在ThreadLocal里肯定是拿不到子线程信息的，只能拿到主线程自己的。

多线程事务提交方案

因此解决方案就很简单，子线程的事务自己操作，那么多线程事务处理哪家强，JDK里找CompletableFuture！当然这里使用CountDownLatch也是可行的，网上也有案例。多线程事务在处理逻辑上其实和分布式事务很像，因此我这里采用2PC的思想，一阶段所有子线程全部开启事务并执行SQL，然后阻塞等待，二阶段判断是否全部成功，是就唤醒所有线程提交事务，否就全部回滚。

-----------需要注入Bean，一个是Spring Boot事务管理，一个是线程池-----------
@Autowired
private PlatformTransactionManager transactionManager;
@Autowired
@Qualifier("ioDenseExecutor")
private ThreadPoolTaskExecutor ioDense;
-----------多线程事务新增操作-----------
private void batchSchedule(List<BudgetBase> addList) {
        if (!CollectionUtils.isEmpty(addList)) {
            //定义局部变量，是否成功、顺序标识、等待线程队列
            AtomicBoolean isSuccess = new AtomicBoolean(true);
            AtomicInteger cur = new AtomicInteger(1);
            List<Thread> unfinishedList = new ArrayList<>();
            //切分新增集合
            List<List<BudgetBase>> partition = Lists.partition(addList, 1000);
            int totalSize = partition.size();
            //多线程处理开始
            CompletableFuture<Void> future =
                    CompletableFuture.allOf(partition.stream().map(addPartitionList -> CompletableFuture.runAsync(() -> {
                        //Spring事务内部由ThreadLocal存储事务绑定信息，因此需要每个线程新开一个事务
                        DefaultTransactionDefinition defGo = new DefaultTransactionDefinition();
                        defGo.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                        TransactionStatus statusGo = transactionManager.getTransaction(defGo);
                        int curInt = cur.getAndIncrement();
                        try {
                            log.info("当前是第{}个线程开始启动，线程名={}", curInt, Thread.currentThread().getName());
                            baseInfoService.getBaseMapper().batchSchedule(addPartitionList);
                            log.info("当前是第{}个线程完成批量插入，开始加入等待队列，线程名={}", curInt, Thread.currentThread().getName());
                            //ArrayList线程不安全，多线程会出现数据覆盖，体现为数据丢失
                            synchronized (unfinishedList) {
                                unfinishedList.add(Thread.currentThread());
                            }
                            log.info("当前是第{}个线程已加入队列，开始休眠，线程名={}", curInt, Thread.currentThread().getName());
                            notifyAllThread(unfinishedList, totalSize, false);
                            LockSupport.park();
                            if (isSuccess.get()) {
                                log.info("当前是第{}个线程提交，线程名={}", curInt, Thread.currentThread().getName());
                                transactionManager.commit(statusGo);
                            } else {
                                log.info("当前是第{}个线程回滚，线程名={}", curInt, Thread.currentThread().getName());
                                transactionManager.rollback(statusGo);
                            }
                        } catch (Exception e) {
                            log.error("当前是第{}个线程出现异常，线程名={}", curInt, Thread.currentThread().getName(), e);
                            transactionManager.rollback(statusGo);
                            isSuccess.set(false);
                            notifyAllThread(unfinishedList, totalSize, true);
                        }
                    }, ioDense)).toArray(CompletableFuture[]::new));
            future.join();
        }
    }
private void notifyAllThread(List<Thread> unfinishedList, int totalSize, boolean isForce) {
        if (isForce || unfinishedList.size() >= totalSize) {
            log.info("唤醒当前所有休眠线程，线程数={}，总线程数={},是否强制={}", unfinishedList.size(), totalSize, isForce);
            for (Thread thread : unfinishedList) {
                log.info("当前线程={}被唤醒", thread.getName());
                LockSupport.unpark(thread);
            }
        }
    }

方案详解

为什么用LockSupport的park()和unpark()而不用Thread.sleep()、Object.wait()、Condition.await()?

  1. 更简单，不需要获取锁，能直接阻塞线程。
  2. 更直观，以thread为操作对象更符合阻塞线程的直观定义；
  3. 更精确，可以准确地唤醒某一个线程（notify随机唤醒一个线程，notifyAll唤醒所有等待的线程）；
  4. 更灵活 ，unpark方法可以在park方法前调用。

第4点很重要，如果不能提前使用unpark()的话，按照代码逻辑最后一个线程会被永久阻塞。

为什么要自建线程池？

CompletableFuture默认的线程池ForkJoinPool.commonPool()偏向于计算密集型任务处理，核心线程数和逻辑CPU数少1，对于多线程事务这种IO密集型任务来说核心线程数偏少。并且上述方法在操作中都是阻塞线程，无法一次性开启全部线程的话，会导致notifyAllThread方法无法执行，老线程阻塞新线程无法开启，就尬住了。
ForkJoinPool基于工作窃取算法，所以最适合的是计算密集型任务，这里我们开启一个参数调整为IO密集型(多核心少队列)的ThreadPoolTaskExecutor线程池即可。

注意MySQL/Druid等数据库的最大连接数

使用多线程的时候也别忘了调整其他组件的最大连接数。Druid线程池这个代码配置可以调，MySQL5.7默认151得用配置文件调整。MySQL最大连接数调整的方法之前从零开始的SQL修炼手册-实战篇有讲解过，欢迎读者们翻翻我之前写的干货。

真实的批量提交

Mybatis与JDBC批量插入MySQL数据库性能测试及解决方案
先贴一个大佬的文章，里面大概讲了Mybatis批量插入和JDBC批量+手动事务的优劣，结论就是小于1W用Mybatis，小于10W且大于1W用JDBC，大于10W必须数据分批。当然我上面多线程做的分批导入肯定是不安全的操作，如果要一次性导入的话根据数据量判断用大佬文章中的代码案例即可。

多线程事务提交方案–使用须知


如果此时数据库连接池配置较小，比如spring.datasource.druid.max-active=10(Druid配置最大连接数为10)。但是我在使用多线程提交时，分批次数为20，那么开了10个之后达到上线就会一直卡住，原因是老的线程挂起不会释放，新的线程因为线程池满了无法创建。因此在使用该方案时一定要估算数据量，分好合适的大小，连接池和数据库的最大连接数也要注意是否匹配。

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

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

相关文章

STL--list如何实现元素的插入和删除

STL--list如何实现元素的插入和删除

在C标准模板库&#xff08;STL&#xff09;中&#xff0c;std::list 是一个双向链表。由于它的双向链表特性&#xff0c;std::list 支持在任何位置高效地插入和删除元素。 元素插入&#xff1a; ●使用 push_back() 在列表尾部添加元素&#xff1b; ●使用 push_front() 在列表…
阅读更多...
hadoop分布式计算组件

hadoop分布式计算组件

什么是计算、分布式计算&#xff1f; 计算&#xff1a;对数据进行处理&#xff0c;使用统计分析等手段得到需要的结果 分布式计算&#xff1a;多台服务器协同工作&#xff0c;共同完成一个计算任务 分布式计算常见的2种工作模式 分散->汇总(MapReduce就是这种模式)中心调…
阅读更多...
在NBA我需要翻译--适配器模式

在NBA我需要翻译--适配器模式

1.1 在NBA我需要翻译&#xff01; "你说姚明去了几年&#xff0c;英语练出来了哦&#xff0c;我看教练在那里布置战术&#xff0c;他旁边也没有翻译的&#xff0c;不住点头&#xff0c;瞧样子听懂没什么问题了。" "要知道&#xff0c;最开始&#xff0c…
阅读更多...
（学习日记）2024.04.04：UCOSIII第三十二节：计数信号量实验

（学习日记）2024.04.04：UCOSIII第三十二节：计数信号量实验

写在前面&#xff1a; 由于时间的不足与学习的碎片化&#xff0c;写博客变得有些奢侈。 但是对于记录学习&#xff08;忘了以后能快速复习&#xff09;的渴望一天天变得强烈。 既然如此 不如以天为单位&#xff0c;以时间为顺序&#xff0c;仅仅将博客当做一个知识学习的目录&a…
阅读更多...
激光雷达和相机的联合标定工具箱[cam_lidar_calibration]介绍

激光雷达和相机的联合标定工具箱[cam_lidar_calibration]介绍

激光雷达和相机的联合标定工具箱[cam_lidar_calibration]介绍 写在前面安装过程调试过程标定成功可视化展示 写在前面 激光雷达和相机联合标定工具 论文地址&#xff1a;https://ieeexplore.ieee.org/stamp/stamp.jsp?tp&arnumber9564700 github地址: https://github.com…
阅读更多...
设计方案：914-基于64路AD的DBF波束形成硬件

设计方案：914-基于64路AD的DBF波束形成硬件

一、硬件概述 &#xff24;&#xff22;&#xff26;技术的实现全部是在数字域实现&#xff0c;然而天线阵列接收的信号经过多次混频后得到的中频信号是模拟信号&#xff0c;实现&#xff24;&#xff22;&#xff26;处理并充分发挥&#xff24;&#xff22;&…
阅读更多...
[C++][算法基础]模拟堆(堆)

[C++][算法基础]模拟堆(堆)

维护一个集合&#xff0c;初始时集合为空&#xff0c;支持如下几种操作&#xff1a; I x&#xff0c;插入一个数 x&#xff1b;PM&#xff0c;输出当前集合中的最小值&#xff1b;DM&#xff0c;删除当前集合中的最小值&#xff08;数据保证此时的最小值唯一&#xff09;&…
阅读更多...
【LeetCode热题100】153. 寻找旋转排序数组中的最小值（二分）

【LeetCode热题100】153. 寻找旋转排序数组中的最小值（二分）

一.题目要求 已知一个长度为 n 的数组&#xff0c;预先按照升序排列&#xff0c;经由 1 到 n 次 旋转 后&#xff0c;得到输入数组。例如&#xff0c;原数组 nums [0,1,2,4,5,6,7] 在变化后可能得到&#xff1a; 若旋转 4 次&#xff0c;则可以得到 [4,5,6,7,0,1,2]若旋转 7…
阅读更多...
Flutter应用发布前的关键iOS设备测试策略

Flutter应用发布前的关键iOS设备测试策略

大家好&#xff0c;我是咕噜铁蛋&#xff01;今天我想和大家分享一下关于Flutter应用在发布前&#xff0c;如何进行关键iOS设备测试的策略。随着移动应用的普及&#xff0c;Flutter作为一种跨平台的开发框架&#xff0c;越来越受到开发者的青睐。但是&#xff0c;跨平台也意味着…
阅读更多...
10 Python进阶：MongoDB

10 Python进阶：MongoDB

MongoDb介绍 MongoDB是一个基于分布式架构的文档数据库&#xff0c;它使用JSON样式的数据存储&#xff0c;支持动态查询&#xff0c;完全索引。MongoDB是NoSQL数据库的一种&#xff0c;主要用于处理大型、半结构化或无结构化的数据。以下是MongoDB数据库的一些关键特点和优势&a…
阅读更多...
蓝桥杯 历届真题 杨辉三角形【第十二届】【省赛】【C组】

蓝桥杯 历届真题 杨辉三角形【第十二届】【省赛】【C组】

资源限制 内存限制&#xff1a;256.0MB C/C时间限制&#xff1a;1.0s Java时间限制&#xff1a;3.0s Python时间限制&#xff1a;5.0s 思路&#xff1a; 由于我第一写没考虑到大数据的原因&#xff0c;直接判断导致只得了40分&#xff0c;下面是我的代码&#xff1a; #…
阅读更多...
4.7 IO day6

4.7 IO day6

1&#xff1a;有一个隧道&#xff0c;全长5公里&#xff0c;有2列火车&#xff0c;全长200米&#xff0c; 火车A时速 100公里每小时 火车B时速 50公里每小时 现在要求模拟火车反复通过隧道的场景(不可能2列火车都在隧道内运行) #include <stdio.h> #include <string.…
阅读更多...
1、java语法入门（找工作版）

1、java语法入门（找工作版）

文章目录 一、Java简介二、Java常量与变量1、标识符2、关键字3、变量4、类的命名规则5、数据类型6、基本数据类型字面值7、变量的定义与初始化8、ASCII码和Unicode编码9、转义字符10、类型转换11、常量 三、Java运算符1、算术运算符2、赋值运算符3、关系运算符4、逻辑运算符5、…
阅读更多...
C#/.NET/.NET Core推荐学习书籍（24年4月更新，已分类）

C#/.NET/.NET Core推荐学习书籍（24年4月更新，已分类）

前言 古人云&#xff1a;“书中自有黄金屋&#xff0c;书中自有颜如玉”&#xff0c;说明了书籍的重要性。作为程序员&#xff0c;我们需要不断学习以提升自己的核心竞争力。以下是一些优秀的C#/.NET/.NET Core相关学习书籍&#xff08;包含了C#、.NET、.NET Core、Linq、EF/E…
阅读更多...
瓦拉纳西（Varanasi）宗教重要性历史与文化旅游与经济社会生活环境挑战“赶due”赶due的特点包括：赶due的应对策略：陶行知生平简介教育实践与贡献

瓦拉纳西（Varanasi）宗教重要性历史与文化旅游与经济社会生活环境挑战“赶due”赶due的特点包括：赶due的应对策略：陶行知生平简介教育实践与贡献

目录 瓦拉纳西&#xff08;Varanasi&#xff09; 宗教重要性 历史与文化 旅游与经济 社会生活 环境挑战 “赶due” 赶due的特点包括&#xff1a; 赶due的应对策略&#xff1a; 陶行知 生平简介 教育实践与贡献 教育思想 遗产与影响 1.澳洲限制半工半读&#xff…
阅读更多...
SQL Sever 2008 安装教程

SQL Sever 2008 安装教程

先从官网下载程序&#xff1a;下载地址 打开上述链接后&#xff0c;点击下载按钮。 就会跳出下面这个界面&#xff0c;如果你的电脑是64位的请选择下图中这两个程序。 下载完成后&#xff0c;在电脑磁盘中找到这两个文件&#xff0c;注意安装的顺序&#xff0c;先安装 SQLEXPR…
阅读更多...
H5 点击图片翻转效果

H5 点击图片翻转效果

需求 ☑ h5 实现点击图片得到的是放大的镜像图片&#xff08;不是放大镜效果 而是实现图片镜像对折&#xff0c;左右翻转&#xff09; ☑ 鼠标点击后原图消失/隐藏&#xff0c;在原来的位置上取而代之的是翻转后的图&#xff08;除了翻转之外不要改变其他的性质&#xff0c;比…
阅读更多...
如何保证全部流量走代理

如何保证全部流量走代理

最近因为某些原因&#xff0c;需要做一些确保高匿的事情&#xff0c;便花时间做了一定的调研&#xff0c;至于是什么事情这里不便多说。 本文主要还是聊聊我看到的一些使用代理软件误区和确保流量全部走代理的方法&#xff0c;甚至也可以说是Proxifier的用户使用手册&#xff…
阅读更多...
2024/4/1—力扣—栈的最小值

2024/4/1—力扣—栈的最小值

代码实现&#xff1a; typedef struct node {int val;struct node *next; } Node;typedef struct {struct node *top;int min; } MinStack;/** initialize your data structure here. */MinStack* minStackCreate() {MinStack *obj malloc(sizeof(*obj));obj->top NULL;ob…
阅读更多...
Redis分布式锁误删情况说明

Redis分布式锁误删情况说明

4.4 Redis分布式锁误删情况说明 逻辑说明&#xff1a; 持有锁的线程在锁的内部出现了阻塞&#xff0c;导致他的锁自动释放&#xff0c;这时其他线程&#xff0c;线程2来尝试获得锁&#xff0c;就拿到了这把锁&#xff0c;然后线程2在持有锁执行过程中&#xff0c;线程1反应过…
阅读更多...
最新文章

Copyright @ 2022~2023