文章目录
 
引用类型简介
对象可达性判断
GC Roots对象
可达性判断
可达性状态类型
可达性判断规则
状态转换
  
  
Reference
类定义
状态变化
四种引用类型实现
强引用FinalReference
软引用SoftReference
弱引用WeakReference
虚引用PhantomReference
  
 

 
引用类型简介
 
Java开发者肯定都很熟悉java中的4种引用类型，它们从强到弱分别是：
 
引用类型
对象是否可引用
回收时间
使用场景
强引用
可以
从不回收
普遍对象的状态
软引用
可以
内存不足时
内存敏感的高速缓存
弱引用
可以
下一次GC
对象缓存
虚引用
不可以
下一次GC，不影响对象生命周期
必须和引用队列(ReferenceQueue)一起使用，一般用于追踪垃圾收集器的回收动作。相比对象的finalize方法，虚引用的方式更加灵活和安全。
 
但可能大多数对4种引用类型的理解都只停留在概念的记忆上，而并不了解四种引用的实现原理。下面我们结合源代码了解下四种引用的实现原理。当然在了解四种引用的实现原理之前，首先得了解下JVM中实现对象可达性判断的原理。
 
对象可达性判断
 
目前，大多数JVM都是使用可达性分析算法来判断对象的是否可达。可达性分析算法以GC Roots对象作为起始点进行搜索。当一个对象与GC Roots对象没有任何引用链相连时(也即引用有向图中从GC Roots对象到这个对象是不连通的)，则表明该对象是不可用的（不可用的对象不一定被判定为可以回收的对象）。当对象与GC Roots对象有引用链相连时，则需要根据引用链的类型来判断对象是否可达。
 
 
 
不可用的对象不一定被判定为可以回收的对象：判定对象为”死亡”至少需要经历两次标记的过程。第一次标记：对象可达性分析，如果发现对象没有与GC Roots相连接的引用链，且对象需要执行finalize方法，将会被加入F-Queue队列中。第二次标记：由一个优先级低的Finalizer线程去取F-Queue队列的对象，“尝试执行”对象的finalize方法。
 
 
JVM会保证触发满足条件的对象的finalize方法，但是并不承诺会等待方法执行结束。finalize方法是对象逃脱死亡命运的最后一次机会。
 
 
GC Roots对象
 
GC Roots对象包含以下四类：
 
虚拟机栈(栈桢中的本地变量表)中的引用的对象；
方法区中的类静态属性引用的对象；
方法区中的常量引用的对象；
本地方法栈中JNI（Native方法）引用的对象；
 
可达性判断
 
可达性状态类型
 
Java有5种类型的可达性状态：
 
强可达(Strongly Reachable)：与GC Roots对象之间有强引用相连通，则为强可达的；
软可达(Soft Reachable)：与GC Roots对象之间没有强引用相连通，但有软引用相连通，则为软可达的；
弱可达(Weak Reachable)：与GC Roots对象之间没有强引用或软引用相连通，但有弱引用相连通，则为弱可达的；
虚可达(Phantom Reachable)：与GC Roots对象之间没有强引用、软引用或弱引用相连通，然后该对象finalize方法已执行，并且有虚引用相连通，则为虚可达的；
不可达(Unreachable)：如果对象finalize方法已执行并且没有任何引用相连通，则对象是不可达的，可以被回收。
 
可达性判断规则
 
从GC Roots对象到一个对象的引用链可能存在多条，那么此时会依据两个原则来判断对象的可达性：
 
单个引用链中，以最弱的引用类型为准；
多引用链联合看时，以最强的引用类型为准；
 
 
首先，单个引用链中，以最弱的引用类型为准：则GC Roots->Obj1->Obj4是软引用连通的，GC Roots->Obj2->Obj4是弱引用连通的，GC Roots->Obj3->Obj5是弱引用连通的。然后多引用链联合看时，以最强的引用类型为准：则GC Roots到Obj4对象的引用联合来看是弱引用连通的。
 
状态转换
 
对象可达性状态是随着程序运行而不断变化的，对象可达性状态转换图可参考下图。
 
对象创建后一般是强可达的。
当GC Roots对象到该对象的强引用被清除后：如果剩余引用链最高为软引用，则状态转换为软可达的；反之如果最高为弱引用，则状态转换为弱可达的，反之则把对象标记为可执行finalize方法状态。
当软可达对象重新被强引用连接时，则转换为强可达状态；当软可达对象的软引用被清除后，如果剩余引用链最高为弱引用，则状态转换为弱可达；反之则把对象标记为可执行finalize方法状态。
当弱可达对象重新被强引用或者软引用连接时，则可转换为强可达或者软可达；当弱可达对象的弱引用被清除后，则把对象标记为可执行finalize方法状态。
可对象被标记为可执行finalize方法状态，如果对象finalize从未被执行，则执行finalize方法，并标记对象的finalize方法已经被执行（在finalize方法可能会重新生成强/软/弱引用等，对象状态会重新转换为强/软/弱可达，不过并不推荐这么做，因为可能会导致对象状态紊乱，无法被正常回收）；反之当对象有虚引用连接时，则转换为虚可达状态，否则转换为不可达状态。
虚可达对象在垃圾回收后状态转换为不可达（不能通过虚引用获取对象引用，所以对象状态不会再转换为强/软/弱可达）；
 
 
Reference
 
Reference类是所有引用类型的基类，定义了reference对象的通用操作，用来保存对象引用及引用的内部状态。Reference抽象类初始化时，会启动一个ReferenceHandler线程。Reference的referent被回收前，垃圾回收器会把reference添加到pending这个链表里（如果注册了ReferenceQueue），然后ReferenceHandler线程不断的读取pending中的reference，把它加入到对应的ReferenceQueue中（如果Reference是Cleaner类的实例，即虚引用对象，则调用其注册的预处理钩子方法）。
 
 
 
ReferenceQueue提供了两个静态字段NULL，ENQUEUED。这两个字段的主要功能：NULL是当我们构造Reference实例时queue传入null时，会默认使用NULL，这样在enqueue时判断queue是否为NULL,如果为NULL直接返回，入队失败。ENQUEUED的作用是防止重复入队，reference后会把其queue字段赋值为ENQUEUED,当再次入队时会直接返回失败。
 
 
类定义
 
Reference对象的基类。该类定义了reference对象的通用操作。因为reference对象是和垃圾回收器密切配合实现的，因此该类不能直接进行子类化。
 
public abstract class Reference<T> {
	// 用于保存对象的引用，GC会特别对待该变量
    private T referent; 
	// 如果注册了ReferenceQueue（需要通知机制），用来保存对象引用的队列，
    volatile ReferenceQueue<? super T> queue;

    // 保存需要由ReferenceHandler处理的引用
    volatile Reference next;

	// 被JVM使用，保存需要被JVM处理的下一个引用
    transient private Reference<T> discovered;

    // 同步锁，用于同步pending队列的进队和出队
    static private class Lock { }
    private static Lock lock = new Lock();

    // 一个PENDING队列，配合上述next一起使用，实现类单向循环链表的操作
    private static Reference<Object> pending = null;

	// 高优先级线程，用于将pending队列里面的Reference实例依次添加到不同的ReferenceQueue中
	private static class ReferenceHandler extends Thread {...}
	...
}
 
状态变化
 
一个对象引用有四种内部状态:
 
Active: 新创建的实例的状态，当对象引用被垃圾回收器回收前：如果Reference注册了ReferenceQueue，则会切换为Pending，并且Reference会加入pending链表中，如果没有注册ReferenceQueue，会切换为Inactive。
Pending: 在pending链表中的Reference的状态，这些Reference等待被ReferenceHandler内部线程加入ReferenceQueue中。
Enqueued: 在ReferenceQueue队列中的Reference的状态，如果Reference从队列中移除，会进入Inactive状态。未注册ReferenceQueue的实例不会到达该状态。
Inactive: Reference的最终状态，该状态不会再改变。
 
其状态转换图如下：
 
 
四种引用类型实现
 
不同引用类型的UML类图如下：
 
 
强引用FinalReference
 
对象新建后默认为强引用类型的，是普遍对象引用的类型。查看FinalReference在JDK中的源码发现其只有一个空实现，这也说明强引用是“默认引用类型”。
 
/**
 * Final references, used to implement finalization
 */
class FinalReference<T> extends Reference<T> {
    public FinalReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}
 
软引用SoftReference
 
软引用是用来描述一些“还有用但是非必须”的对象。软引用的回收策略在不同的JVM实现会略有不同，JVM不仅仅只会考虑当前内存情况，还会考虑软引用所指向的referent最近的使用情况和创建时间来综合决定是否回收该referent。软引用保存了两个变量：
 
timestamp：每次调用get方法都会更新时间戳。JVM可以利用该字段来选择要清除的软引用，但不是必须要这样做。
clock：时间锁，由垃圾收集器更新。
 
因此，任何GC都可以使用这些字段并定义清除软引用的策略，例如：最后清除最近创建的或最近使用的软引用。
 
/**
 * 软引用对象由垃圾收集器根据内存需要决定是否清除。软引用经常用于实现内存敏感的缓存。
 *
 * 假如垃圾收集器在某个时间确定对象是软可达的，此时它可以选择原子地清除
 * 指向该对象的所有软引用，以及从该对象通过强引用链连接的其他软可达对象的所有软引用。
 * 与时同时或者之后的某个时间，它会将注册了reference queues的新清除的软引用加入队列。
 *
 * 在虚拟机抛出OutOfMemoryError异常之前，将保证清除对软可达对象的所有软引用。
 * 不过，并没有对清除软引用的时间以及清除顺序施加强制约束。
 * 但是，鼓励虚拟机实现偏向不清除最近创建或最近使用的软引用。
 *
 * 该类的直接实例可用于实现简单的缓存。
 * 该类或其派生子类也可用于更大的数据结构以实现更复杂的高速缓存。
 * 只要软引用的引用对象还是强可达的，即还在实际使用中，软引用就不会被清除。
 * 因此，复杂的高速缓存可以通过持有对最近使用缓存对象的强引用来防止其被清除，
 * 而不常使用的剩余缓存对象由垃圾收集器决定是否清除。
 */
public class SoftReference<T> extends Reference<T> {

	// 时间锁，由垃圾收集器更新。
    static private long clock;

	// 每次调用get方法都会更新该时间戳。JVM可能会在选择要清除的软引用时使用该字段，
	// 但这不是强制必须的。
    private long timestamp;
	
	// 返回对象的引用。如果该引用对象已经被程序或者垃圾收集器清除，则返回null。
	// 把最近一次垃圾回收时间赋值给timestamp
    public T get() {
        T o = super.get();
        if (o != null && this.timestamp != clock)
            this.timestamp = clock;
        return o;
    }

}
 
弱引用WeakReference
 
当一个对象没有被强引用或者软引用连接，但被弱引用连接时，则处于弱可达状态。只要发生GC，弱可达的对象就会被清除，同时会把弱引用加入到注册的引用队列中(如果存在的话)。弱引用对GC几乎是没有影响的，它不影响对应的referent被终结(finalized)和回收(reclaimed)。因此，弱引用最常用于实现规范化映射(canonicalizing mappings)，例如哈希表，如果它们在程序中未被引用，则其键和值将从映射中删除。
 
/**
 * 弱引用对象不能阻止自身的引用被回收。
 * 弱引用常用于实现规范化映射(对象实例可以在程序的多个地方同时使用)。
 *
 * 假如垃圾收集器在某个时间点确定对象是弱可达的。那时它将原子地清除对该对象的所有弱引用
 * 以及该引用通过强引用或者软引用连接的所有其他弱可达对象的所有弱引用。
 * 同时，它将表明前面所指的所有弱可达对象都可以执行finalize方法。
 * 与此同时或之后某一个时间，它将注册了reference queues的那些新清除弱引用加入队列。
 */
public class WeakReference<T> extends Reference<T> {

	// 创建没有注册ReferenceQueue的弱引用
    public WeakReference(T referent) {
        super(referent);
    }

	// 创建注册了ReferenceQueue的弱引用
    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}
 
虚引用PhantomReference
 
虚引用是所有引用类型中最弱的一种。一个对象是否关联到虚引用，完全不会影响该对象的生命周期，也无法通过虚引用来获取一个对象的实例。为对象设置一个虚引用的唯一目的是：能在此对象被垃圾收集器回收的时候收到一个系统通知，它就是利用ReferenceQueue实现的。当referent被gc回收时，JVM自动把虚引用对象本身加入到ReferenceQueue中，表明该reference指向的referent被回收。然后可以通过去queue中取到reference，可以通过这个来做额外的清理工作。可以用虚引用代替对象finalize方法来实现资源释放，这样更加灵活和安全。
 
/**
 * 虚引用对象在被垃圾收集器检查到后加入reference queues队列，否则会被回收。
 * 虚引用最常用于实现比Java finalization机制更灵活的安排额外的清理工作。
 *
 * 如果垃圾收集器在某个时间点确定虚引用对象是虚可达的，那么在那个时间或之后某个时间它会将引用加入reference queues队列。
 *
 * 为了确保可回收对象保持不变，虚引用的引用无法使用：虚引用对象的get方法始终返回null。
 *
 * 与软引用和弱引用不同，当虚引用加入reference queues队列后垃圾收集器不会被自动清除。
 * 只通过虚引用可达的对象将保持不变，直到所有此类引用都被清除或自已变为不可达。
 */
public class PhantomReference<T> extends Reference<T> {

    // 由于不能通过虚引用访问对象，因此此方法始终返回null。
    public T get() {
        return null;
    }

    // 使用空ReferenceQueue队列创建一个虚引用没有意义：它的get方法总是返回null，
	// 并且由于它没有注册队列，所以也不会被加入队列有任何清理前的预处理操作。
    public PhantomReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }
}

首先要明白为什么需要数据类型？
 数据类型在计算机语言中，是对内存位置的一个抽象的表达方式。不同类型的变量在内存中分配的字节数不同，同时存储方式也是不同的。所以给变量赋值前需要先确定变量的类型，即确定了数据需分配内存空间的大小，数据在内存的存储方式。
 JAVA是强类型语言。
 
java中的变量分为两种类型
 
- 基本类型
 
int、float、double、boolean、char…
 不具备对象的特性（不能调用方法、功能简单）
 直接存储在内存中的内存栈上的，数据本身的值就是存储在栈空间里面
 
为了让基本数据类型也具备对象的特性，JAVA为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。
 
基本类型和包装类之间的对应关系：
 
 可以这么记：
 int——>Integer
 char——>Character
 其他——>字母不变（首字母小写变大写）
 
包装类主要提供了两大类方法：
 
 将本类型和其他基本类型进行转换的方法
 将字符串和本类型及包装类互相转换的方法
 
Integer包装类的常用方法：
 包装类——>基本数据类型
 
基本类型和包装类之间的转换
 
在 JDK1.5 引入自动装箱和拆箱的机制后，包装类和基本类型之间的转换就更加轻松便利了。
 
Integer a = new Integer(3);     //定义Integer包装类对象，值为3
int b = a + 5;            //将对象和基本类型进行运算
 
装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
 
int i = 10;           //定义一个int基本类型值
Integer x = new Integer(i);                //手动装箱
Integer y = i;                        //自动装箱
 
拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
 
Integer j = new Integer(8);           //定义一个Integer包装类对象，值为8
int m = j.intValue();          //手动拆箱为int类型
int n = j;                        //自动拆箱为int类型
 
基本类型和字符串之间的转换
 
基本类型转换为字符串有三种方法:
 1.使用包装类的toString()方法
 2.使用String类的valueOf()方法
 3.用一个空字符串加上基本类型
 
int c =10;            //基本数据类型
String str1 = Integer.toString(c);           //方法1
String str2 = String.valueOf(c);            //方法2
String str3 = c + " ";                             //方法3
 
字符串转换成基本类型有两种方法
 1.调用包装类的parseXXX静态方法
 2.调用包装类的valueOf()方法转换为基本类型的包装类，会自动拆箱
 
String str = "8";
int d  = Integer.parseInt(str);            //方法1
int  e = Integer.valueOf(str);            //方法2
 
注意：
 parseInt(String s) 是把字符串——>基本数据类型 (返回int(以整型为例）)
 valueOf(String s) 是把字符串——>包装类对象 (返回Integer(以整型为例）)
 
int  e = Integer.valueOf(str); 
 
虽然valueOf(str)将字符串——>包装类对象，但是JAVA会自动拆箱，使其转换为基本类型。
 
.valueOf前面是什么就转成什么类型
 
- 引用类型
 
继承于Object类， 是一个对象类型。
 按照Java里面存储对象的内存模型来进行数据存储的，使用内存堆和内存栈进行数据存储。
 引用存储在有序的内存栈上的
 而对象本身的值存储在内存堆上的
 
基本数据类型和引用类型的主要区别：
 基本数据类型只有一块存储空间(分配在stack中)
 引用类型有两块存储空间(一块在stack中,一块在heap中)
 

 　在上图中引用类型在传参时不是在heap中再分配一块内存来存变量c 所指向的A(),而是让a 指向同一个A 的实例，这就与C++ 中的指针一样，先声明指针变量a,b,c,d 在传参的时候让a 指向c所指向的内存，让 d 指向 b 所指向的内存。很明显Java中的引用与C++中的指针在原理上是相类似的，但记住Java没有指针，只有引用。
 
 
简单类型是按值传递
 Java 方法的参数是简单类型的时候，是按值传递的 。
 以参数形式传递简单类型的变量时，实际上是将参数的值作了一个拷贝传进方法函数的，那么在方法函数里再怎么改变值，其结果都只是改变了拷贝的值，而不是原值。
 所以像swap（a,b)的例子，传进简单类型是不会交换的，只是把参数的副本进行了交换，原值还是不变。
 
 
引用
 引用其实就像是一个对象的名字或者别名。
 一个对象在内存中会请求一块空间来保存数据，根据对象的大小，它可能需要占用的空间大小也不等。访问对象的时候，我们不会直接是访问对象在内存中的数据，而是通过引用去访问。引用也是一种数据类型，我们可以把它想象为类似 C++ 语言中指针的东西，它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。
 如果我们定义了不止一个引用指向同一个对象，那么这些引用是不相同的，因为引用也是一种数据类型，需要一定的内存空间（stack，栈空间）来保存。但是它们的值是相同的，都指示同一个对象在内存（heap，堆空间）的中位置。比如：
 
String a=“This is a Text!”;
 
String b=a;
 
 

 　通过上面的代码和图形示例不难看出，a 和 b 是不同的两个引用，我们使用了两个定义语句来定义它们。但它们的值是一样的，都指向同一个对象 “This is a Text!”。
 注意：String 对象的值本身是不可更改的 (像 b = “World”; b = a; 这种情况不是改变了 “World” 这一对象的值，而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。
 
两个要点：
 
（1） 引用是一种数据类型（保存在stack中），保存了对象在内存（heap，堆空间）中的地址，这种类型即不是我们平时所说的简单数据类型也不是类实例(对象)；
 
 
 
*（引用类型变量存储在栈内存中，保存的是实际对象在堆内存中的地址，实际对象中保存着内容）
 
 
（2） 不同的引用可能指向同一个对象，换句话说，一个对象可以有多个引用，即该类类型的变量。
 
本人原创，如转载请告知，如有问题，请交流！

注意，不是JVM中的四种引用类型：强、软、弱、虚引用。
 详见我的另一篇文章《JVM中的四种引用类型》
 
Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注
 
引用类型：底层结构和基本类型差别较大
 
JVM的内存空间：
 （1）. Heap 堆空间：分配对象 new Student（）
 （2）. Stack 栈空间：临时变量 Student stu
 （3）.Code 代码区 ：类的定义，静态资源 Student.class
 
Student stu = new Student（）； //new 在内存的堆空间创建对象
stu.study();                   //把对象的地址赋给stu引用变量
 
上例实现步骤：
 a.JVM加载Student.class 到Code区
 b.new Student()在堆空间分配空间并创建一个Student实例
 c.将此实例的地址赋值给引用stu， 栈空间
 
基本数据类类型存的是数值本身，而引用类型变量在内存放的是数据的引用，并不是数据的本身，引用类型变量是以间接方式去获取数据。引用类型变量都属于对象类型，如：数组、类、字符串等都属于引用类型变量。所以，引用类型变量里面存放的是数据的地址。
 
对于 引用变量的比较一般是有两个不同的方法
 1）比较两个变量是不是指向同一个对象，此时，需要比较 a b 中的地址是不是执行同一个值 ，因为此时比较的是 a b 中的地址值，要用 ==
 2）比较 a b 分别对应不同的对象，此时 a b 中的地址 一定是不同的了 ，此时比较的是对象的值 ，因此这里的比较只能用equals

JS有六大数据类型：
 
 
 
Number、String、Boolean、Null、Undefined、Object
 
 
​
 
这些数据类型可以通过 typeof关键字 进行检测
 
typeof 123			//number

typeof 'abc'		//string

typeof true			//boolean

typeof undefined	//undefined

typeof null			//object

typeof { }			//object

typeof [ ]			//object

typeof function(){}	//function
 
 
 
null类型进行typeof操作符后，结果是object，原因在于，null类型被当做一个空对象引用。
 
 
​
 
JS的这些数据类型又分为两大类：
 
 
 
一种存在堆中，叫做引用数据类型，做等号赋值操作进行的是址传递
 
 
一种存在栈中，叫做基本数据类型，做等号赋值操作进行的是值传递
 
 
​
 
存在堆中：引用数据类型（object、function）
 
存在栈中：基本数据类型（number、string、boolean、null、unedfined）
 
​
 
数组Array被归为object类型，用typeof 检测不出来，需要用到 instanceof
 
var arr = [];
console.log(arr instanceof Array);        //true