精华内容
下载资源
问答
  • Java虽然内存管理机制,但仍应该警惕内存泄露的问题。例如对象池、缓存中的过期对象都...这几种引用级别由高到低分别为:强引用、软引用、弱引用和虚引用。 强引用:平时我们编程的时候例如:Object object=new

    Java虽然有内存管理机制,但仍应该警惕内存泄露的问题。例如对象池、缓存中的过期对象都有可能引发内存泄露的问题。

    从JDK1.2版本开始,加入了对象的几种引用级别,从而使程序能够更好的控制对象的生命周期,帮助开发者能够更好的缓解和处理内存泄露的问题。

    这几种引用级别由高到低分别为:强引用、软引用、弱引用和虚引用。

    强引用:

    平时我们编程的时候例如:Object object=new Object();那object就是一个强引用了。如果一个对象具有强引用,那就类似于必不可少的生活用品,垃圾回收器绝不会回收它。当内存空 间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足问题。

    软引用(SoftReference):

    如果一个对象只具有软引用,那就类似于可有可物的生活用品。如果内存空间足够,垃圾回收器就不会回收它,如果内存 空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收,Java虚拟机就会把这个软引用加入到与之关联 的引用队列中。

    弱引用(WeakReference):

    如果一个对象只具有弱引用,那就类似于可有可物的生活用品。弱引用与软引用的区别在于:只具有弱引用的对象拥有更 短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程, 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联 的引用队列中。

    虚引用(PhantomReference):

    “虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。如果一个对象 仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于:虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队 列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    在java.lang.ref包中提供了三个类:SoftReference类、WeakReference类和PhantomReference类,它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列,它可以和这三种引用类联合使用,以便跟踪Java虚拟机回收所引用的对象的活动。

    以下程序创建了一个String对象、ReferenceQueue对象和WeakReference对象:

            //创建一个强引用
            String str = "hello";
            //创建引用队列, <String>为范型标记,表明队列中存放String对象的引用
            ReferenceQueue<String> rq = new ReferenceQueue<>();
            //创建一个弱引用,它引用"hello"对象,并且与rq引用队列关联
            //<String>为范型标记,表明WeakReference会弱引用String对象
            WeakReference<String> wf = new WeakReference<>(str, rq);

    以上程序代码执行完毕,内存中引用与对象的关系如图所示,"hello"对象同时具有强引用和弱引用:

    引用

    带实线的箭头表示强引用,带虚线的箭头表示弱引用。从图中可以看出,此时"hello"对象被str强引用,并且被一个WeakReference对象弱引用,因此"hello"对象不会被垃圾回收。

    在以下程序代码中,把引用"hello"对象的str变量置为null,然后再通过WeakReference弱引用的get()方法获得"hello"对象的引用:

            String str = "hello"; //① 
            ReferenceQueue<String> rq = new ReferenceQueue<String>(); //② 
            WeakReference<String> wf = new WeakReference<String>(str, rq); //③
            str=null; //④取消"hello"对象的强引用
            String str1=wf.get(); //⑤假如"hello"对象没有被回收,str1引用"hello"对象
            //假如"hello"对象没有被回收,rq.poll()返回null
            Reference<? extends String> ref=rq.poll(); //⑥

    执行完以上第④行后,内存中引用与对象的关系下图所示:

    20070320103110764

    此时"hello"对象仅仅具有弱引用,因此它有可能被垃圾回收。假如它还没有被垃圾回收,那么接下来在第⑤行执行wf.get()方法会返回 "hello"对象的引用,并且使得这个对象被str1强引用。再接下来在第⑥行执行rq.poll()方法会返回null,因为此时引用队列中没有任何 引用。ReferenceQueue的poll()方法用于返回队列中的引用,如果没有则返回null。

    ,在以下程序代码中,执行完第④行后,"hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法,催促垃圾回收器工作,从而提高 "hello"对象被回收的可能性。假如"hello"对象被回收,那么WeakReference对象的引用被加入到ReferenceQueue中, 接下来wf.get()方法返回null,并且rq.poll()方法返回WeakReference对象的引用。

            String str = "hello"; //①
            ReferenceQueue<String> rq = new ReferenceQueue<String>(); //② 
            WeakReference<String> wf = new WeakReference<String>(str, rq); //③
            str=null; //④
            //两次催促垃圾回收器工作,提高"hello"对象被回收的可能性
            System.gc(); //⑤
            System.gc(); //⑥
            String str1=wf.get(); //⑦ 假如"hello"对象被回收,str1为null
            Reference<? extends String> ref=rq.poll(); //⑧
    在以下例程的References类中,依次创建了10个软引用、10个弱引用和10个虚引用,它们各自引用一个Grocery对象。从程序运行时的打印结果可以看出,虚引用形同虚设,它所引用的对象随时可能被垃圾回收,具有弱引用的对象拥有稍微长的生命周期,当垃圾回收器执行回收操作时,有可能被垃圾回收,具有软引用的对象拥有较长的生命周期,但在Java虚拟机认为内存不足的情况下,也会被垃圾回收。

    import java.lang.ref.*;
    import java.util.*;
    class Grocery {
    	private static final int SIZE = 10000;
    	// 属性d使得每个Grocery对象占用较多内存,有80K左右
    	private double[] d = new double[SIZE];
    	private String id;
    	public Grocery(String id) {
    		this.id = id;
    	}
    	public String toString() {
    		return id;
    	}
    	public void finalize() {
    		System.out.println("Finalizing " + id);
    	}
    }
    public class References {
    	private static ReferenceQueue<Grocery> rq = new ReferenceQueue<Grocery>();
    	public static void checkQueue() {
    		Reference<? extends Grocery> inq = rq.poll(); // 从队列中取出一个引用
    		if (inq != null)
    			System.out.println("In queue: " + inq + " : " + inq.get());
    	}
    	public static void main(String[] args) {
    		final int size = 10;
    		// 创建10个Grocery对象以及10个软引用
    		Set<SoftReference<Grocery>> sa = new HashSet<SoftReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			SoftReference<Grocery> ref = new SoftReference<Grocery>(
    					new Grocery("Soft " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			sa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    		// 创建10个Grocery对象以及10个弱引用
    		Set<WeakReference<Grocery>> wa = new HashSet<WeakReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			WeakReference<Grocery> ref = new WeakReference<Grocery>(
    					new Grocery("Weak " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			wa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    		// 创建10个Grocery对象以及10个虚引用
    		Set<PhantomReference<Grocery>> pa = new HashSet<PhantomReference<Grocery>>();
    		for (int i = 0; i < size; i++) {
    			PhantomReference<Grocery> ref = new PhantomReference<Grocery>(
    					new Grocery("Phantom " + i), rq);
    			System.out.println("Just created: " + ref.get());
    			pa.add(ref);
    		}
    		System.gc();
    		checkQueue();
    	}
    }


    转载自:http://www.dexcoder.com/selfly/article/313


    展开全文
  • Java四种引用类型 1.引用的基本概念 强引用:当我们使用new创建对象时,被创建的对象就是强引用,如Object object = new Object(),其中的object就是一个强引用了。如果一个对象具有强引用,JVM就不会去GC它,JVM...

    Java四种引用类型 

    1.引用的基本概念 
    强引用:当我们使用new创建对象时,被创建的对象就是强引用,如Object object = new Object(),其中的object就是一个强引用了。如果一个对象具有强引用,JVM就不会去GC它,JVM宁可会报OOM来终止程序,也不回收该对象。 

    软引用: 如果一个对象只具备软引用,如果内存空间足够,那么JVM就不会GC它,如果内存空间不足了,就会GC该对象。 

    弱引用: 如果一个对象只具有弱引用,只要JVM的GC线程检测到了,就会立即回收。弱引用的生命周期要比软引用短很多。不过,如果垃圾回收器是一个优先级很低的线程,也不一定会很快就会释放掉软引用的内存。 

    虚引用:如果一个对象只具有虚引用,那么它就和没有任何引用一样,随时会被JVM当作垃圾进行GC。 

    上面的四种引用对应的是new关键字以及java.lang.ref包中的SoftReference,WeakReference, PhantomReference。我们注意到在java.lang.ref包中,还存在一个类叫做ReferenceQueue。 

    2.理解ReferenceQueue 
    当软引用对象被GC之后,虽然这个SoftReference对象指向的对象已不存在,但这个SoftReference对象本身还占用内存,因此需要一个适当的清除机制,避免大量SoftReference对象带来的OOM。这就需要用到ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法,如下例子: 

    Java代码  收藏代码
    1. ReferenceQueue queue = new ReferenceQueue();  
    2. SoftReference ref=new SoftReference(new MyObject(), queue);  



    那么当这个SoftReference指向的MyOhject对象被垃圾收集器回收的同时,ref对象本身会被放入ReferenceQueue。也就是说,ReferenceQueue中保存的对象是Reference对象,但这些Reference对象引用的对象已经不存在了。 

    我们可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强引用对象被回收。利用这个方法,我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去软引用的对象的清除掉。 


    3.理解WeakHashMap 
    WeakHashMap是以弱引用为键实现的HsahMap。更精确地说,对于一个给定的key对象,其对应的value对象的存在并不能阻止该key对象被GC。GC某个key对象时,它所在的条目会一并被从Map中删除。这是WeakHashMap与其他HashMap最大的不同。看下面的例子: 

    Java代码  收藏代码
      1. import java.util.Iterator;  
      2. import java.util.WeakHashMap;  
      3.   
      4. public class Demo{  
      5.     public static void main(String [] args) throws Exception{  
      6.         WeakHashMap<String,String> weakHashMap=new WeakHashMap<String, String>();  
      7.         String [] sts=new String[10];  
      8.         for(int i=0;i<100;i++){  
      9.             if(i%10==0) {  
      10.                 sts[i/10]=new String(""+i);  
      11.                 weakHashMap.put(sts[i/10], new String(""+i));  
      12.             }  
      13.             else  
      14.                 weakHashMap.put(new String(""+i), new String(""+i));  
      15.         }  
      16.   
      17.         // 催促垃圾回收器工作  
      18.         System.gc();  
      19.         // 把CPU让给垃圾回收器线程  
      20.         Thread.sleep(8000);  
      21.   
      22.         Iterator<String> iterator=weakHashMap.keySet().iterator();  
      23.         while(iterator.hasNext()){  
      24.             System.out.println(iterator.next());  
      25.         }  
      26.     }  
      27. }  

    转载:https://www.cnblogs.com/yaowen/p/6292984.html

    展开全文
  • C++里有哪几种数据类型

    千次阅读 2019-10-30 09:09:04
    C++里有哪几种数据类型? 1.基本类型    布尔型   布尔型,即bool,它的取值只能是true(真)或者false(假),分别代表非零与零。对布尔型的赋值可以直接用true或者false进行赋值,也可以用整型常量对其进行赋值,...

    C++里有哪几种数据类型?

    1.基本类型

       布尔型

      布尔型,即bool,它的取值只能是true(真)或者false(假),分别代表非零与零。对布尔型的赋值可以直接用true或者false进行赋值,也可以用整型常量对其进行赋值,只不过整型常量赋值给布尔型变量会自动转换为true或者false。true就是(非零,在计算机中存储时以1存储),false就是(零,计算机内以0存储)。

       字符型

    char类型
        char是基本的字符类型,一个char的空间应确保可以存放(机器基本字符集中)任意字符对应的数字值。也即,一个char的大小和一个机器字节(8bit)一样。储存ASCII码
    其他字符类型
        作用:用于扩展字符集。
        wchar_t类型:用于确保可以存放机器最大扩展字符集中的任意一个字符。用于存储其他语言中的字符。
        char16_t/char32_t类型:为Unicode字符集服务。
        Unicode:是用于表示所有自然语言中字符的标准。

       整形

    数据类型 定义标识符 占字节数 数值范围
    短整形 short int 2 -216~~215-1
    整形 int 4 -232~~231-1
    长整形 long int 4 -232~~231-1
    超长整形 long long int 8 -264~~263-1
    无符号整形 unsigned 2 0~~216-1
    无符号短整形 unsigned short 2 0~~216-1
    无符号长整形 unsigned long 4 0~~232-1
    无符号超长整形 unsigned long long 8 0~~264-1

       浮点型

       float 数据类型被认为是单精度。double 数据类型通常是 float 的两倍大小,因此被认为是双精度。顾名思义,long double 数据类型又比 double 要大。这些数据类型的确切大小取决于当前使用的计算机。唯一可以保证的是:
      double 至少与 float 一样大。
      long double 至少与 double一样大。

       字符串类

      在C++标准库里,通过类string从新自定义了字符串。
      头文件: #include
      string直接支持字符串连接
      string直接支持字符串的大小比较
      string直接支持子串查找和提取
      string直接支持字符串的插入和替换
      string同时具备字符串数组的灵活性,可以通过[ ]重载操作符来访问每个字符。

    2.构造类型

      数组类型

      一个数组就像一个变量,但是它可以存储一组值,所有值均具有相同的数据类型。这些值一起存储在连续的内存位置。数组的大小声明符必须是一个常量整数表达式,其值大于零。它可以是一个常数,也可以是一个命名常量。

    int SIZE=5;
    int array[SIZE];
    
    float arrayf[10]//10个float值的数组
    char arrayc[20]//20个char值的数组
    string arrays[5]//5个string对象的数组
    

      结构体类型

      结构体就是一个可以包含不同数据类型的一个结构,它是一种可以自己定义的数据类型,它的特点和数组主要有两点不同,首先结构体可以在一个结构中声明不同的数据类型。第二,相同结构的结构体变量是可以相互赋值的,而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制了,即使数据类型和数组大小完全相同。结构体可以描述数组不能够清晰描述的结构,这是数组所不具备的。
      定义结构体使用struct修饰符

      共用体类型

      共用体类型也是用来描述类型不相同的数据,但与结构体类型不同,共用体数据成员存储时采用覆盖技术,共享(部分)存储空间。在结构体中增加共用体类型成员,可使结构体中产生动态成员,相当于PASCAl,语言的变体记录。
      共用体类型定义用关键字union标识

      类类型

      类代表了某一批对象的共性和特征。类是对象的抽象,对象是类的具体实例。和结构体类型和结构体变量一样,c++中也是先声明一个类类型,然后用它去定义若干个同类型的对象。对象就是类类型的一个变量。

    class Student //声明了一个名为student的类类型
    {
    	private:
    	int num;
    	public:
    	void display();
    };
    Student stud1,stud2; //定义了两个Student类的对象
    

      事实上,类也是一种数据类型,它是一种广义的数据类型,过去接触的都是狭义的数据类型,如结构体类型的成员都是数据,而类这种数据类型的数据既包含数据也包含操作数据的函数。

      枚举类型

      如果一个变量只有几种可能的值,可以定义为枚举(enumeration)类型。所谓“枚举”是指将变量的值一一列举出来,变量的值只能在列举出来的值的范围内。
      声明枚举类型用enum开头。
      l例如

    enum weekday{sun,mon,tue,wed,thu,fri,sat};
    

      上面声明了一个枚举类型weekday,花括号中sun,mon,…,sat等称为枚举元素或枚举常量。
    表示这个类型的变量的值只能是以上7个值之一。它们是用户自己定义的标识符。

    3.指针类型

      指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的类型,指针的值或者叫指针所指向的内存区,还有指针本身所占据的内存区。

    4.引用类型

      “引用”是c++的一种新的变量类型,是对C的一个重要补充。它的作用是为变量起一个别名。假如有一个变量a,想给它起一个别名。

    int a;int &b=a;
    

      这就表明了b是a的“引用”,即a的别名。经过这样的声明,使用a或b的作用相同,都代表同一变量。在上述引用中,&是“引用声明符”,并不代表地址。不要理解为“把a的值赋给b的地址”。引用类型的数据存储在内存的堆中,而内存单元中只存放堆中对象的地址。声明引用并不开辟内存单元,b和a都代表同一变量单元。
    注意:在声明引用变量类型时,必须同时使之初始化,即声明它代表哪一变量。在声明一个变量的引用之后,在本函数执行期间,该引用一直与其代表的变量相联系
      引用的规则
      (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。
      (2)不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。
      (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。
      引用的主要功能:
      传递函数的参数和返回值。

      C++语言中,函数的参数和返回值的传递方式有三种:值传递、指针传递和引用传递。

    5.空类型

      对于空类,编译器不会生成任何的成员函数,只会生成1个字节的占位符。

    展开全文
  • Java中“引用”的几种类型

    千次阅读 2016-05-28 10:59:56
    引用:无论内存是否足够,不会回收。 软引用:内存不足时,回收该引用关联的对象。 弱引用:垃圾回收时,无论内存是否足够,都会回收。 虚引用:任何时候都可能被垃圾回收器回收。 在Java中,...

    强引用:无论内存是否足够,不会回收。

    软引用:内存不足时,回收该引用关联的对象。

    弱引用:垃圾回收时,无论内存是否足够,都会回收。

    虚引用:任何时候都可能被垃圾回收器回收。


    在Java中,虽然不需要程序员手动去管理对象的生命周期,但是如果希望某些对象具备一定的生命周期的话(比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误)就需要用到软引用和弱引用了。

      从Java SE2开始,就提供了四种类型的引用:强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的:第一是可以让程序员通过代码的方式决定某些对象的生命周期;第二是有利于JVM进行垃圾回收。下面来阐述一下这四种类型引用的概念:

      1.强引用(StrongReference)

      强引用就是指在程序代码之中普遍存在的,比如下面这段代码中的object和str都是强引用:

    1
    2
    Object object = new Object();
    String str = "hello";

      只要某个对象有强引用与之关联,JVM必定不会回收这个对象,即使在内存不足的情况下,JVM宁愿抛出OutOfMemory错误也不会回收这种对象。比如下面这段代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Main {
        public static void main(String[] args) {
            new Main().fun1();
        }
         
        public void fun1() {
            Object object = new Object();
            Object[] objArr = new Object[1000];
        }
    }

      当运行至Object[] objArr = new Object[1000];这句时,如果内存不足,JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是,当fun1运行完之后,object和objArr都已经不存在了,所以它们指向的对象都会被JVM回收。

      如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

      比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的:

    复制代码
     /**
         * Removes the element at the specified position in this Vector.
         * Shifts any subsequent elements to the left (subtracts one from their
         * indices).  Returns the element that was removed from the Vector.
         *
         * @throws ArrayIndexOutOfBoundsException if the index is out of range
         *         ({@code index < 0 || index >= size()})
         * @param index the index of the element to be removed
         * @return element that was removed
         * @since 1.2
         */
        public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        Object oldValue = elementData[index];
    
        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                     numMoved);
        elementData[--elementCount] = null; // Let gc do its work
    
        return (E)oldValue;
        }
    复制代码

      2.软引用(SoftReference)

      软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象,只有在内存不足的时候JVM才会回收该对象。因此,这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。

      软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。下面是一个使用示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    import java.lang.ref.SoftReference;
     
    public class Main {
        public static void main(String[] args) {
             
            SoftReference<String> sr = new SoftReference<String>(new String("hello"));
            System.out.println(sr.get());
        }
    }

      3.弱引用(WeakReference)

      弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。在java中,用java.lang.ref.WeakReference类来表示。下面是使用示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import java.lang.ref.WeakReference;
     
    public class Main {
        public static void main(String[] args) {
         
            WeakReference<String> sr = new WeakReference<String>(new String("hello"));
             
            System.out.println(sr.get());
            System.gc();                //通知JVM的gc进行垃圾回收
            System.out.println(sr.get());
        }
    }
      第二个输出结果是null,这说明只要JVM进行垃圾回收,被弱引用关联的对象必定会被回收掉。不过要注意的是,这里所说的被弱引用关联的对象是指只有弱引用与之关联,如果存在强引用同时与之关联,则进行垃圾回收时也不会回收该对象(软引用也是如此)。

      弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。

      4.虚引用(PhantomReference)

      虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。

      要注意的是,虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    import java.lang.ref.PhantomReference;
    import java.lang.ref.ReferenceQueue;
     
     
    public class Main {
        public static void main(String[] args) {
            ReferenceQueue<String> queue = new ReferenceQueue<String>();
            PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
            System.out.println(pr.get());
        }
    }

    二.进一步理解软引用和弱引用

      对于强引用,我们平时在编写代码时经常会用到。而对于其他三种类型的引用,使用得最多的就是软引用和弱引用,这2种既有相似之处又有区别。它们都是用来描述非必需对象的,但是被软引用关联的对象只有在内存不足时才会被回收,而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。

      在SoftReference类中,有三个方法,两个构造方法和一个get方法(WekReference类似):

      两个构造方法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public SoftReference(T referent) {
        super(referent);
        this.timestamp = clock;
        }
     
    public SoftReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
        this.timestamp = clock;
        }

      get方法用来获取与软引用关联的对象的引用,如果该对象被回收了,则返回null。

       在使用软引用和弱引用的时候,我们可以显示地通过System.gc()来通知JVM进行垃圾回收,但是要注意的是,虽然发出了通知,JVM不一定会立刻执行,也就是说这句是无法确保此时JVM一定会进行垃圾回收的。

    展开全文
  • JS六大数据类型: Number、String、Boolean、Null、Undefined、Object ​ 这些数据类型可以通过 typeof关键字 进行检测 typeof 123 //number typeof 'abc' //string typeof true //boolean typeof ...
  • 在我们写前后端交互时,最反感的可能就是拼接大量图表的工作了(html += "xxxxxxxxx...." ),记得之前写一个“急”页面,大量的js拼接内容(类似今日头条APP的检索页面),拼接代码写了千行。知道么,我是流着...
  • java的几种引用类型

    千次阅读 2011-02-02 10:26:00
    一个常见的问题是会产生“悬挂引用(dangling references)”,即一个对象引用所指向的内存区块已经被错误的回收并重新分配给新的对象了,程序如果继续使用这个引用的话会造成不可预期的结果。开发人员可能忘记...
  • .Net 的类型可以分为值类型引用类型,值类型通常分配在线程堆栈上,并且不包含任何指向实例数据的指针。引用类型实例分配在托管堆上,变量保存了实例数据的内存引用。  1. 值类型变量只是进行数据复制,创建一个...
  • Java引用类型有哪些

    万次阅读 2019-07-05 16:48:32
    动力节点Java培训最新上线Java实验班,等你来测试自己适不适合学习Java编程哦! Java类型一般两种,即基本数据类型引用数据类型。其中,引用数据类型在存储堆中对...1、Java中有哪几种引用?它们的含义和区...
  •   JS1997年标准化以后,定义了六内置类型,包括五原始(Primitive)类型以及一种引用类型,ES6又新增了一原始类型-----symbol,接下来咱们一一来分析下这七内置类型: 六原始类型 分别是: number string ...
  • Java 5种引用类型(对象类型):类 接口 数组 枚举 标注 引用类型:底层结构和基本类型差别较大 JVM的内存空间: (1). Heap 堆空间:分配对象 new Student() (2). Stack 栈空间:临时变量 Student stu (3)...
  • Mysql几种索引类型的区别及适用情况

    万次阅读 多人点赞 2013-07-30 18:39:38
    如大家所知道的,Mysql目前主要以下几种索引类型:FULLTEXT,HASH,BTREE,RTREE。 那么,这几种索引什么功能和性能上的不同呢? FULLTEXT 即为全文索引,目前只有MyISAM引擎支持。其可以在CREATE TABLE ,ALTER...
  • 目前总结了一下,在iOS平台容易引起循环引用个场景: 一、parent-child模式 二、block(编译器会提示警告) 三、NSTimer
  • java中四种引用类型

    千次阅读 2015-08-27 11:42:50
    今天看代码,里面一个类java.lang.ref.SoftReference把小弟弄神了,试想一下,接触java已经3年了哇,连lang包下面的类都不了解,怎么混。后来在网上查资料,感觉收获颇多,现记录如下。对象的强、软、弱和虚引用...
  • java四种引用类型

    万次阅读 2020-05-11 10:04:53
    编程语言都自己操作内存中元素的方式,例如在 C 和 C++ 里是通过指针,而在 Java 中则是通过“引用”。 java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁...
  • js数组也是很重要的一块,所以准备对数组的操作等写一个系列。...2.本部分讲解数组的几种合并方法优劣比较根据第一部分的基础知识,我们最容易想到的是concat、push、unshift1.concat合并数组concat是生成一个新数
  • java数据类型(八基本数据类型+三种引用类型

    万次阅读 多人点赞 2017-02-08 11:05:32
    2引用数据类型 二:注意事项: 1:java开发过程中整型用int、小数用double、布尔用boolean; 2:类型转换都是小范围向大范围转换,大范围往小范围转化需要用到强制转换;  例如:(1)int a=12;double b=a;(2...
  • JS判断数据类型几种方式

    千次阅读 2019-05-09 12:21:41
    JS中常见的几种数据类型 基本类型:string、boolean、number 特殊类型:undefined和null 3、引用类型:Array、Date、RegExp… typeof typeof检测基本数据类型时没有问题,但是当其对引用类型进行检测时,会返回...
  • Doctype的几种类型

    千次阅读 2015-10-01 17:47:27
    其中的DTD(例如上例中的xhtml1-transitional.dtd)叫文档类型定义,里面包含了文档的规则,浏览器就根据你定义的DTD来解释你页面的标识,并展现出来。 要建立符合标准的网页,DOCTYPE声明是必不可少的关键组成部分;...
  • golang中的值类型引用类型

    千次阅读 2019-08-20 20:48:29
    类型引用类型类型类型:这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &...
  • java基本类型引用类型

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型引用类型 目录 java基本类型引用类型 目录 一基本数据类型引用类型 三基本类型引用类型的区别 默认值 内存分配 自动装箱自动拆箱 自动装箱拆箱带来的问题 程序的性能 空指针异常 ...
  • C++类中定义数据成员的类型几种方式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 674,420
精华内容 269,768
关键字:

引用有哪几种类型