深刻ThreadLocal的內部機制

深刻ThreadLocal的內部機制

早在JDK 1.2的版本中就提供java.lang.ThreadLocalThreadLocal爲解決多線程程序的併發問題提供了一種新的思路。使用這個工具類能夠很簡潔地編寫出優美的多線程程序。ThreadLocal並非一個Thread,而是Thread的局部變量。當使用ThreadLocal維護變量時,ThreadLocal爲每一個使用該變量的線程提供獨立的變量副本。 java

ThreadLocal的接口方法: 緩存

void set(Object value):設置當前線程的線程局部變量的值。 多線程

public Object get():該方法返回當前線程所對應的線程局部變量。 併發

public void remove():將當前線程局部變量的值刪除,目的是爲了減小內存的佔用,該方法是JDK 5.0新增的方法。 dom

須要指出的是,當線程結束後,對應該線程的局部變量將自動被垃圾回收, ide

因此顯式調用該方法清除線程的局部變量並非必須的操做,但它能夠加快內存回收的速度。 工具

protected Object initialValue():返回該線程局部變量的初始值,該方法是一個protected的方法,顯然是爲了讓子類覆蓋而設計的。 測試

這個方法是一個延遲調用方法,在線程第1次調用get()set(Object)時才執行, this

而且僅執行1次。ThreadLocal中的缺省實現直接返回一個nullspa

JDK5.0中,ThreadLocal已經支持泛型,該類的類名已經變爲ThreadLocal<T>

ThreadLocal是如何作到爲每個線程維護變量的副本的呢?其實實現的思路很簡單:在ThreadLocal類中有一個Map,用於存儲每個線程的變量副本

模擬ThreadLocal代碼清單:

package cn.itcast.ref;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.Random;

public class MyThreadLocal {

    //使用同步的map維護對象- 王健-QQ549051701

    private static Map<Thread,Object> map =

              Collections.synchronizedMap(new HashMap<Thread,Object>());

    public static Object get(){

       //獲取當前線程

       Thread currentThread = Thread.currentThread();

       Object o = map.get(currentThread);

       if(o==null){

           o = new Random().nextInt(100);//假設是一個隨機數

           map.put(currentThread, o);

       }

       return o;

    }

    public static void remove(){

       Thread currentThread = Thread.currentThread();

       if(map.containsKey(currentThread)){

           map.remove(currentThread);

       }

    }

}

雖然這個ThreadLocal實現版本顯得比較幼稚,但它和JDK所提供的ThreadLocal類在實現思路上是相近的。

 

測試代碼清單:

    @Test

    public void testMyThreadLocal(){

       Object o1 = MyThreadLocal.get();

       Object o2 = MyThreadLocal.get();

       //如下由於是同一個線程全部值相同

       System.err.println(o1+","+o2);

       new Thread(){

           public void run() {

              //在新的線程中獲取對象爲不一樣的值

              Object o3 = MyThreadLocal.get();

              System.err.println("o3:"+o3);

           };

       }.start();

    }

 

什麼時候清除對象的問題

       ThreadLocal能夠很好的維護線程局部的對象,那麼它是如何作到及時將對象從內存中回收的呢?

       遍觀ThreadLocal的源代碼可知,ThreadLocal是經過弱引用實現對象能夠在內存被及時清回收的,如下是從ThreadLocal內部類Entry的源代碼,可見Entry內部是WeakReferences(弱引用)的子類,即一個弱引用而已:

        static class Entry extends WeakReference<ThreadLocal> {

            /** The value associated with this ThreadLocal. */

            Object value;

            Entry(ThreadLocal k, Object v) {

                super(k);

                value = v;

            }

        }

 

對象的引用

JDK1.2版本開始,把對象的引用分爲四種級別,從而使程序能更加靈活的控制對象的生命週期。這四種級別由高到低依次爲:強引用、軟引用、弱引用和虛引用。

1.強引用

       Person p = new Persion();

通常狀況下介紹的引用實際上都是強引用,這是使用最廣泛的引用。若是一個對象具備強引用,那就相似於必不可少的生活用品,垃圾回收器毫不會回收它。當內存空 間不足,Java虛擬機寧願拋出OutOfMemoryError錯誤,使程序異常終止,也不會靠隨意回收具備強引用的對象來解決內存不足問題。

2.軟引用(SoftReference

若是一個對象只具備軟引用,那就相似於可有可物的生活用品。若是內存空間足夠,垃圾回收器就不會回收它,若是內存空間不足了,就會回收這些對象的內存。只要垃圾回收器沒有回收它,該對象就能夠被程序使用。軟引用可用來實現內存敏感的高速緩存。軟引用能夠和一個引用隊列(ReferenceQueue)聯合使用,若是軟引用所引用的對象被垃圾回收,Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。

3.弱引用(WeakReference

若是一個對象只具備弱引用,那就相似於可有可物的生活用品。弱引用與軟引用的區別在於:只具備弱引用的對象擁有更短暫的生命週期。在垃圾回收器線程掃描它 所管轄的內存區域的過程當中,一旦發現了只具備弱引用的對象,無論當前內存空間足夠與否,都會回收它的內存。不過,因爲垃圾回收器是一個優先級很低的線程, 所以不必定會很快發現那些只具備弱引用的對象。弱引用能夠和一個引用隊列(ReferenceQueue)聯合使用,若是弱引用所引用的對象被垃圾回收,Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。

4.虛引用(PhantomReference

"虛引用"顧名思義,就是形同虛設,與其餘幾種引用都不一樣,虛引用並不會決定對象的生命週期。若是一個對象僅持有虛引用,那麼它就和沒有任何引用同樣,在任什麼時候候均可能被垃圾回收。虛引用主要用來跟蹤對象被垃圾回收的活動。虛引用與軟引用和弱引用的一個區別在於:虛引用必須和引用隊列(ReferenceQueue)聯合使用。當垃 圾回收器準備回收一個對象時,若是發現它還有虛引用,就會在回收對象的內存以前,把這個虛引用加入到與之關聯的引用隊列中。程序能夠經過判斷引用隊列中是 否已經加入了虛引用,來了解被引用的對象是否將要被垃圾回收。程序若是發現某個虛引用已經被加入到引用隊列,那麼就能夠在所引用的對象的內存被回收以前採起必要的行動。

爲弱引用使用較多:

弱引用的示例代碼:

    /**

     * 弱引用的示例 - 王健 - QQ549051701

     */

    @Test

    public void testRef2() throws Exception{

       //聲明一個引用隊列

       ReferenceQueue<Person> pp = new ReferenceQueue<Person>();

       //聲明一個弱引用對象,引用一個Person對象

       WeakReference<Person> rq = new WeakReference<Person>(new Person("弱引用"),pp);

       //催促垃圾回收,因爲Person沒有被任何變量引用,因此會被回收

       System.gc();

       //給垃圾回收器留出足夠的時間

       Thread.sleep(1000);

       //被回收之後,獲取到的p對象將變成null值

       Person p = rq.get();

       System.err.println("ppp:"+p);

       //被回收之後的對象,將會放到回收隊列中,但已經不能夠再使用

       Reference<? extends Person> ref= pp.poll();

       //若是有對象已經被回收,則返回一個對象,不然返回null

       System.err.println(">>:"+ref);

    }

 

模擬使用弱引用實現的ThreadLoale

package cn.itcast.ref;

import java.lang.ref.WeakReference;

import java.util.HashMap;

import java.util.Map;

public class MyThreadLocale{

    //聲明爲實例成員變量

    private Map<MyThreadLocale, WeakReference<Object>> mm

           = new HashMap<MyThreadLocale, WeakReference<Object>>();

    public void set(Object t){

       mm.put(this,new WeakReference<Object>(t));

    }

    public Object get(){

       WeakReference<Object> wk = mm.get(this);

       if(wk==null){

           return null;

       }else{

           Object o = wk.get();

           return o;

       }

    }

}

 

測試代碼:

    @Test

    public void testWeak(){

       MyThreadLocale mm = new MyThreadLocale();

       mm.set(new Dog("Jack"));

       Object o = mm.get();//只要是被強引用就不會被回收

       System.gc();

       Object oo = mm.get();

       System.err.println("返回的值爲:"+oo);

    }

如下是Dog類:

class Dog{

    private String name;

    public Dog(String name){

       this.name=name;

    }

    @Override

    public String toString() {

       return "Dog [name=" + name + "]";

    }

    @Override

    protected void finalize() throws Throwable {

       System.err.println("OKOKOKK");

    }

}

相關文章
相關標籤/搜索