面試中經(jīng)常被問到Java引用類型原理，帶你深入剖析
1.選擇唯一性索引
唯一性索引的值是唯一的，可以更快速的通過該索引來確定某條記錄。例如，學(xué)生表中學(xué)號(hào)是具有唯一性的字段。為該字段建立唯一性索引可以很快的確定某個(gè)學(xué)生的信息。如果使用姓名的話，可能存在同名現(xiàn)象，從而降低查詢速度。
2.為經(jīng)常需要排序、分組和聯(lián)合操作的字段建立索引
經(jīng)常需要ORDER BY、GROUP BY、DISTINCT和UNION等操作的字段，排序操作會(huì)浪費(fèi)很多時(shí)間。如果為其建立索引，可以有效地避免排序操作。
3.為常作為查詢條件的字段建立索引
如果某個(gè)字段經(jīng)常用來做查詢條件，那么該字段的查詢速度會(huì)影響整個(gè)表的查詢速度。因此，為這樣的字段建立索引，可以提高整個(gè)表的查詢速度。
4.限制索引的數(shù)目
索引的數(shù)目不是越多越好。每個(gè)索引都需要占用磁盤空間，索引越多，需要的磁盤空間就越大。修改表時(shí)，對索引的重構(gòu)和更新很麻煩。越多的索引，會(huì)使更新表變得很浪費(fèi)時(shí)間。
5.盡量使用數(shù)據(jù)量少的索引
如果索引的值很長，那么查詢的速度會(huì)受到影響。例如，對一個(gè)CHAR(100)類型的字段進(jìn)行全文檢索需要的時(shí)間肯定要比對CHAR(10)類型的字段需要的時(shí)間要多。
6.盡量使用前綴來索引
如果索引字段的值很長，最好使用值的前綴來索引。例如，TEXT和BLOG類型的字段，進(jìn)行全文檢索會(huì)很浪費(fèi)時(shí)間。如果只檢索字段的前面的若干個(gè)字符，這樣可以提高檢索速度。
7.刪除不再使用或者很少使用的索引
表中的數(shù)據(jù)被大量更新，或者數(shù)據(jù)的使用方式被改變后，原有的一些索引可能不再需要。數(shù)據(jù)庫管理員應(yīng)當(dāng)定期找出這些索引，將它們刪除，從而減少索引對更新操作的影響。
8.最左前綴匹配原則，非常重要的原則。
mysql會(huì)一直向右匹配直到遇到范圍查詢(>、<、between、like)就停止匹配，比如a 1=”” and=”” b=”2” c=”“> 3 and d = 4 如果建立(a,b,c,d)順序的索引，d是用不到索引的，如果建立(a,b,d,c)的索引則都可以用到，a,b,d的順序可以任意調(diào)整。
9.=和in可以亂序。
比如a = 1 and b = 2 and c = 3 建立(a,b,c)索引可以任意順序，mysql的查詢優(yōu)化器會(huì)幫你優(yōu)化成索引可以識(shí)別的形式
10.盡量選擇區(qū)分度高的列作為索引。
區(qū)分度的公式是count(distinct col)/count(*)，表示字段不重復(fù)的比例，比例越大我們掃描的記錄數(shù)越少，唯一鍵的區(qū)分度是1，而一些狀態(tài)、性別字段可能在大數(shù)據(jù)面前區(qū)分度就 是0，那可能有人會(huì)問，這個(gè)比例有什么經(jīng)驗(yàn)值嗎?使用場景不同，這個(gè)值也很難確定，一般需要join的字段我們都要求是0.1以上，即平均1條掃描10條 記錄
11.索引列不能參與計(jì)算，保持列“干凈”。
比如from_unixtime(create_time) = ’2014-05-29’就不能使用到索引，原因很簡單，b+樹中存的都是數(shù)據(jù)表中的字段值，但進(jìn)行檢索時(shí)，需要把所有元素都應(yīng)用函數(shù)才能比較，顯然成本 太大。所以語句應(yīng)該寫成create_time = unix_timestamp(’2014-05-29’);
12.盡量的擴(kuò)展索引，不要新建索引。
比如表中已經(jīng)有a的索引，現(xiàn)在要加(a,b)的索引，那么只需要修改原來的索引即可
注意：選擇索引的最終目的是為了使查詢的速度變快。上面給出的原則是最基本的準(zhǔn)則，但不能拘泥于上面的準(zhǔn)則。讀者要在以后的學(xué)習(xí)和工作中進(jìn)行不斷的實(shí)踐。根據(jù)應(yīng)用的實(shí)際情況進(jìn)行分析和判斷，選擇最合適的索引方式。
Java中一共有4種引用類型(其實(shí)還有一些其他的引用類型比如FinalReference)：強(qiáng)引用、軟引用、弱引用、虛引用。
其中強(qiáng)引用就是我們經(jīng)常使用的Object a = new Object(); 這樣的形式，在Java中并沒有對應(yīng)的Reference類。
本篇文章主要是分析軟引用、弱引用、虛引用的實(shí)現(xiàn)，這三種引用類型都是繼承于Reference這個(gè)類，主要邏輯也在Reference中。
問題
在分析前，先拋幾個(gè)問題?
- 網(wǎng)上大多數(shù)文章對于軟引用的介紹是：在內(nèi)存不足的時(shí)候才會(huì)被回收，那內(nèi)存不足是怎么定義的?什么才叫內(nèi)存不足?
- 網(wǎng)上大多數(shù)文章對于虛引用的介紹是：形同虛設(shè)，虛引用并不會(huì)決定對象的生命周期。主要用來跟蹤對象被垃圾回收器回收的活動(dòng)。真的是這樣嗎?
- 虛引用在Jdk中有哪些場景下用到了呢?
Reference
我們先看下Reference.java中的幾個(gè)字段
- public abstract class Reference<T> {
- //引用的對象
- private T referent;
- //回收隊(duì)列，由使用者在Reference的構(gòu)造函數(shù)中指定
- volatile ReferenceQueue<? super T> queue;
- //當(dāng)該引用被加入到queue中的時(shí)候，該字段被設(shè)置為queue中的下一個(gè)元素，以形成鏈表結(jié)構(gòu)
- volatile Reference next;
- //在GC時(shí)，JVM底層會(huì)維護(hù)一個(gè)叫DiscoveredList的鏈表，存放的是Reference對象，discovered字段指向的就是鏈表中的下一個(gè)元素，由JVM設(shè)置
- transient private Reference<T> discovered;
- //進(jìn)行線程同步的鎖對象
- static private class Lock { }
- private static Lock lock = new Lock();
- //等待加入queue的Reference對象，在GC時(shí)由JVM設(shè)置，會(huì)有一個(gè)java層的線程(ReferenceHandler)源源不斷的從pending中提取元素加入到queue
- private static Reference<Object> pending = null;
- }
一個(gè)Reference對象的生命周期如下：
主要分為Native層和Java層兩個(gè)部分。
Native層在GC時(shí)將需要被回收的Reference對象加入到DiscoveredList中(代碼在referenceProcessor.cpp中
process_discovered_references方法)，然后將DiscoveredList的元素移動(dòng)到PendingList中(代碼在referenceProcessor.cpp中enqueue_discovered_ref_helper方法),PendingList的隊(duì)首就是Reference類中的pending對象。
看看Java層的代碼
- private static class ReferenceHandler extends Thread {
- ...
- public void run() {
- while (true) {
- tryHandlePending(true);
- }
- }
- }
- static boolean tryHandlePending(boolean waitForNotify) {
- Reference<Object> r;
- Cleaner c;
- try {
- synchronized (lock) {
- if (pending != null) {
- r = pending;
- //如果是Cleaner對象，則記錄下來，下面做特殊處理
- c = r instanceof Cleaner ? (Cleaner) r : null;
- //指向PendingList的下一個(gè)對象
- pending = r.discovered;
- r.discovered = null;
- } else {
- //如果pending為null就先等待，當(dāng)有對象加入到PendingList中時(shí)，jvm會(huì)執(zhí)行notify
- if (waitForNotify) {
- lock.wait();
- }
- // retry if waited
- return waitForNotify;
- }
- }
- }
- ...
- // 如果時(shí)CLeaner對象，則調(diào)用clean方法進(jìn)行資源回收
- if (c != null) {
- c.clean();
- return true;
- }
- //將Reference加入到ReferenceQueue，開發(fā)者可以通過從ReferenceQueue中poll元素感知到對象被回收的事件。
- ReferenceQueue<? super Object> q = r.queue;
- if (q != ReferenceQueue.NULL) q.enqueue(r);
- return true;
- }
流程比較簡單：就是源源不斷的從PendingList中提取出元素，然后將其加入到ReferenceQueue中去，開發(fā)者可以通過從ReferenceQueue中poll元素感知到對象被回收的事件。
另外需要注意的是，對于Cleaner類型(繼承自虛引用)的對象會(huì)有額外的處理：在其指向的對象被回收時(shí)，會(huì)調(diào)用clean方法，該方法主要是用來做對應(yīng)的資源回收，在堆外內(nèi)存DirectByteBuffer中就是用Cleaner進(jìn)行堆外內(nèi)存的回收，這也是虛引用在java中的典型應(yīng)用。
看完了Reference的實(shí)現(xiàn)，再看看幾個(gè)實(shí)現(xiàn)類里，各自有什么不同。
SoftReference
- public class SoftReference<T> extends Reference<T> {
- static private long clock;
- private long timestamp;
- public SoftReference(T referent) {
- super(referent);
- this.timestamp = clock;
- }
- public SoftReference(T referent, ReferenceQueue<? super T> q) {
- super(referent, q);
- this.timestamp = clock;
- }
- public T get() {
- T o = super.get();
- if (o != null && this.timestamp != clock)
- this.timestamp = clock;
- return o;
- }
- }
軟引用的實(shí)現(xiàn)很簡單，就多了兩個(gè)字段：clock和timestamp。clock是個(gè)靜態(tài)變量，每次GC時(shí)都會(huì)將該字段設(shè)置成當(dāng)前時(shí)間。timestamp字段則會(huì)在每次調(diào)用get方法時(shí)將其賦值為clock(如果不相等且對象沒被回收)。
那這兩個(gè)字段的作用是什么呢?這和軟引用在內(nèi)存不夠的時(shí)候才被回收，又有什么關(guān)系呢?
這些還得看JVM的源碼才行，因?yàn)闆Q定對象是否需要被回收都是在GC中實(shí)現(xiàn)的。
- size_t
- ReferenceProcessor::process_discovered_reflist(
- DiscoveredList refs_lists[],
- ReferencePolicy* policy,
- bool clear_referent,
- BoolObjectClosure* is_alive,
- OopClosure* keep_alive,
- VoidClosure* complete_gc,
- AbstractRefProcTaskExecutor* task_executor)
- {
- ...
- //還記得上文提到過的DiscoveredList嗎?refs_lists就是DiscoveredList。
- //對于DiscoveredList的處理分為幾個(gè)階段，SoftReference的處理就在第一階段
- ...
- for (uint i = 0; i < _max_num_q; i++) {
- process_phase1(refs_lists[i], policy,
- is_alive, keep_alive, complete_gc);
- }
- ...
- }
- //該階段的主要目的就是當(dāng)內(nèi)存足夠時(shí)，將對應(yīng)的SoftReference從refs_list中移除。
- void
- ReferenceProcessor::process_phase1(DiscoveredList& refs_list,
- ReferencePolicy* policy,
- BoolObjectClosure* is_alive,
- OopClosure* keep_alive,
- VoidClosure* complete_gc) {
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
- // Decide which softly reachable refs should be kept alive.
- while (iter.has_next()) {
- iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
- //判斷引用的對象是否存活
- bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
- //如果引用的對象已經(jīng)不存活了，則會(huì)去調(diào)用對應(yīng)的ReferencePolicy判斷該對象是不時(shí)要被回收
- if (referent_is_dead &&
- !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
- if (TraceReferenceGC) {
- gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy",
- (void *)iter.obj(), iter.obj()->klass()->internal_name());
- }
- // Remove Reference object from list
- iter.remove();
- // Make the Reference object active again
- iter.make_active();
- // keep the referent around
- iter.make_referent_alive();
- iter.move_to_next();
- } else {
- iter.next();
- }
- }
- ...
- }
refs_lists中存放了本次GC發(fā)現(xiàn)的某種引用類型(虛引用、軟引用、弱引用等)，而
process_discovered_reflist方法的作用就是將不需要被回收的對象從refs_lists移除掉，refs_lists最后剩下的元素全是需要被回收的元素，最后會(huì)將其第一個(gè)元素賦值給上文提到過的Reference.java#pending字段。
ReferencePolicy一共有4種實(shí)現(xiàn)：NeverClearPolicy，AlwaysClearPolicy，LRUCurrentHeapPolicy，LRUMaxHeapPolicy。
其中NeverClearPolicy永遠(yuǎn)返回false，代表永遠(yuǎn)不回收SoftReference，在JVM中該類沒有被使用，AlwaysClearPolicy則永遠(yuǎn)返回true，在referenceProcessor.hpp#setup方法中中可以設(shè)置policy為AlwaysClearPolicy，至于什么時(shí)候會(huì)用到AlwaysClearPolicy，大家有興趣可以自行研究。
LRUCurrentHeapPolicy和LRUMaxHeapPolicy的should_clear_reference方法則是完全相同：
- bool LRUMaxHeapPolicy::should_clear_reference(oop p,
- jlong timestamp_clock) {
- jlong interval = timestamp_clock - java_lang_ref_SoftReference::timestamp(p);
- assert(interval >= 0, "Sanity check");
- // The interval will be zero if the ref was accessed since the last scavenge/gc.
- if(interval <= _max_interval) {
- return false;
- }
- return true;
- }
timestamp_clock就是SoftReference的靜態(tài)字段clock，
java_lang_ref_SoftReference::timestamp(p)對應(yīng)是字段timestamp。如果上次GC后有調(diào)用SoftReference#get，interval值為0，否則為若干次GC之間的時(shí)間差。
_max_interval則代表了一個(gè)臨界值，它的值在LRUCurrentHeapPolicy和LRUMaxHeapPolicy兩種策略中有差異。
- void LRUCurrentHeapPolicy::setup() {
- _max_interval = (Universe::get_heap_free_at_last_gc() / M) * SoftRefLRUPolicyMSPerMB;
- assert(_max_interval >= 0,"Sanity check");
- }
- void LRUMaxHeapPolicy::setup() {
- size_t max_heap = MaxHeapSize;
- max_heap -= Universe::get_heap_used_at_last_gc();
- max_heap /= M;
- _max_interval = max_heap * SoftRefLRUPolicyMSPerMB;
- assert(_max_interval >= 0,"Sanity check");
- }
看到這里你就知道SoftReference到底什么時(shí)候被被回收了，它和使用的策略(默認(rèn)應(yīng)該是LRUCurrentHeapPolicy)，堆可用大小，該SoftReference上一次調(diào)用get方法的時(shí)間都有關(guān)系。
WeakReference
- public class WeakReference<T> extends Reference<T> {
- public WeakReference(T referent) {
- super(referent);
- }
- public WeakReference(T referent, ReferenceQueue<? super T> q) {
- super(referent, q);
- }
- }
可以看到，對于Soft references和Weak references clear_referent字段傳入的都是true，這也符合我們的預(yù)期：對象不可達(dá)后，引用字段就會(huì)被置為null，然后對象就會(huì)被回收(對于軟引用來說，如果內(nèi)存足夠的話，在Phase 1，相關(guān)的引用就會(huì)從refs_list中被移除，到Phase 3時(shí)refs_list為空集合)。
但對于Final references和 Phantom references，clear_referent字段傳入的是false，也就意味著被這兩種引用類型引用的對象，如果沒有其他額外處理，只要Reference對象還存活，那引用的對象是不會(huì)被回收的。Final references和對象是否重寫了finalize方法有關(guān)，不在本文分析范圍之內(nèi)，我們接下來看看Phantom references。
可以看到WeakReference在Java層只是繼承了Reference，沒有做任何的改動(dòng)。那referent字段是什么時(shí)候被置為null的呢?要搞清楚這個(gè)問題我們再看下上文提到過的
process_discovered_reflist方法：
- size_t
- ReferenceProcessor::process_discovered_reflist(
- DiscoveredList refs_lists[],
- ReferencePolicy* policy,
- bool clear_referent,
- BoolObjectClosure* is_alive,
- OopClosure* keep_alive,
- VoidClosure* complete_gc,
- AbstractRefProcTaskExecutor* task_executor)
- {
- ...
- //Phase 1:將所有不存活但是還不能被回收的軟引用從refs_lists中移除（只有refs_lists為軟引用的時(shí)候，這里policy才不為null）
- if (policy != NULL) {
- if (mt_processing) {
- RefProcPhase1Task phase1(*this, refs_lists, policy, true /*marks_oops_alive*/);
- task_executor->execute(phase1);
- } else {
- for (uint i = 0; i < _max_num_q; i++) {
- process_phase1(refs_lists[i], policy,
- is_alive, keep_alive, complete_gc);
- }
- }
- } else { // policy == NULL
- assert(refs_lists != _discoveredSoftRefs,
- "Policy must be specified for soft references.");
- }
- // Phase 2:
- // 移除所有指向?qū)ο筮€存活的引用
- if (mt_processing) {
- RefProcPhase2Task phase2(*this, refs_lists, !discovery_is_atomic() /*marks_oops_alive*/);
- task_executor->execute(phase2);
- } else {
- for (uint i = 0; i < _max_num_q; i++) {
- process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);
- }
- }
- // Phase 3:
- // 根據(jù)clear_referent的值決定是否將不存活對象回收
- if (mt_processing) {
- RefProcPhase3Task phase3(*this, refs_lists, clear_referent, true /*marks_oops_alive*/);
- task_executor->execute(phase3);
- } else {
- for (uint i = 0; i < _max_num_q; i++) {
- process_phase3(refs_lists[i], clear_referent,
- is_alive, keep_alive, complete_gc);
- }
- }
- return total_list_count;
- }
- void
- ReferenceProcessor::process_phase3(DiscoveredList& refs_list,
- bool clear_referent,
- BoolObjectClosure* is_alive,
- OopClosure* keep_alive,
- VoidClosure* complete_gc) {
- ResourceMark rm;
- DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
- while (iter.has_next()) {
- iter.update_discovered();
- iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
- if (clear_referent) {
- // NULL out referent pointer
- //將Reference的referent字段置為null，之后會(huì)被GC回收
- iter.clear_referent();
- } else {
- // keep the referent around
- //標(biāo)記引用的對象為存活，該對象在這次GC將不會(huì)被回收
- iter.make_referent_alive();
- }
- ...
- }
- ...
- }
不管是弱引用還是其他引用類型，將字段referent置null的操作都發(fā)生在process_phase3中，而具體行為是由clear_referent的值決定的。而clear_referent的值則和引用類型相關(guān)。
- ReferenceProcessorStats ReferenceProcessor::process_discovered_references(
- BoolObjectClosure* is_alive,
- OopClosure* keep_alive,
- VoidClosure* complete_gc,
- AbstractRefProcTaskExecutor* task_executor,
- GCTimer* gc_timer) {
- NOT_PRODUCT(verify_ok_to_handle_reflists());
- ...
- //process_discovered_reflist方法的第3個(gè)字段就是clear_referent
- // Soft references
- size_t soft_count = 0;
- {
- GCTraceTime tt("SoftReference", trace_time, false, gc_timer);
- soft_count =
- process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
- is_alive, keep_alive, complete_gc, task_executor);
- }
- update_soft_ref_master_clock();
- // Weak references
- size_t weak_count = 0;
- {
- GCTraceTime tt("WeakReference", trace_time, false, gc_timer);
- weak_count =
- process_discovered_reflist(_discoveredWeakRefs, NULL, true,
- is_alive, keep_alive, complete_gc, task_executor);
- }
- // Final references
- size_t final_count = 0;
- {
- GCTraceTime tt("FinalReference", trace_time, false, gc_timer);
- final_count =
- process_discovered_reflist(_discoveredFinalRefs, NULL, false,
- is_alive, keep_alive, complete_gc, task_executor);
- }
- // Phantom references
- size_t phantom_count = 0;
- {
- GCTraceTime tt("PhantomReference", trace_time, false, gc_timer);
- phantom_count =
- process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
- is_alive, keep_alive, complete_gc, task_executor);
- }
- ...
- }
可以看到，對于Soft references和Weak references clear_referent字段傳入的都是true，這也符合我們的預(yù)期：對象不可達(dá)后，引用字段就會(huì)被置為null，然后對象就會(huì)被回收(對于軟引用來說，如果內(nèi)存足夠的話，在Phase 1，相關(guān)的引用就會(huì)從refs_list中被移除，到Phase 3時(shí)refs_list為空集合)。
但對于Final references和 Phantom references，clear_referent字段傳入的是false，也就意味著被這兩種引用類型引用的對象，如果沒有其他額外處理，只要Reference對象還存活，那引用的對象是不會(huì)被回收的。Final references和對象是否重寫了finalize方法有關(guān)，不在本文分析范圍之內(nèi)，我們接下來看看Phantom references。
PhantomReference
- public class PhantomReference<T> extends Reference<T> {
- public T get() {
- return null;
- }
- public PhantomReference(T referent, ReferenceQueue<? super T> q) {
- super(referent, q);
- }
- }
可以看到虛引用的get方法永遠(yuǎn)返回null，我們看個(gè)demo。
- public static void demo() throws InterruptedException {
- Object obj = new Object();
- ReferenceQueue<Object> refQueue =new ReferenceQueue<>();
- PhantomReference<Object> phanRef =new PhantomReference<>(obj, refQueue);
- Object objg = phanRef.get();
- //這里拿到的是null
- System.out.println(objg);
- //讓obj變成垃圾
- obj=null;
- System.gc();
- Thread.sleep(3000);
- //gc后會(huì)將phanRef加入到refQueue中
- Reference<? extends Object> phanRefP = refQueue.remove();
- //這里輸出true
- System.out.println(phanRefP==phanRef);
- }
從以上代碼中可以看到，虛引用能夠在指向?qū)ο蟛豢蛇_(dá)時(shí)得到一個(gè)'通知'(其實(shí)所有繼承References的類都有這個(gè)功能)，需要注意的是GC完成后，phanRef.referent依然指向之前創(chuàng)建Object，也就是說Object對象一直沒被回收!
而造成這一現(xiàn)象的原因在上一小節(jié)末尾已經(jīng)說了：對于Final references和 Phantom references，clear_referent字段傳入的時(shí)false，也就意味著被這兩種引用類型引用的對象，如果沒有其他額外處理，在GC中是不會(huì)被回收的。
對于虛引用來說，從refQueue.remove();得到引用對象后，可以調(diào)用clear方法強(qiáng)行解除引用和對象之間的關(guān)系，使得對象下次可以GC時(shí)可以被回收掉。
End
針對文章開頭提出的幾個(gè)問題，看完分析，我們已經(jīng)能給出回答：
1.我們經(jīng)常在網(wǎng)上看到軟引用的介紹是：在內(nèi)存不足的時(shí)候才會(huì)回收，那內(nèi)存不足是怎么定義的?為什么才叫內(nèi)存不足?
軟引用會(huì)在內(nèi)存不足時(shí)被回收，內(nèi)存不足的定義和該引用對象get的時(shí)間以及當(dāng)前堆可用內(nèi)存大小都有關(guān)系，計(jì)算公式在上文中也已經(jīng)給出。
2.網(wǎng)上對于虛引用的介紹是：形同虛設(shè)，與其他幾種引用都不同，虛引用并不會(huì)決定對象的生命周期。主要用來跟蹤對象被垃圾回收器回收的活動(dòng)。真的是這樣嗎?
嚴(yán)格的說，虛引用是會(huì)影響對象生命周期的，如果不做任何處理，只要虛引用不被回收，那其引用的對象永遠(yuǎn)不會(huì)被回收。所以一般來說，從ReferenceQueue中獲得PhantomReference對象后，如果PhantomReference對象不會(huì)被回收的話(比如被其他GC ROOT可達(dá)的對象引用)，需要調(diào)用clear方法解除PhantomReference和其引用對象的引用關(guān)系。
3.虛引用在Jdk中有哪些場景下用到了呢?
DirectByteBuffer中是用虛引用的子類Cleaner.java來實(shí)現(xiàn)堆外內(nèi)存回收的，后續(xù)會(huì)寫篇文章來說說堆外內(nèi)存的里里外外。
