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

前言

多线程大家肯定都不陌生，理论滚瓜烂熟，八股天花乱坠，但是大家有多少在代码中实践过呢？很多人在实际开发中可能就用用@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个之后达到上线就会一直卡住，原因是老的线程挂起不会释放，新的线程因为线程池满了无法创建。因此在使用该方案时一定要估算数据量，分好合适的大小，连接池和数据库的最大连接数也要注意是否匹配。

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

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

相关文章

什么是GIF?MP4视频如何转换成GIF动图格式？

什么是GIF?MP4视频如何转换成GIF动图格式？

一&#xff0c;什么是GIF GIF的全称是Graphics Interchange Format&#xff0c;可译为图形交换格式&#xff0c;用于以超文本标志语言&#xff08;Hypertext Markup Language&#xff09;方式显示索引彩色图像&#xff0c;在因特网和其他在线服务系统上得到广泛应用。GIF是一种…
阅读更多...
NzN的数据结构--二叉树part1

NzN的数据结构--二叉树part1

你叉叉&#xff0c;让你学数据结构你不学&#xff1b;你叉叉&#xff0c;让你看二叉树你不看。 今天我们来一起学习二叉树部分&#xff0c;先赞后看是好习惯。 一、树的概念及结构 1. 树的概念 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有…
阅读更多...
合并主分支到子分支

合并主分支到子分支

参考&#xff1a;【Git】合并分支出现 Please enter a commit message to explain why this merge is necessary.-CSDN博客 git 如何将主分支(master)合并到子分支上_git 将主分支合并到子分支-CSDN博客 1、先切换到主分支master git checkout master 2、把主分支代码拉到本地…
阅读更多...
【Threejs进阶教程-效果篇】1.Threejs文字与css2d/css3d技术

【Threejs进阶教程-效果篇】1.Threejs文字与css2d/css3d技术

Threejs文字与css2d/css3d技术 学习ThreeJS的捷径学习之前先搞清楚自己想要什么样的效果贴图文字准备一张带文字的png贴图使用sprite来进行贴图实现2D始终面朝相机的文字使用planeGeometry来贴图实现3D文字使用planeGeometry来贴图实现伪3D文字动态贴图文字html2Canvas 文字几何…
阅读更多...
Java8关于Function接口

Java8关于Function接口

Java学习-Function接口 1 函数式接口简介和学习地址2 两种常见的函数式接口2.1 Runnable&#xff1a;执行接口&#xff0c;不接收参数&#xff0c;也无返回结果。2.2 Consumer&#xff1a;作为消费接口&#xff0c;接收一个参数&#xff0c;无返回结果。 3 初识3.1 定义Functio…
阅读更多...
Android详细介绍POI进行Word操作（小白可进）

Android详细介绍POI进行Word操作（小白可进）

poi-tl是一个基于Apache POI的Word模板引擎&#xff0c;也是一个免费开源的Java类库&#xff0c;你可以非常方便的加入到你的项目中&#xff0c;并且拥有着让人喜悦的特性。 一、使用poi前准备 1.导入依赖&#xff1a; 亲手测过下面Android导入POI依赖的方法可用 放入这个 …
阅读更多...
OSPF实例是什么？

OSPF实例是什么？

OSPF实例是什么&#xff1f; **OSPF实例指的是一个OSPF路由进程&#xff0c;它是在一个设备上运行的单独的OSPF路由协议实体**。 在详细解释这个概念之前&#xff0c;需要了解OSPF&#xff08;Open Shortest Path First&#xff09;是一种内部网关协议&#xff08;IGP&#x…
阅读更多...
hive图形化客户端工具

hive图形化客户端工具

hive准备 创建测试数据 以root用户登录&#xff0c;使用hive命令启动hive。 创建库 create database testhivedb; 创建表 create table testhivedb.testhivetable( id int ,name string ); 插入数据 insert into testhivedb.testhivetable values (1,cc); insert into…
阅读更多...
Vscode连接WSL2当中的jupyter

Vscode连接WSL2当中的jupyter

主要解决办法参考自这篇博客 1. 在WSL当中安装jupyter 这个随便找一篇博客即可&#xff0c;比如这篇&#xff0c;也可以根据现有的环境参考其它博客内容 2. 使用jupyter创建一个虚拟环境 首先激活想要添加的虚拟环境后&#xff0c;输入命令安装库: pip install ipykernel …
阅读更多...
HarmonyOS实战开发-如何实现分布式帐号相关的功能。

HarmonyOS实战开发-如何实现分布式帐号相关的功能。

介绍 本示例主要展示了分布式帐号相关的功能&#xff0c;使用ohos.account.distributedAccount、ohos.account.osAccount等接口&#xff0c;实现了绑定分布式帐号、解绑分布式帐号、更新分布式帐号信息和管理分布式帐号的功能&#xff1b; 效果预览 使用说明 1.首次进入应用会…
阅读更多...
Text-Driven Object Detection 关于结合文本的目标检测

Text-Driven Object Detection 关于结合文本的目标检测

1、简单介绍 首先说明&#xff0c;本文目的主要是水一篇CSDN博客&#xff0c;顺便说一下和标题相关的认识。 近几年&#xff0c;在目标检测领域关于多模态的目标检测工作已成了主流&#xff0c;趋势仍在延续&#xff0c;未来仍有很大挖掘空间。这里说的多模态不是简单的多源数…
阅读更多...
element-ui使用记录

element-ui使用记录

element-ui的组件名就是类名 样式穿透&#xff08;用来修改没有类名的子组件样式&#xff09; 例如修改头部具名插槽的样式&#xff08;但是无法定位该元素&#xff09; 查看最后生成的html结构中对应的结构&#xff08;这里的头部有类名&#xff0c;可以直接对该类名进行样…
阅读更多...
【CicadaPlayer】demuxer_service的简单理解

【CicadaPlayer】demuxer_service的简单理解

G:\CDN\all_players\CicadaPlayer-github-0.44\mediaPlayer\SMPMessageControllerListener.cppplayer的demuxer服务类 std::unique_ptr<demuxer_service> mDemuxerService{nullptr};根据option （Cicada::options），可以决定音视频的不同操作，通过 hander可以获得具体使…
阅读更多...
SpringCloud Alibaba Sentinel 创建流控规则

SpringCloud Alibaba Sentinel 创建流控规则

一、前言 接下来是开展一系列的 SpringCloud 的学习之旅&#xff0c;从传统的模块之间调用&#xff0c;一步步的升级为 SpringCloud 模块之间的调用&#xff0c;此篇文章为第十四篇&#xff0c;即介绍 SpringCloud Alibaba Sentinel 创建流控规则。 二、基本介绍 我们在 senti…
阅读更多...
UltraScale 架构 SelectIO 资源之IODELAY与IOSERDES仿真与使用

UltraScale 架构 SelectIO 资源之IODELAY与IOSERDES仿真与使用

平台&#xff1a;vivado2018.3 具体内容见ug571-ultrascale-selectio IDELAYE3 在调试超高速信号的时候&#xff0c;需要使用iodelayiserdes来调试校准输入信号。例如外部某ADC采样率为5GHZ&#xff0c;外部ADC使用2.5GHZ的时钟去采集输入信号。为了实现采集&#xff0c;adc芯…
阅读更多...
90天玩转Python—05—基础知识篇：Python基础知识扫盲,使用方法与注意事项

90天玩转Python—05—基础知识篇：Python基础知识扫盲,使用方法与注意事项

90天玩转Python系列文章目录 90天玩转Python—01—基础知识篇：C站最全Python标准库总结 90天玩转Python--02--基础知识篇：初识Python与PyCharm 90天玩转Python—03—基础知识篇：Python和PyCharm（语言特点、学习方法、工具安装） 90天玩转Python—04—基础知识篇：Pytho…
阅读更多...
如何搭建APP分发平台分发平台搭建教程

如何搭建APP分发平台分发平台搭建教程

搭建一个APP分发平台可以帮助开发者更好地分发和管理他们的应用程序。下面是一个简要的教程&#xff0c;介绍如何搭建一个APP分发平台。 1.确定需求和功能&#xff1a;首先&#xff0c;确定你的APP分发平台的需求和功能。考虑以下几个方面&#xff1a; 用户注册和登录&#xff…
阅读更多...
Stable Diffusion扩散模型推导公式的基础知识

Stable Diffusion扩散模型推导公式的基础知识

文章目录 1、独立事件的条件概率2、贝叶斯公式、先验概率、后验概率、似然、证据3、马尔可夫链4、正态分布 / 高斯分布5、重参数化技巧6、期望7、KL散度 、高斯分布的KL散度8、极大似然估计9、ELBO :Evidence Lower Bound10、一元二次方程 1、独立事件的条件概率 A 和 B 是两个…
阅读更多...
Vue项目打包成exe文件（electron）

Vue项目打包成exe文件（electron）

1.将写好的vue项目打包 1.1运行vue ui命令 输出目标文件 如果打开index.html是空白的&#xff0c;而且控制台报错获取xxx资源失败的问题&#xff0c;你需要在vue.config.js 上加一个命令&#xff0c;如果没有你需要创建一个。 2.下载electron官方示例 git clone https://gith…
阅读更多...
zdpdjango_argonadmin Django后台管理系统中的常见功能开发

zdpdjango_argonadmin Django后台管理系统中的常见功能开发

效果预览 首先&#xff0c;看一下这个项目最开始的样子&#xff1a; 左侧优化 将左侧优化为下面的样子&#xff1a; 代码位置&#xff1a; 代码如下&#xff1a; {% load i18n static admin_argon %}<aside class"sidenav bg-white navbar navbar-vertical na…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023