关于Java强引用,软引用,弱引用,你知道吗?

数字锁相环的原理与FPGA实现 数字锁相环是锁相环电路的全数字实现。锁相环电路能够实现对输入信号的相位进行跟踪,进而在噪声中提取纯净的有用信号。以上就是今天要讲的内容,本文简单地介绍了锁相环的原理,然后,在Vivado仿真平台上,通过verilog做仿真验证。最终仿真结果能够实现锁定,但锁定时间较长,表明参数仍可做调整。 阅读详情
我看得到一个讲的比较彻底明白的一片博客-原文地址:http://zhangjunhd.blog.51cto.com/113473/53092/

1.对象的强、软、弱和虚引用
在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及(reachable)状态,程序才能使用它。从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用、软引用、弱引用和虚引用。图1为对象应用类层次。

图1
⑴强引用(StrongReference)
强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。
 
⑵软引用(SoftReference)
如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存(下文给出示例)。
软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
 
⑶弱引用(WeakReference)
弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
 
⑷虚引用(PhantomReference)
“虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之 关联的引用队列中。
ReferenceQueue queue = new ReferenceQueue ();
PhantomReference pr = new PhantomReference ( object , queue );
程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。
2.对象可及性的判断
    在很多时候,一个对象并不是从根集直接引用的,而是一个对象被其他对象引用,甚至同时被几个对象所引用,从而构成一个以根集为顶的树形结构。如图2所示
    在这个树形的引用链中,箭头的方向代表了引用的方向,所指向的对象是被引用对象。由图可以看出,从根集到一个对象可以由很多条路径。比如到达对象5的路径就有①-⑤,③-⑦两条路径。由此带来了一个问题,那就是某个对象的可及性如何判断:
◆单条引用路径可及性判断:在这条路径中,最弱的一个引用决定对象的可及性。
◆多条引用路径可及性判断:几条路径中,最强的一条的引用决定对象的可及性。
    比如,我们假设图2中引用①和③为强引用,⑤为软引用,⑦为弱引用,对于对象5按照这两个判断原则,路径①-⑤取最弱的引用⑤,因此该路径对对象5的引用为软引用。同样,③-⑦为弱引用。在这两条路径之间取最强的引用,于是对象5是一个软可及对象。
3.使用软引用构建敏感数据的缓存
3.1 为什么需要使用软引用
   首先,我们看一个雇员信息查询系统的实例。我们将使用一个Java语言实现的雇员信息查询系统查询存储在磁盘文件或者数据库中的雇员人事档案信息。作为一个用户,我们完全有可能需要回头去查看几分钟甚至几秒钟前查看过的雇员档案信息(同样,我们在浏览WEB页面的时候也经常会使用“后退”按钮)。这时我们通常会有两种程序实现方式:一种是把过去查看过的雇员信息保存在内存中,每一个存储了雇员档案信息的Java对象的生命周期贯穿整个应用程序始终;另一种是当用户开始查看其他雇员的档案信息的时候,把存储了当前所查看的雇员档案信息的Java对象结束引用,使得垃圾收集线程可以回收其所占用的内存空间,当用户再次需要浏览该雇员的档案信息的时候,重新构建该雇员的信息。很显然,第一种实现方法将造成大量的内存浪费,而第二种实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集,包含雇员档案信息的对象仍然完好地保存在内存中,应用程序也要重新构建一个对象。我们知道,访问磁盘文件、访问网络资源、查询数据库等操作都是影响应用程序执行性能的重要因素,如果能重新获取那些尚未被回收的Java对象的引用,必将减少不必要的访问,大大提高程序的运行速度。
 
3.2 如果使用软引用
SoftReference的特点是它的一个实例保存对一个Java对象的软引用,该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说,一旦SoftReference保存了对一个Java对象的软引用后,在垃圾线程对这个Java对象回收前,SoftReference类所提供的get()方法返回Java对象的强引用。另外,一旦垃圾线程回收该Java对象之后,get()方法将返回null。
看下面代码:
MyObject aRef = new  MyObject();
SoftReference aSoftRef = new SoftReference( aRef );
    此时,对于这个MyObject对象,有两个引用路径,一个是来自SoftReference对象的软引用,一个来自变量aReference的强引用,所以这个MyObject对象是强可及对象。
随即,我们可以结束aReference对这个MyObject实例的强引用:
aRef = null ;
此后,这个MyObject对象成为了软可及对象。如果垃圾收集线程进行内存垃圾收集,并不会因为有一个SoftReference对该对象的引用而始终保留该对象。Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。也就是说,垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象,而且虚拟机会尽可能优先回收长时间闲置不用的软可及对象,对那些刚刚构建的或刚刚使用过的“新”软可反对象会被虚拟机尽可能保留。在回收这些对象之前,我们可以通过:
MyObject anotherRef =(MyObject) aSoftRef .get();
    重新获得对该实例的强引用。而回收之后,调用get()方法就只能得到null了。
 
3.3 使用ReferenceQueue清除失去了软引用对象的SoftReference
作为一个Java对象,SoftReference对象除了具有保存软引用的特殊性之外,也具有Java对象的一般性。所以,当软可及对象被回收之后,虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值,需要一个适当的清除机制,避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法,如:
ReferenceQueue queue = new  ReferenceQueue();
SoftReference  ref = new  SoftReference( aMyObject , queue );
    那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时,ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说,ReferenceQueue中保存的对象是Reference对象,而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出,它是一个队列,当我们调用它的poll()方法的时候,如果这个队列中不是空队列,那么将返回队列前面的那个Reference对象。
在任何时候,我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法,我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。常用的方式为:
SoftReference ref = null ;
while ((ref = (EmployeeRef) q .poll()) != null ) {
    // 清除 ref
}
理解了ReferenceQueue的工作机制之后,我们就可以开始构造一个Java对象的高速缓存器了。
 
3.4通过软可及对象重获方法实现Java对象的高速缓存
    利用Java2平台垃圾收集机制的特性以及前述的垃圾对象重获方法,我们通过一个雇员信息查询系统的小例子来说明如何构建一种高速缓存器来避免重复构建同一个对象带来的性能损失。我们将一个雇员的档案信息定义为一个Employee类:
publicclass Employee {
    private String id ; // 雇员的标识号码
    private String name ; // 雇员姓名
    private String department ; // 该雇员所在部门
    private String Phone ; // 该雇员联系电话
    privateint salary ; // 该雇员薪资
    private String origin ; // 该雇员信息的来源
 
    // 构造方法
    public Employee(String id) {
       this . id = id;
       getDataFromlnfoCenter();
    }
 
    // 到数据库中取得雇员信息
    privatevoid getDataFromlnfoCenter() {
       // 和数据库建立连接井查询该雇员的信息,将查询结果赋值
       // 给 name , department , plone , salary 等变量
       // 同时将 origin 赋值为 "From DataBase"
    }
……
这个Employee类的构造方法中我们可以预见,如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的,都要重新构建一个实例,这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.Hashtable;
publicclass EmployeeCache {
    staticprivate EmployeeCache cache ; // 一个 Cache 实例
    private Hashtable<String,EmployeeRef> employeeRefs ; // 用于 Chche 内容的存储
    private ReferenceQueue<Employee> q ; // 垃圾 Reference 的队列
 
    // 继承 SoftReference ,使得每一个实例都具有可识别的标识。
    // 并且该标识与其在 HashMap 内的 key 相同。
    privateclass EmployeeRef extends SoftReference<Employee> {
       private String _key = "" ;
 
       public EmployeeRef(Employee em, ReferenceQueue<Employee> q) {
           super (em, q);
           _key = em.getID();
       }
    }
 
    // 构建一个缓存器实例
    private EmployeeCache() {
       employeeRefs = new Hashtable<String,EmployeeRef>();
       q = new ReferenceQueue<Employee>();
    }
 
    // 取得缓存器实例
    publicstatic EmployeeCache getInstance() {
       if ( cache == null ) {
           cache = new EmployeeCache();
       }
       return cache ;
    }
 
    // 以软引用的方式对一个 Employee 对象的实例进行引用并保存该引用
    privatevoid cacheEmployee(Employee em) {
       cleanCache(); // 清除垃圾引用
       EmployeeRef ref = new EmployeeRef(em, q );
       employeeRefs .put(em.getID(), ref);
    }
 
    // 依据所指定的 ID 号,重新获取相应 Employee 对象的实例
    public Employee getEmployee(String ID) {
       Employee em = null ;
       // 缓存中是否有该 Employee 实例的软引用,如果有,从软引用中取得。
       if ( employeeRefs .containsKey(ID)) {
           EmployeeRef ref = (EmployeeRef) employeeRefs .get(ID);
           em = (Employee) ref.get();
       }
       // 如果没有软引用,或者从软引用中得到的实例是 null ,重新构建一个实例,
       // 并保存对这个新建实例的软引用
       if (em == null ) {
           em = new Employee(ID);
           System. out .println( "Retrieve From EmployeeInfoCenter. ID=" + ID);
           this .cacheEmployee(em);
       }
       return em;
    }
 
    // 清除那些所软引用的 Employee 对象已经被回收的 EmployeeRef 对象
    privatevoid cleanCache() {
       EmployeeRef ref = null ;
       while ((ref = (EmployeeRef) q .poll()) != null ) {
           employeeRefs .remove(ref. _key );
       }
    }
 
    // 清除 Cache 内的全部内容
    publicvoid clearCache() {
       cleanCache();
       employeeRefs .clear();
       System. gc();
       System. runFinalization();
    }
}
4.使用弱引用构建非敏感数据的缓存
4.1全局 Map 造成的内存泄漏
无意识对象保留最常见的原因是使用Map将元数据与临时对象(transient object)相关联。假定一个对象具有中等生命周期,比分配它的那个方法调用的生命周期长,但是比应用程序的生命周期短,如客户机的套接字连接。需要将一些元数据与这个套接字关联,如生成连接的用户的标识。在创建Socket时是不知道这些信息的,并且不能将数据添加到Socket对象上,因为不能控制 Socket 类或者它的子类。这时,典型的方法就是在一个全局 Map 中存储这些信息,如下面的 SocketManager 类所示:使用一个全局 Map 将元数据关联到一个对象。
publicclass SocketManager {
    private Map<Socket, User> m = new HashMap<Socket, User>();
 
    publicvoid setUser(Socket s, User u) {
       m .put(s, u);
    }
 
    public User getUser(Socket s) {
       return m .get(s);
    }
 
    publicvoid removeUser(Socket s) {
       m .remove(s);
    }
}
这种方法的问题是元数据的生命周期需要与套接字的生命周期挂钩,但是除非准确地知道什么时候程序不再需要这个套接字,并记住从 Map 中删除相应的映射,否则,Socket 和 User 对象将会永远留在 Map 中,远远超过响应了请求和关闭套接字的时间。这会阻止 Socket 和 User 对象被垃圾收集,即使应用程序不会再使用它们。这些对象留下来不受控制,很容易造成程序在长时间运行后内存爆满。除了最简单的情况,在几乎所有情况下找出什么时候 Socket 不再被程序使用是一件很烦人和容易出错的任务,需要人工对内存进行管理。
 
4.2如何使用WeakHashMap
在Java集合中有一种特殊的Map类型—WeakHashMap,在这种Map中存放了键对象的弱引用,当一个键对象被垃圾回收器回收时,那么相应的值对象的引用会从Map中删除。WeakHashMap能够节约存储空间,可用来缓存那些非必须存在的数据。关于Map接口的一般用法。
下面示例中MapCache类的main()方法创建了一个WeakHashMap对象,它存放了一组Key对象的弱引用,此外main()方法还创建了一个数组对象,它存放了部分Key对象的强引用。
import java.util.WeakHashMap;
 
class Element {
    private String ident ;
 
    public Element(String id) {
       ident = id;
    }
 
    public String toString() {
       return ident ;
    }
 
    publicint hashCode() {
       return ident .hashCode();
    }
 
    publicboolean equals(Object obj) {
       return obj instanceof Element && ident .equals(((Element) obj). ident );
    }
   
    protectedvoid finalize(){
       System. out .println( "Finalizing " +getClass().getSimpleName()+ " " + ident );
    }
}
 
class Key extends Element{
    public Key(String id){
       super (id);
    }
}
 
class Value extends Element{
    public Value (String id){
       super (id);
    }
}
 
publicclass CanonicalMapping {
    publicstaticvoid main(String[] args){
       int size=1000;
       Key[] keys= new Key[size];
       WeakHashMap<Key,Value> map= new WeakHashMap<Key,Value>();
       for ( int i=0;i<size;i++){
           Key k= new Key(Integer.toString(i));
           Value v= new Value(Integer.toString(i));
           if (i%3==0)
              keys[i]=k;
           map.put(k, v);
       }
       System. gc();
    }
}
从打印结果可以看出,当执行System.gc()方法后,垃圾回收器只会回收那些仅仅持有弱引用的Key对象。id可以被3整除的Key对象持有强引用,因此不会被回收。
 
4.3用 WeakHashMap 堵住泄漏
在 SocketManager 中防止泄漏很容易,只要用 WeakHashMap 代替 HashMap 就行了。(这里假定SocketManager不需要线程安全)。当映射的生命周期必须与键的生命周期联系在一起时,可以使用这种方法。用WeakHashMap修复 SocketManager。
publicclass SocketManager {
    private Map<Socket,User> m = new WeakHashMap<Socket,User>();
   
    publicvoid setUser(Socket s, User u) {
        m .put(s, u);
    }
    public User getUser(Socket s) {
        return m .get(s);
    }
}
 
4.4配合使用引用队列
WeakHashMap 用弱引用承载映射键,这使得应用程序不再使用键对象时它们可以被垃圾收集,get() 实现可以根据 WeakReference.get() 是否返回 null 来区分死的映射和活的映射。但是这只是防止 Map 的内存消耗在应用程序的生命周期中不断增加所需要做的工作的一半,还需要做一些工作以便在键对象被收集后从 Map 中删除死项。否则,Map 会充满对应于死键的项。虽然这对于应用程序是不可见的,但是它仍然会造成应用程序耗尽内存。
引用队列是垃圾收集器向应用程序返回关于对象生命周期的信息的主要方法。弱引用有个构造函数取引用队列作为参数。如果用关联的引用队列创建弱引用,在弱引用对象成为 GC 候选对象时,这个引用对象就在引用清除后加入到引用队列中(具体参考上文软引用示例)。
WeakHashMap 有一个名为 expungeStaleEntries() 的私有方法,大多数 Map 操作中会调用它,它去掉引用队列中所有失效的引用,并删除关联的映射。
5.UML:使用关联类指明特定形式的引用
关联类能够用来指明特定形式的引用,如弱(weak)、软(soft)或虚 (phantom)引用。
也可以如下的构造型方式。
深度学习-161-Dify工具之对比使用工作流和聊天流生成图表可视化的html文件 分别使用聊天流和工作流进行数据分析结果的可视化,生成html文件。聊天流可以配置带记忆,这样就可以多次交互优化结果。 阅读详情

相关推荐

无人自行车平衡控制:最小二乘法动态零点拟合实践

本文探讨了无人自行车平衡控制中动态零点的重要性及实现方法。通过最小二乘法拟合车头角度与ROL值的线性关系,解决了固定零点在转向时导致的稳定性问题。实践表明,动态零点拟合能显著提升系统平衡稳定性并降低能耗。

uran的专栏 664

Java数据类型:引用类型

引用类型,顾名思义,是用于存储对象引用(或称为句柄)的数据类型。引用类型不是类或者对象,只是变量的一种类型。当我们声明一个引用类型的变量时,该变量并不直接存储对象本身(如下图的变量obj1),而是存储了指向对象在内存中位置的一个地址(如下图的堆地址1这意味着,通过引用类型的变量,能够间接地操作对象。通过引用类型的变量对Java对象进行操作,赋予Java对象以生命力。通过本文的解析与示例,希望读者能更加深入地掌握引用类型,灵活运用这一强大工具,构建更加高效、健壮的Java应用程序。

epitomizelu的专栏 3835

Rockchip开发板FUSB302快充调试避坑指南:从设备树配置到驱动修改全流程

本文详细解析了在Rockchip开发板上调试FUSB302快充功能的全流程,重点涵盖设备树配置、驱动修改及硬件设计避坑指南。针对PD协议协商失败、电流倒灌等常见问题,提供了从软件配置到硬件排查的实战解决方案,帮助嵌入式工程师高效完成快充功能开发。

weixin_28256233的博客 114

Java的四种引用类型

Java有四种引用类型:强引用、软引用、弱引用、虚引用。 1. 强引用(StrongReference) 强引用是最常用的引用。如果一个对象具有强引用,那 GC(Gabage Collection,垃圾回收)绝不会回收它。 Object obj = new Object(); // 强引用 当内存空间不足,Java虚拟机宁愿抛出 OutOfMemoryError 错误,使程序异常终止,也...

Fantasy 7001

揭秘N531:这颗不到2毛钱的国产栅极驱动器,如何成为功率开关的“全能搭档”?

本文深入解析了国产栅极驱动器N531如何成为功率开关的“全能搭档”。针对MOSFET和IGBT等电压驱动器件在实际应用中需要大电流实现快速开关的核心痛点,N531凭借±500mA的强劲驱动能力、宽电压供电及高兼容性,有效降低开关损耗,提升系统效率与可靠性。文章通过实战案例与设计指南,阐述了这颗高性价比芯片在简化设计、降低成本方面的显著优势。

z5a6b的博客 627

企业微信群机器人Webhook配置全攻略:从创建到发送消息的完整流程

本文详细介绍了企业微信群机器人Webhook的配置流程,从创建机器人到获取Webhook地址,再到发送各类消息的完整步骤。通过Python代码示例展示了文本、Markdown等消息类型的发送方法,并提供了性能优化建议和常见问题排查技巧,帮助企业高效实现自动化消息推送。

weixin_29208327的博客 6889

Java的4种引用类型

java为引用类型专门定义了一个类叫做。Reference是跟java垃圾回收机制息息相关的类,通过探讨Reference的实现可以更加深入的理解java的垃圾回收是怎么工作的。引用的结构图如下:引用队列是为了配合SoftReference、WeakReference、PhantomReference使用,它们三个在GC回收之前会被放到引用队列里ReferenceQueue保存下。

weixin_40482816的博客 3121

BarTender破解版风险与低成本正版替代方案全解析

在工业自动化和企业信息化领域,标签打印与条形码技术是连接物理世界与数字系统的关键环节。其核心原理是通过软件驱动打印设备,将可变数据(如序列号、生产日期)与固定模板结合,生成可追溯的标识载体。这项技术的价值在于实现生产流程可视化、供应链管理精细化与质量控制自动化,广泛应用于仓储物流、制造执行、零售门店等场景。然而,软件授权合规性常成为企业成本控制的痛点,尤其面对BarTender这类行业标准工具时,部分用户可能寻求破解方案。但破解版软件通常采用内存补丁、伪造许可证等技术手段绕过验证,不仅存在法律风险,更会引发

weixin_32736961的博客 756

Java的引用(Reference)数据类型概述

Java的引用(Reference)数据类型概述

cnds123的专栏 2264

silvaco(TCAD)击穿特性仿真,的不收敛问题

在silvaco仿真学习过程中,最近这段时间一直有一个很大的问题困扰着我,那就是我在仿真击穿特型曲线的过程中,在电压加到后期比较大的情况下,往往会出现仿真不收敛的情况,正常情况下器件的击穿应该在一个外加偏压上,电流出现迅速的上升,这才是击穿的定义,但是我仿真的过程中程序跑到一个较大的电压时,器件出现击穿,我观察电压电流曲线,在击穿电压(程序报告的)电流并没有出现迅速的变化,类似于下图这种形式。(2)解决方法,将初始电压调整到合适的值,这个值可能是更大的也可能是更小的,要注意多多尝试。

zm19992533002908的博客 4949

告别第三方插件:官方Fused Library如何重塑Android库的合并与发布流程

本文详细介绍了Android官方推出的Fused Library如何替代第三方fat-aar插件,优化Android库的合并与发布流程。通过原生支持、智能依赖管理等优势,Fused Library解决了版本兼容性、依赖传递等核心痛点,提供了更稳定高效的开发体验。文章还提供了迁移实操指南和工程实践建议,帮助开发者顺利过渡到官方方案。

weixin_42561040的博客 259

Java中的四种引用类型

java中的四种引用类型

sugarxxc的博客 8266

医疗器械软件测试输出内容(1)

*单元测试(Unit Testing):**单元测试是软件测试的最底层,用于验证软件中最小的可测试单元——函数、方法或模块。系统测试是在集成测试之后进行的,它对整个系统进行测试,验证系统在不同部分集成在一起后是否满足需求和规格。: 集成测试是在单元测试之后进行的,它关注不同单元之间的交互和集成。对于不同安全级别的软件(IEC 62304 A类、B类、C类),在体系上要求输出的文件内容有所区别。**说明:**将集成测试和软件系统测试合并为一项单一的计划和一组活动是可接收的。

ct745363083的博客 1867

Java中的强引用、软引用、弱引用、虚引用,你知道几个?

文章目录一、背景二、预备知识1. Young GC示例解释2. 解释3. Full GC示例解释4. 解释三、强引用四、软引用五、弱引用六、虚引用七、在Guava中使用强软弱引用七、总结 一、背景 工程中用到guava的本地缓存。它底层实现和API接口上使用了强引用、软引用、弱引用。所以温故知新下,也夯实下基础。 二、预备知识 先来看下GC日志每个字段的含义 1. Young GC示例解释 [GC (Allocation Failure) [PSYoungGen: 273405K->20968K(27

Javacxyzz的博客 339

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

java强引用、软引用、弱引用、虚引用-Java的引用类型总共有四种,你都知道吗

目录 谈引用 强引用(Strong Reference)——不回收 强引用例子 软引用(SoftReference)——内存不足即回收 弱引用(WeakReference)——发现即回收 面试题:你开发中使用过WeakHashMap吗? 虚引用(PhantomReference)——对象回收跟踪 终结器引用(Finalreference) 谈引用 1.我们希望能描述这样一类对象:当内存空间还足够时,则能保留在内存中;如果内存空间在进行垃圾收集后还是很紧张,则可以抛弃这些对象。 ...

秃了也弱了 1022

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

面试大咖说:java对象引用,强引用、软引用、弱引用、虚引用,大家都知道多少?

java根据其生命周期的长短又将引用类型分为强引用、软引用、弱引用、虚引用;1、强引用:new一个对象就是强引用 例如 Object obj = new Object();当JVM的内存空间不足时,宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象; 软引用的生命周期比强引用短一些。 2、软引用是通过SoftReference类实现的。 当JVM认为内存空间不足时,就会去试图回收软引用指向的对象;软引用通常用在对内存敏感的程序中,比如高速缓存就有用到软引用,内

撸起袖子加油干 478

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

理解Java的强引用、软引用、弱引用和虚引用

Java中4种引用的级别和强度由高到低依次为:强引用 -> 软引用 -> 弱引用 -> 虚引用当垃圾回收器回收时,某些对象会被回收,某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象,然后将某些不可达的对象和一些引用的对象进行回收。引用类型被垃圾回收时间用途生存时间强引用从来不会对象的一般状态JVM停止运行时终止软引用当内存不足时对象缓存内存不足时终止弱引用正常垃圾回收时对象缓存垃圾回收后终止虚引用正常垃圾回收时跟踪对象的垃圾回收垃圾回收后终止。

m0_74931226的博客 169

JAVA基础 - 强引用、弱引用、软引用、虚引用

强引用:不会被回收; 软应用:内存不足时回收 弱引用:正常垃圾回收 虚引用:跟踪对象的正常垃圾回收 ...

zs1972551648的博客 1万+

强引用,弱引用,软引用,虚引用它们有什么区别?你知道吗?

本文详细解析了Java中的四种引用类型:强引用、软引用、弱引用和虚引用。首先回顾了JVM内存模型,包括栈、堆、方法区等组成部分。然后分别阐述了每种引用类型的特点: 强引用:最常见的引用类型,只要存在强引用,对象就不会被GC回收; 软引用:内存不足时会被回收,适合实现缓存功能; 弱引用:只要发生GC就会被回收,常用于ThreadLocal等场景; 虚引用:无法获取对象,主要用于管理堆外内存,需配合引用队列使用。 文章通过代码示例展示了每种引用的特性,并分析了它们的使用场景和内存管理机制,最后用表格对比总结概括

m0_70325779的博客 4098

Java里强引用、软引用、弱引用、幻引用区别总结

在Java中,引用类型决定了对象的生命周期以及垃圾收集器如何处理这些对象。这里有四种引用类型:强引用、软引用、弱引用和幻象引用(也称虚引用)。这四种引用类型提供了不同程度的控制,使得开发人员能够更精细地管理对象的生命周期和内存使用。

小小默:进无止境 1644

强引用、弱引用、软引用、虚引用

Java中4种引用的级别和强度由高到低依次为:强引用 -> 软引用 -> 弱引用 -> 虚引用当垃圾回收器回收时,某些对象会被回收,某些不会被回收。垃圾回收器会从根对象Object来标记存活的对象,然后将某些不可达的对象和一些引用的对象进行回收。引用类型被垃圾回收时间用途生存时间强引用从来不会对象的一般状态JVM停止运行时终止软引用当内存不足时对象缓存内存不足时终止弱引用正常垃圾回收时对象缓存垃圾回收后终止虚引用正常垃圾回收时跟踪对象的垃圾回收垃圾回收后终止。

m0_74267125的博客 1672

Java中强引用、软引用、弱引用、虚引用

引用类型被回收时间用途生存时间强引用从来不会对象的一般状态JVM停止运行时软引用内存不足时对象缓存内存不足时弱引用jvm垃圾回收时对象缓存gc运行后虚引用未知未知未知引用类型软引用和弱引用都可以简单实现缓存功能,在实现缓存功能的基础上又能保证缓存对象可以被及时回收。

pig_boss的博客 1665

java对象的强引用,软引用,弱引用和虚引用

<br />     众所周知,java中是JVM负责内存的分配和回收,这是它的优点(使用方便,程序不用再像使用c那样操心内存),但同时也是它的缺点(不够灵活)。为了解决内存操作不灵活这个问题,可以采用软引用等方法。<br /> <br />     在JDK1.2以前的版本中,当一个对象不被任何变量引用,那么程序就无法再使用这个对象。也就是说,只有对象处于可触及状态,程序才能使用它。这 就像在日常生活中,从商店购买了某样物品后,如果有用,就一直保留它,否则就把它扔到垃圾箱,由清洁工人收走。一般说来,如果物

lengyuhong的专栏 4万+

Java强引用、软引用、弱引用、虚引用有什么区别?

在 Java 语言中,除了原始数据类型的变量,其他所有都是所谓的引用类型,指向各种不同的对象,理解引用对于掌握 Java 对象生命周期和 JVM 内部相关机制非常有帮助。 在Java语言中,除了基本数据类型外,其他的都是指向各类对象的对象引用;Java中根据其生命周期的长短,将引用分为4类。 强引用、软引用、弱引用、虚引用有什么区别?具体使用场景是什么? 典型回答 1.强引用 特点:我们平常典型编码Object obj = new Object()中的obj就是强引用。通过关键字new创建的对象所关联的引用

小朱小朱绝不认输的博客 4196

java强引用,软引用,弱引用,虚引用

用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。强引用: Java中的引用,有点像C++的指针。通过引用,可以对堆中的对象进行操作。在某函数中,当创建了一个对象,该对象被分配在堆中,通过这个对象的引用才能对这个对象进行操作。StringBuffer str=new Strin

漫长学习路 5014

Java中弱引用、软引用、虚引用及强引用的区别

前言从Jdk1.2开始,在java.lang.ref包下就提供了三个类:SoftReference(软引用),PhantomReference(虚引用)和WeakReference(弱引用),它们分别代表了系统对对象的中的三种引用方式:软引用,虚引用以及弱引用。因此java语言对对象的引用有如下四种。可能有些工作经验比较丰富的java程序员都不太明白这几种引用的区别,仅仅只是知道而已。但是知道弱引用

qwli7 3149
上一篇: 应该避免的Android内存泄露的种种原因,你知道吗?(持续更新学习中)
下一篇: 看到的一个前辈说道的Runnable和Thread的区别,感觉很赞!
RockCode_li
博客等级 码龄12年 3粉丝 17原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值