【Java】 DirectByteBuffer堆外内存回收

PhantomReference虚引用

在分析堆外内存回收之前，先了解下PhantomReference虚引用。

PhantomReference需要与ReferenceQueue引用队列结合使用，在GC进行垃圾回收的时候，如果发现一个对象只有虚引用在引用它，则认为该对象需要被回收，会将引用该对象的虚引用加入到与其关联的ReferenceQueue队列中，开发者可以通过ReferenceQueue获取需要被回收的对象，然后做一些清理操作，从队列中获取过的元素会从队列中清除，之后GC就可以对该对象进行回收。

虚引用提供了一种追踪对象垃圾回收状态的机制，让开发者知道哪些对象准备进行回收，在回收之前开发者可以进行一些清理工作，之后GC就可以将对象进行真正的回收。

来看一个虚引用的使用例子：

  1. 创建一个ReferenceQueue队列queue，用于跟踪对象的回收；
  2. 创建一个obj对象，通过new创建的是强引用，只要强引用存在，对象就不会被回收；
  3. 创建一个虚引用PhantomReference，将obj对象和ReferenceQueue队列传入，此时phantomReference里面引用了obj对象，并关联着引用队列queue；
  4. 同样的方式创建另一个obj1对象和虚引用对象phantomReference1；
  5. 将obj置为NULL，此时强引用关系失效；
  6. 调用 System.gc()进行垃圾回收；
  7. 由于obj的强引用关系失效，所以GC认为该对象需要被回收，会将引用该对象的虚引用phantomReference对象放入到与其关联的引用队列queue中；
  8. 通过poll从引用队列queue中获取对象，可以发现会获取到phantomReference对象，poll获取之后会将对象从引用队列中删除，之后会被垃圾回收器回收；
  9. obj1的强引用关系还在，所以从queue中并不会获取到；
   public static void main(String[] args) {// 创建引用队列ReferenceQueue<Object> queue = new ReferenceQueue<Object>();// 创建obj对象Object obj = new Object();// 创建虚引用，虚引用引用了obj对象，并与queue进行关联PhantomReference<Object> phantomReference = new PhantomReference<Object>(obj, queue);// 创建obj1对象Object obj1 = new Object();PhantomReference<Object> phantomReference1 = new PhantomReference<Object>(obj1, queue);// 将obj置为NULL，强引用关系失效obj = null;// 垃圾回收System.gc();// 从引用队列获取对象Object o = queue.poll();if (null != o) {System.out.println(o.toString());}}

输出结果：

java.lang.ref.PhantomReference@277c0f21

Reference实例的几种状态

Active：初始状态，创建一个Reference类型的实例之后处于Active状态，以上面虚引用为例，通过new创建一个PhantomReference虚引用对象之后，虚引用对象就处于Active状态。

Pending：当GC检测到对象的可达性发生变化时，会根据是否关联了引用队列来决定是否将状态更改为Pending或者Inactive，虚引用必须与引用队列结合使用，所以对于虚引用来说，如果它实际引用的对象需要被回收，垃圾回收器会将这个虚引用对象加入到一个Pending列表中，此时处于Pending状态。

同样以上面的的虚引用为例，因为obj的强引用关系失效，GC就会把引用它的虚引用对象放入到pending列表中。

Enqueued：表示引用对象被加入到了引用队列，Reference有一个后台线程去检测是否有处于Pending状态的引用对象，如果有会将引用对象加入到与其关联的引用队列中，此时由Pending转为Enqueued状态表示对象已加入到引用队列中。

Inactive：通过引用队列的poll方法可以从引用队列中获取引用对象，同时引用对象会从队列中移除，此时引用对象处于Inactive状态，之后会被GC回收。

DirectByteBuffer堆外内存回收

在DirectByteBuffer的构造函数中，在申请内存之前，先调用了Bits的reserveMemory方法回收内存，申请内存之后，调用Cleaner的create方法创建了一个Cleaner对象，并传入了当前对象（DirectByteBuffer）和一个Deallocator类型的对象：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {private final Cleaner cleaner;DirectByteBuffer(int cap) {                   // package-privatesuper(-1, 0, cap, cap);boolean pa = VM.isDirectMemoryPageAligned();int ps = Bits.pageSize();long size = Math.max(1L, (long)cap + (pa ? ps : 0));// 清理内存Bits.reserveMemory(size, cap);long base = 0;try {// 分配内存base = unsafe.allocateMemory(size);} catch (OutOfMemoryError x) {Bits.unreserveMemory(size, cap);throw x;}unsafe.setMemory(base, size, (byte) 0);if (pa && (base % ps != 0)) {// Round up to page boundaryaddress = base + ps - (base & (ps - 1));} else {address = base;}// 创建Cleader，传入了当前对象和Deallocatorcleaner = Cleaner.create(this, new Deallocator(base, size, cap));att = null;}
}

Cleaner从名字上可以看出与清理有关，Bits的reserveMemory方法底层也是通过Cleaner来进行清理，所以Cleaner是重点关注的类。

Deallocator是DirectByteBuffer的一个内部类，并且实现了Runnable接口，在run方法中可以看到对内存进行了释放，接下来就去看下在哪里触发Deallocator任务的执行：

class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer {private static class Deallocator implements Runnable {// ...private Deallocator(long address, long size, int capacity) {assert (address != 0);this.address = address; // 设置内存地址this.size = size;this.capacity = capacity;}public void run() {if (address == 0) {// Paranoiareturn;}// 释放内存unsafe.freeMemory(address);address = 0;Bits.unreserveMemory(size, capacity);}}
}

Cleaner

Cleaner继承了PhantomReference，PhantomReference是Reference的子类，所以Cleaner是一个虚引用对象。

创建Cleaner

虚引用需要与引用队列结合使用，所以在Cleaner中可以看到有一个ReferenceQueue，它是一个静态的变量，所以创建的所有Cleaner对象都会共同使用这个引用队列。

在创建Cleaner的create方法中，处理逻辑如下：

  1. 通过构造函数创建了一个Cleaner对象，构造函数中的referent参数为DirectByteBuffer，thunk参数为Deallocator对象，在构造函数中又调用了父类的构造函数完成实例化；
  2. 调用add方法将创建的Cleaner对象加入到链表中，添加到链表的时候使用的是头插法，新加入的节点放在链表的头部，first成员变量是一个静态变量，它指向链表的头结点，创建的Cleaner都会加入到这个链表中；

创建后的Cleaner对象处于Active状态。

 public class Cleaner extends PhantomReference<Object>{// ReferenceQueue队列private static final ReferenceQueue<Object> dummyQueue = new ReferenceQueue<>();// 静态变量，链表的头结点，创建的Cleaner都会加入到这个链表中static private Cleaner first = null;// thunkprivate final Runnable thunk;public static Cleaner create(Object ob, Runnable thunk) {if (thunk == null)return null;// 创建一个Cleaner并加入链表return add(new Cleaner(ob, thunk));}private Cleaner(Object referent, Runnable thunk) {super(referent, dummyQueue); // 调用父类构造函数，传入引用对象和引用队列this.thunk = thunk; // thunk指向传入的Deallocator}private static synchronized Cleaner add(Cleaner cl) {// 如果头结点不为空if (first != null) {// 将新加入的节点作为头结点cl.next = first; first.prev = cl;}first = cl;return cl;}
}

Cleaner调用父类构造函数时，最终会进入到父类Reference中的构造函数中：

referent：指向实际的引用对象，上面创建的是DirectByteBuffer，所以这里指向的是DirectByteBuffer。

queue：引用队列，指向Cleaner中的引用队列dummyQueue。

public class PhantomReference<T> extends Reference<T> {// ...public PhantomReference(T referent, ReferenceQueue<? super T> q) {super(referent, q); // 调用父类构造函数}}public abstract class Reference<T> {/* 引用对象 */private T referent;         // 引用队列volatile ReferenceQueue<? super T> queue;Reference(T referent, ReferenceQueue<? super T> queue) {this.referent = referent;// 设置引用队列this.queue = (queue == null) ? ReferenceQueue.NULL : queue;}}

启动ReferenceHandler线程

Reference中有一个静态方法，里面创建了一个ReferenceHandler并设置为守护线程，然后启动了该线程，并创建了JavaLangRefAccess对象设置到SharedSecrets中：

public abstract class Reference<T> {static {ThreadGroup tg = Thread.currentThread().getThreadGroup();for (ThreadGroup tgn = tg;tgn != null;tg = tgn, tgn = tg.getParent());// 创建ReferenceHandlerThread handler = new ReferenceHandler(tg, "Reference Handler");// 设置优先级为最高handler.setPriority(Thread.MAX_PRIORITY);handler.setDaemon(true);handler.start();// 这里设置了JavaLangRefAccessSharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {@Overridepublic boolean tryHandlePendingReference() {// 调用了tryHandlePendingreturn tryHandlePending(false);}});}
}

ReferenceHandler是Reference的内部类，继承了Thread，在run方法中开启了一个循环，不断的执行tryHandlePending方法，处理Reference中的pending列表：

public abstract class Reference<T> {private static class ReferenceHandler extends Thread {// ...ReferenceHandler(ThreadGroup g, String name) {super(g, name);}public void run() {while (true) {// 处理pending列表tryHandlePending(true);}}}}

Cleaner会启动一个优先级最高的守护线程，不断调用tryHandlePending来检测是否有需要回收的引用对象(还未进行真正的回收)，然后进行处理。

处理pending列表

垃圾回收器会将要回收的引用对象放在Reference的pending变量中，从数据类型上可以看出pending只是一个Reference类型的对象，并不是一个list，如果有多个需要回收的对象，如何将它们全部放入pending对象中？

可以把pengding看做是一个链表的头结点，假如有引用对象被判定需要回收，如果pengding为空直接放入即可，如果不为空，将使用头插法将新的对象加入到链表中，也就是将新对象的discovered指向pending对象，然后将pending指向当前要回收的这个对象，这样就形成了一个链表，pending指向链表的头结点。

在pending链表中的引用对象处于pending状态。

接下来看tryHandlePending方法的处理逻辑：

  1. 如果pending不为空，表示有需要回收的对象，此时将pengding指向的对象放在临时变量r中，并判断是否是Cleaner类型，如果是将其强制转为Cleaner，记录在临时变量c中，接着更新pending的值为r的discovered，因为discovered中记录了下一个需要被回收的对象，pengding需要指向下一个需要被回收的对象；

    pending如果为NULL，会进入到else的处理逻辑，返回值为参数传入的waitForNotify的值。

  2. 判断Cleaner对象是否为空，如果不为空，调用Cleaner的clean方法进行清理；

  3. 获取引用对象关联的引用队列，然后调用enqueue方法将引用对象加入到引用队列中；

  4. 返回true；

public abstract class Reference<T> {// 指向pending列表中的下一个节点transient private Reference<T> discovered; // 静态变量pending列表，可以看做是一个链表，pending指向链表的头结点private static Reference<Object> pending = null;static boolean tryHandlePending(boolean waitForNotify) {Reference<Object> r;Cleaner c;try {synchronized (lock) {// 如果pending不为空if (pending != null) {// 获取pending执行的对象r = pending;// 如果是Cleaner类型c = r instanceof Cleaner ? (Cleaner) r : null;// 将pending指向下一个节点pending = r.discovered;// 将discovered置为空r.discovered = null;} else {// 等待if (waitForNotify) {lock.wait();}return waitForNotify;}}} catch (OutOfMemoryError x) {Thread.yield();// retryreturn true;} catch (InterruptedException x) {// retryreturn true;}if (c != null) {// 调用clean方法进行清理c.clean();return true;}// 获取引用队列ReferenceQueue<? super Object> q = r.queue;// 如果队列不为空，将对象加入到引用队列中if (q != ReferenceQueue.NULL) q.enqueue(r);// 返回truereturn true;}
}
释放内存

在Cleaner的clean方法中，可以看到，调用了thunk的run方法，前面内容可知，thunk指向的是Deallocator对象，所以会执行Deallocator的run方法，Deallocator的run方法前面也已经看过，里面会对DirectByteBuffer的堆外内存进行释放：

public class Cleaner extends PhantomReference<Object> {public void clean() {if (!remove(this))return;try {// 调用run方法thunk.run();} catch (final Throwable x) {AccessController.doPrivileged(new PrivilegedAction<Void>() {public Void run() {if (System.err != null)new Error("Cleaner terminated abnormally", x).printStackTrace();System.exit(1);return null;}});}}
}

总结

Cleaner是一个虚引用，它实际引用的对象DirectByteBuffer如果被GC判定为需要回收，会将引用该对象的Cleaner加入到pending列表，ReferenceHandler线程会不断检测pending是否为空，如果不为空，就对其进行处理：

  1. 如果对象类型为Cleaner，就调用Cleaner的clean方法进行清理，Cleaner的clean方法又会调用Deallocator的run方法，里面调用了freeMemory方法对DirectByteBuffer分配的堆外内存进行释放；
  2. 将Cleaner对象加入到与其关联的引用队列中；
引用队列

ReferenceQueue名字听起来是一个队列，实际使用了一个链表，使用头插法将加入的节点串起来，ReferenceQueue中的head变量指向链表的头节点，每个节点是一个Reference类型的对象：

public class ReferenceQueue<T> {// head为链表头节点private volatile Reference<? extends T> head = null;
}

Reference中除了discovered变量之外，还有一个next变量，discovered指向的是处于pending状态时pending列表中的下一个元素，next变量指向的是处于Enqueued状态时，引用队列中的下一个元素：

public abstract class Reference<T> {/* When active:   处于active状态时为NULL*     pending:   this*    Enqueued:   Enqueued状态时，指向引用队列中的下一个元素*    Inactive:   this*/@SuppressWarnings("rawtypes")Reference next;/* When active:   active状态时，指向GC维护的一个discovered链表中的下一个元素*     pending:   pending状态时，指向pending列表中的下一个元素*   otherwise:   其他情况为NULL*/transient private Reference<T> discovered;  /* used by VM */
}

enqueue入队

进入引用队列中的引用对象处于enqueue状态。

enqueue的处理逻辑如下：

  1. 判断要加入的对象关联的引用队列，对队列进行判断，如果队列为空或者队列等于ReferenceQueue中的空队列ENQUEUED，表示该对象之前已经加入过队列，不能重复操作，返回false，如果未加入过继续下一步；
  2. 将对象所关联的引用队列置为ENQUEUED，它是一个空队列，表示节点已经加入到队列中；
  3. 判断头节点是否为空，如果为空，表示链表还没有节点，将当前对象的next指向自己，如果头结点不为空，将当前对象的next指向头结点，然后更新头结点的值为当前对象（头插法插入链表）；
  4. 增加队列的长度，也就是链表的长度；
public class ReferenceQueue<T> {// 空队列static ReferenceQueue<Object> ENQUEUED = new Null<>();// 入队，将节点加入引用队列，队列实际上是一个链表boolean enqueue(Reference<? extends T> r) {synchronized (lock) {// 获取关联的引用队列ReferenceQueue<?> queue = r.queue;// 如果为空或者已经添加到过队列if ((queue == NULL) || (queue == ENQUEUED)) {return false;}assert queue == this;// 将引用队列置为一个空队列，表示该节点已经入队r.queue = ENQUEUED;// 如果头结点为空将下一个节点置为自己，否则将next置为链表的头结点，可以看出同样使用的是头插法将节点插入链表r.next = (head == null) ? r : head;// 更新头结点为当前节点head = r;// 增加长度queueLength++;if (r instanceof FinalReference) {sun.misc.VM.addFinalRefCount(1);}lock.notifyAll();return true;}}
}
poll出队

在调用poll方法从引用队列中获取一个元素并出队的时候，首先对head头结点进行判空，如果为空表示引用队列中没有数据，返回NULL，否则调用reallyPoll从引用队列中获取元素。

出队的处理逻辑如下：

  1. 获取链表中的第一个节点也就是头结点，如果不为空进行下一步；

  2. 如果头节点的下一个节点是自己，表示链表只有一个节点，头结点出队之后链表为空，所以将头结点的值更新为NULL；

    如果头节点的下一个节点不是自己，表示链表中还有其他节点，更新head头节点的值为下一个节点，也就是next指向的对象；

  3. 将需要出队的节点的引用队列置为NULL，next节点置为自己，表示节点已从队列中删除；

  4. 引用队列的长度减一；

  5. 返回要出队的节点；

从出队的逻辑中可以看出，引用队列中的对象是后进先出的，poll出队之后的引用对象处于Inactive状态，表示可以被GC回收掉。

public class ReferenceQueue<T> {/*** 从引用队列中获取一个节点，进行出队操作*/public Reference<? extends T> poll() {// 如果头结点为空，表示没有数据 if (head == null)return null;synchronized (lock) {return reallyPoll();}}@SuppressWarnings("unchecked")private Reference<? extends T> reallyPoll() {     、  /* Must hold lock */// 获取头结点Reference<? extends T> r = head;if (r != null) {// 如果头结点的下一个节点是自己，表示链表只有一个节点，head置为null，否则head值为r的下一个节点，也就是next指向的对象head = (r.next == r) ?null :r.next;// 将引用队列置为NULLr.queue = NULL;// 下一个节点置为自己r.next = r;// 长度减一queueLength--;if (r instanceof FinalReference) {sun.misc.VM.addFinalRefCount(-1);}// 返回链表中的第一个节点return r;}return null;}
}

reserveMemory内存清理

最开始在DirectByteBuffer的构造函数中看到申请内存之前会调用Bits的reserveMemory方法，如果没有足够的内存，它会从SharedSecrets获取JavaLangRefAccess对象进行一些处理，由前面的内容可知，Reference中的静态方法启动ReferenceHandler之后，创建了JavaLangRefAccess并设置到SharedSecrets中，所以这里调用JavaLangRefAccess的tryHandlePendingReference实际上依旧调用的是Reference中的tryHandlePending方法。

在调用Reference中的tryHandlePending方法处理需要回收的对象之后，调用tryReserveMemory方法判断是否有足够的内存，如果内存依旧不够，会调用` System.gc()触发垃圾回收，然后开启一个循环，处理逻辑如下：

  1. 判断内存是否充足，如果充足直接返回；

  2. 判断睡眠次数是否小于限定的最大值，如果小于继续下一步，否则终止循环；

  3. 调用tryHandlePendingReference处理penging列表中的引用对象，前面在处理pending列表的逻辑中可以知道，如果pending列表不为空，会返回true，tryHandlePendingReference也会返回true，此时意味着清理了一部分对象，所以重新进入到第1步进行检查；

    如果pending列表为空，会返回参数中传入的waitForNotify的值，从JavaLangRefAccess的tryHandlePendingReference中可以看出这里传入的是false，所以会进行如下处理：

    • 通过 Thread.sleep(sleepTime)让当前线程睡眠一段时间，这样可以避免reserveMemory方法一直在占用资源;
    • 对睡眠次数加1;

  4. 如果以上步骤处理之后还没有足够的空间会抛出抛出OutOfMemoryError异常；

reserveMemory方法的作用是保证在申请内存之前有足够的内存，如果没有足够的内存会进行清理，达到指定清理次数之后依旧没有足够的内存空间，将抛出OutOfMemoryError异常。

class Bits {static void reserveMemory(long size, int cap) {if (!memoryLimitSet && VM.isBooted()) {maxMemory = VM.maxDirectMemory();memoryLimitSet = true;}// 是否有足够内存if (tryReserveMemory(size, cap)) {return;}// 获取JavaLangRefAccessfinal JavaLangRefAccess jlra = SharedSecrets.getJavaLangRefAccess();// 调用tryHandlePendingReferencewhile (jlra.tryHandlePendingReference()) {// 判断是否有足够的内存if (tryReserveMemory(size, cap)) {return;}}// 调用gc进行垃圾回收System.gc();boolean interrupted = false;try {long sleepTime = 1;int sleeps = 0;// 开启循环while (true) {// 是否有足够内存if (tryReserveMemory(size, cap)) {return;}// 如果次数小于最大限定次数，终止if (sleeps >= MAX_SLEEPS) {break;}// 再次处理penging列表中的对象if (!jlra.tryHandlePendingReference()) {try {// 睡眠一段时间Thread.sleep(sleepTime);sleepTime <<= 1;sleeps++; // 睡眠次数增加1} catch (InterruptedException e) {interrupted = true;}}}// 抛出OutOfMemoryError异常throw new OutOfMemoryError("Direct buffer memory");} finally {if (interrupted) {// don't swallow interruptsThread.currentThread().interrupt();}}}
}public abstract class Reference<T> {static {// ...// 这里设置了JavaLangRefAccessSharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {@Overridepublic boolean tryHandlePendingReference() {// 调用tryHandlePending,这里waitForNotify参数传入的是falsereturn tryHandlePending(false);}});}
}

参考

Reference源码解析

一文读懂java中的Reference和引用类型

Java 源码剖析——彻底搞懂 Reference 和 ReferenceQueue

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

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

相关文章

PyTorch 入门

PyTorch 入门

一、说明 深度学习是机器学习的一个分支&#xff0c;其中编写的算法模仿人脑的功能。深度学习中最常用的库是 Tensorflow 和 PyTorch。由于有各种可用的深度学习框架&#xff0c;人们可能想知道何时使用 PyTorch。以下是人们更喜欢使用 Pytorch 来完成特定任务的原因。 Pytorch…
阅读更多...
虹科分享 | 确保冻干工艺开发中精确测量和数据完整性的5步指南

虹科分享 | 确保冻干工艺开发中精确测量和数据完整性的5步指南

虹科分享 | 确保冻干工艺开发中精确测量和数据完整性的5步指南 介绍 冻干周期的工艺开发在冻干中起着至关重要的作用&#xff0c;因为它可以优化关键工艺参数&#xff0c;以实现理想的产品质量和工艺一致性。优化冻干工艺还可以缩短运行时间&#xff0c;尽早发现关键错误&…
阅读更多...
Unity头发飘动效果

Unity头发飘动效果

Unity头发飘动 介绍动作做头发飘动头发骨骼绑定模拟物理组件 UnityChan插件下载UnityChan具体用法确定人物是否绑定好骨骼节点&#xff08;要做的部位比如头发等&#xff09;给人物添加SpringManager骨骼管理器给骨骼节点添加SpringBone这里给每个头发骨骼都添加上SpringBone。…
阅读更多...
【RabbitMQ 实战】09 客户端连接集群生产和消费消息

【RabbitMQ 实战】09 客户端连接集群生产和消费消息

一、部署一个三节点集群 下面的链接是最快最简单的一种集群部署方法 3分钟部署一个RabbitMQ集群 上的的例子中&#xff0c;没有映射端口&#xff0c;所以没法从宿主机外部连接容器&#xff0c;下面的yml文件中&#xff0c;暴露了端口。 每个容器应用都映射了宿主机的端口&…
阅读更多...
Excel 快速分析

Excel 快速分析

文章目录 格式化图表汇总计数 表超级表 迷你图 快捷键: Ctrl Q 先选中数据, 再按快捷键或快速分析按钮. 格式化 查看规则: 前提是先在表中添加某种规则, 再全选该表, 这样在查看规则时才会显示出这个规则. 图表 汇总 计数 表 超级表 迷你图
阅读更多...
Stable Diffusion生成图片

Stable Diffusion生成图片

画质 masterpiece,best quality,illustration,extremely detail CG unity 8k wallpaper,ultra-detailed,depth of field 杰作&#xff0c;最佳质量&#xff0c;插图&#xff0c;极度详细的8K壁纸&#xff0c;超高详细度&#xff0c;景深 画风 Chinese ink painting,water color…
阅读更多...
【Unity3D赛车游戏制作】开始场景搭建——UGUI复合控件Button

【Unity3D赛车游戏制作】开始场景搭建——UGUI复合控件Button

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;元宇宙-秩沅 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 秩沅 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a;Uni…
阅读更多...
Vuex的简介以及入门案例

Vuex的简介以及入门案例

&#x1f3c5;我是默&#xff0c;一个在CSDN分享笔记的博主。&#x1f4da;&#x1f4da; &#x1f31f;在这里&#xff0c;我要推荐给大家我的专栏《Vue》。&#x1f3af;&#x1f3af; &#x1f680;无论你是编程小白&#xff0c;还是有一定基础的程序员&#xff0c;这个专栏…
阅读更多...
1688拍立淘API接口分享

1688拍立淘API接口分享

拍立淘接口&#xff0c;顾名思义&#xff0c;就是通过图片搜索到相关商品列表。通过此接口&#xff0c;可以实现图片搜索爆款商品等功能。 接口地址&#xff1a;1688.item_search_img 公共参数 名称类型必须描述keyString是调用key&#xff08;必须以GET方式拼接在URL中&…
阅读更多...
Typora for Mac：优雅的Markdown文本编辑器，提升你的写作体验

Typora for Mac：优雅的Markdown文本编辑器，提升你的写作体验

Typora是一款强大的Markdown文本编辑器&#xff0c;专为Mac用户设计。无论你是写作爱好者&#xff0c;还是专业作家或博客作者&#xff0c;Typora都能为你提供无与伦比的写作体验。 1. 直观的界面设计 Typora的界面简洁明了&#xff0c;让你专注于写作&#xff0c;而不是被复…
阅读更多...
【Spring框架学习3】Spring Bean的作用域 及 生命周期

【Spring框架学习3】Spring Bean的作用域 及 生命周期

一、Spring Bean的作用域有哪些&#xff1f; Spring框架支持以下五种Bean的作用域&#xff1a; Singleton&#xff1a;这是默认的作用域&#xff0c;在每个Spring IoC容器中只有一个Bean的实例(IoC初始化后)。Spring 中的 bean 默认都是单例的&#xff0c;是对单例设计模式的…
阅读更多...
竞赛选题 深度学习 python opencv 火焰检测识别

竞赛选题 深度学习 python opencv 火焰检测识别

文章目录 0 前言1 基于YOLO的火焰检测与识别2 课题背景3 卷积神经网络3.1 卷积层3.2 池化层3.3 激活函数&#xff1a;3.4 全连接层3.5 使用tensorflow中keras模块实现卷积神经网络 4 YOLOV54.1 网络架构图4.2 输入端4.3 基准网络4.4 Neck网络4.5 Head输出层 5 数据集准备5.1 数…
阅读更多...
美容院微信小程序怎么添加会员管理功能

美容院微信小程序怎么添加会员管理功能

要为美容院的微信小程序添加会员管理功能&#xff0c;需要遵循以下步骤&#xff1a; 一、明确会员管理功能的定位和目标 首先&#xff0c;要明确会员管理功能的定位和目标。会员管理功能是美容院微信小程序的重要功能之一&#xff0c;它能够帮助美容院更好地管理会员信息、了解…
阅读更多...
Qt 常用控件按钮Button 案例分析

Qt 常用控件按钮Button 案例分析

目录 常用控件按钮 1.QPushButton 2.QToolButton 3.QRadioButton 4.QCheckBox 5.QCommandLinkButton 6.QDialogButtonBox 常用控件按钮 Push Button: 命令按钮。 Tool Button:工具按钮。 Radio Button:单选按钮。 Check Box: 复选框按钮 Command Link Button: 命今链…
阅读更多...
2023年中国医学影像信息系统市场规模、竞争格局及行业趋势分析[图]

2023年中国医学影像信息系统市场规模、竞争格局及行业趋势分析[图]

医学影像信息系统简称PACS&#xff0c;与临床信息系统、放射学信息系统、医院信息系统、实验室信息系统同属医院信息系统。医学影像信息系统是处理各种医学影像信息的采集、存储、报告、输出、管理、查询的计算机应用程序。主要包括&#xff1a;预约管理、数据接收、影像处理、…
阅读更多...
Java实现RSA加密和验证

Java实现RSA加密和验证

Java实现RSA加密和验证 生成公私钥基础的公钥加密私钥解密自定义密钥加密及校验加密校验测试验证 使用RSA进行数字签名和验证 RSA&#xff08;Rivest–Shamir–Adleman&#xff09;是一种非对称加密算法&#xff0c;由Ron Rivest、Adi Shamir和Leonard Adleman于1977年提出&…
阅读更多...
pdf怎么压缩？pdf文件缩小的方法在这里

pdf怎么压缩？pdf文件缩小的方法在这里

PDF文件由于其跨平台、可打印性强等特点&#xff0c;成为了我们日常工作中经常使用的一种文件格式。然而&#xff0c;这种格式的文件有时候会因为过于庞大而给我们的存储和传输带来困扰&#xff0c;其实&#xff0c;这种情况只需要通过一些工具对PDF文件进行压缩&#xff0c;即…
阅读更多...
遗传算法入门笔记

遗传算法入门笔记

目录 一、大体实现过程 二、开始我们的进化(具体实现细节) 2.1 先从编码说起 2.1.1 二进制编码法 2.1.&#xff12; 浮点编码法 2.1.3 符号编码法 2.2 为我们的袋鼠染色体编码 2.3 评价个体的适应度 2.4 射杀一些袋鼠 2.5 遗传--染色体交叉(crossover) 2.6 变异--基…
阅读更多...
前端TypeScript学习day03-TS高级类型

前端TypeScript学习day03-TS高级类型

(创作不易&#xff0c;感谢有你&#xff0c;你的支持&#xff0c;就是我前行的最大动力&#xff0c;如果看完对你有帮助&#xff0c;请留下您的足迹&#xff09; 目录 TypeScript 高级类型 class 类 class继承 extends implements 类成员可见性 public protected …
阅读更多...
知识增强语言模型提示 零样本知识图谱问答10.8+10.11

知识增强语言模型提示 零样本知识图谱问答10.8+10.11

知识增强语言模型提示 零样本知识图谱问答 摘要介绍相关工作方法零样本QA的LM提示知识增强的LM提示与知识问题相关的知识检索 实验设置数据集大型语言模型基线模型和KAPIN评估指标实现细节 实验结果和分析结论 摘要 大型语言模型&#xff08;LLM&#xff09;能够执行 零样本cl…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023