Synchronized關(guān)鍵字

Java語言的關(guān)鍵字，當(dāng)它用來修飾一個方法或者一個代碼塊的時候，能夠保證在同一時刻最多只有一個線程執(zhí)行該段代碼。

當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線程必須等待當(dāng)前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。
然而，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。
尤其關(guān)鍵的是，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。
第三個例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結(jié)果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。
以上規(guī)則對其它對象鎖同樣適用.
代碼示例

package test160118;

public class TestSynchronized {
  public static void main(String[] args) {
    Sy sy = new Sy(0);
    Sy sy2 = new Sy(1);
    sy.start();
    sy2.start();
  }
}

class Sy extends Thread {
  private int flag ;

  static Object x1 = new Object();
  static Object x2 = new Object();

  public Sy(int flag) {
    this.flag = flag;
  }
  @Override
  public void run() {
    System.out.println(flag);
    try {
      if (flag == 0) {
        synchronized (x1) {
          System.out.println(flag+"鎖住了x1");
          Thread.sleep(1000);
          synchronized (x2) {
            System.out.println(flag+"鎖住了x2");
          }
          System.out.println(flag+"釋放了x1和x2");
        }
      }
      if(flag == 1) {
        synchronized (x2) {
          System.out.println(flag+"鎖住了x2");
          Thread.sleep(1000);
          synchronized (x1) {
            System.out.println(flag+"鎖住了x1");
          }
          System.out.println(flag+"釋放了x1和x2");
        }
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

ThreadLocal無鎖化線程封閉實現(xiàn)原理
ThreadLocal能做什么呢？

這個一句話不好說，我們不如來看看實際項目中遇到的一些困解：當(dāng)你在項目中根據(jù)一些參數(shù)調(diào)用進入一些方法，然后方法再調(diào)用方法，進而跨對象調(diào)用方法，很多層次，這些方法可能都會用到一些相似的參數(shù)，例如，A中需要參數(shù)a、b、c，A調(diào)用B后，B中需要b、c參數(shù)，而B調(diào)用C方法需要a、b參數(shù)，此時不得不將所有的參數(shù)全部傳遞給B，以此類推，若有很多方法的調(diào)用，此時的參數(shù)就會越來越繁雜，另外，當(dāng)程序需要增加參數(shù)的時候，此時需要對相關(guān)的方法逐個增加參數(shù)，是的，很麻煩，相信你也遇到過，這也是在C語言面向?qū)ο筮^來的一些常見處理手段，不過我們簡單的處理方法是將它包裝成對象傳遞進去，通過增加對象的屬性就可以解決這個問題，不過對象通常是有意義的，所以有些時候簡單的對象包裝增加一些擴展不相關(guān)的屬性會使得我們class的定義變得十分的奇怪，所以在這些情況下我們在架構(gòu)這類復(fù)雜的程序的時候，我們通過使用一些類似于Scope的作用域的類來處理，名稱和使用起來都會比較通用，類似web應(yīng)用中會有context、session、request、page等級別的scope，而ThreadLocal也可以解決這類問題，只是他并不是很適合解決這類問題，它面對這些問題通常是初期并沒有按照scope以及對象的方式傳遞，認為不會增加參數(shù)，當(dāng)增加參數(shù)時，發(fā)現(xiàn)要改很多地方的地方，為了不破壞代碼的結(jié)構(gòu)，也有可能參數(shù)已經(jīng)太多，已經(jīng)使得方法的代碼可讀性降低，增加ThreadLocal來處理，例如，一個方法調(diào)用另一個方法時傳入了8個參數(shù)，通過逐層調(diào)用到第N個方法，傳入了其中一個參數(shù)，此時最后一個方法需要增加一個參數(shù)，第一個方法變成9個參數(shù)是自然的，但是這個時候，相關(guān)的方法都會受到牽連，使得代碼變得臃腫不堪。

上面提及到了ThreadLocal一種亡羊補牢的用途，不過也不是特別推薦使用的方式，它還有一些類似的方式用來使用，就是在框架級別有很多動態(tài)調(diào)用，調(diào)用過程中需要滿足一些協(xié)議，雖然協(xié)議我們會盡量的通用，而很多擴展的參數(shù)在定義協(xié)議時是不容易考慮完全的以及版本也是隨時在升級的，但是在框架擴展時也需要滿足接口的通用性和向下兼容，而一些擴展的內(nèi)容我們就需要ThreadLocal來做方便簡單的支持。

簡單來說，ThreadLocal是將一些復(fù)雜的系統(tǒng)擴展變成了簡單定義，使得相關(guān)參數(shù)牽連的部分變得非常容易，以下是我們例子說明：

Spring的事務(wù)管理器中，對數(shù)據(jù)源獲取的Connection放入了ThreadLocal中，程序執(zhí)行完后由ThreadLocal中獲取connection然后做commit和rollback，使用中，要保證程序通過DataSource獲取的connection就是從spring中獲取的，為什么要做這樣的操作呢，因為業(yè)務(wù)代碼完全由應(yīng)用程序來決定，而框架不能要求業(yè)務(wù)代碼如何去編寫，否則就失去了框架不讓業(yè)務(wù)代碼去管理connection的好處了，此時業(yè)務(wù)代碼被切入后，spring不會向業(yè)務(wù)代碼區(qū)傳入一個connection，它必須保存在一個地方，當(dāng)?shù)讓油ㄟ^ibatis、spring jdbc等框架獲取同一個datasource的connection的時候，就會調(diào)用按照spring約定的規(guī)則去獲取，由于執(zhí)行過程都是在同一個線程中處理，從而獲取到相同的connection，以保證commit、rollback以及業(yè)務(wù)操作過程中，使用的connection是同一個，因為只有同一個conneciton才能保證事務(wù)，否則數(shù)據(jù)庫本身也是不支持的。

其實在很多并發(fā)編程的應(yīng)用中，ThreadLocal起著很重要的重要，它不加鎖，非常輕松的將線程封閉做得天衣無縫，又不會像局部變量那樣每次需要從新分配空間，很多空間由于是線程安全，所以，可以反復(fù)利用線程私有的緩沖區(qū)。

如何使用ThreadLocal？

在系統(tǒng)中任意一個適合的位置定義個 ThreadLocal 變量，可以定義為 public static 類型（直接new出來一個ThreadLocal對象），要向里面放入數(shù)據(jù)就使用set(Object)，要獲取數(shù)據(jù)就用get()操作，刪除元素就用remove()，其余的方法是非 public 的方法，不推薦使用。

下面是一個簡單例子（代碼片段1）：

public class ThreadLocalTest2 {

 public final static ThreadLocal <String>TEST_THREAD_NAME_LOCAL = new ThreadLocal<String>();

 public final static ThreadLocal <String>TEST_THREAD_VALUE_LOCAL = new ThreadLocal<String>();

 public static void main(String[]args) {
 for(int i = 0 ; i < 100 ; i++) {
  final String name = "線程-【" + i + "】";
  final String value = String.valueOf(i);
  new Thread() {
  public void run() {
   try {
   TEST_THREAD_NAME_LOCAL.set(name);
   TEST_THREAD_VALUE_LOCAL.set(value);
   callA();
   }finally {
   TEST_THREAD_NAME_LOCAL.remove();
   TEST_THREAD_VALUE_LOCAL.remove();
   }
  }
  }.start();
 }
 }

 public static void callA() {
 callB();
 }

 public static void callB() {
 new ThreadLocalTest2().callC();
 }

 public void callC() {
 callD();
 }

 public void callD() {
 System.out.println(TEST_THREAD_NAME_LOCAL.get() + "/t=/t" + TEST_THREAD_VALUE_LOCAL.get());
 }
}

這里模擬了100個線程去訪問分別設(shè)置 name 和 value ，中間故意將 name 和 value 的值設(shè)置成一樣，看是否會存在并發(fā)的問題，通過輸出可以看出，線程輸出并不是按照順序輸出，說明是并行執(zhí)行的，而線程 name 和 value 是可以對應(yīng)起來的，中間通過多個方法的調(diào)用，以模實際的調(diào)用中參數(shù)不傳遞，如何獲取到對應(yīng)的變量的過程，不過實際的系統(tǒng)中往往會跨類，這里僅僅在一個類中模擬，其實跨類也是一樣的結(jié)果，大家可以自己去模擬就可以。

相信看到這里，很多程序員都對 ThreadLocal 的原理深有興趣，看看它是如何做到的，盡然參數(shù)不傳遞，又可以像局部變量一樣使用它，的確是蠻神奇的，其實看看就知道是一種設(shè)置方式，看到名稱應(yīng)該是是和Thread相關(guān)，那么廢話少說，來看看它的源碼吧，既然我們用得最多的是set、get和remove，那么就從set下手：

set(T obj)方法為（代碼片段2）：

public void set(T value) {
 Thread t = Thread.currentThread();
 ThreadLocalMap map = getMap(t);
 if (map != null)
 map.set(this, value);
 else
 createMap(t, value);
}

首先獲取了當(dāng)前的線程，和猜測一樣，然后有個 getMap 方法，傳入了當(dāng)前線程，我們先可以理解這個map是和線程相關(guān)的map，接下來如果   不為空，就做set操作，你跟蹤進去會發(fā)現(xiàn)，這個和HashMap的put操作類似，也就是向map中寫入了一條數(shù)據(jù)，如果為空，則調(diào)用createMap方法，進去后，看看（ 代碼片段3 ）：

void createMap(Thread t, T firstValue) {
 t.threadLocals = new ThreadLocalMap(this, firstValue);
}

返現(xiàn)創(chuàng)建了一個ThreadLocalMap，并且將傳入的參數(shù)和當(dāng)前ThreadLocal作為K-V結(jié)構(gòu)寫入進去（ 代碼片段4 ）：

ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
 table = new Entry[INITIAL_CAPACITY];
 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
 table[i] = new Entry(firstKey, firstValue);
 size = 1;
 setThreshold(INITIAL_CAPACITY);
}

這里就不說明ThreadLocalMap的結(jié)構(gòu)細節(jié)，只需要知道它的實現(xiàn)和HashMap類似，只是很多方法沒有，也沒有implements Map，因為它并不想讓你通過某些方式（例如反射）獲取到一個Map對他進一步操作，它是一個ThreadLocal里面的一個static內(nèi)部類，default類型，僅僅在java.lang下面的類可以引用到它，所以你可以想到Thread可以引用到它。

我們再回過頭來看看getMap方法，因為上面我僅僅知道獲取的Map是和線程相關(guān)的，而通過 代碼片段3 ，有一個t.threadLocalMap = new ThreadLocalMap(this, firstValue)的時候，相信你應(yīng)該大概有點明白，這個變量應(yīng)該來自Thread里面，我們根據(jù)getMap方法進去看看：

ThreadLocalMap getMap(Thread t) {
 return t.threadLocals;
}

是的，是來自于Thread，而這個Thread正好又是當(dāng)前線程，那么進去看看定義就是：

ThreadLocal.ThreadLocalMap threadLocals = null;

這個屬性就是在Thread類中，也就是每個Thread默認都有一個ThreadLocalMap，用于存放線程級別的局部變量，通常你無法為他賦值，因為這樣的賦值通常是不安全的。

好像是不是有點亂，不著急，我們回頭先摸索下思路：

1、Thread里面有個屬性是一個類似于HashMap一樣的東西，只是它的名字叫ThreadLocalMap，這個屬性是default類型的，因此同一個package下面所有的類都可以引用到，因為是Thread的局部變量，所以每個線程都有一個自己單獨的Map，相互之間是不沖突的，所以即使將ThreadLocal定義為static線程之間也不會沖突。

2、ThreadLocal和Thread是在同一個package下面，可以引用到這個類，可以對他做操作，此時ThreadLocal每定義一個，用this作為Key，你傳入的值作為value，而this就是你定義的ThreadLocal，所以不同的ThreadLocal變量，都使用set，相互之間的數(shù)據(jù)不會沖突，因為他們的Key是不同的，當(dāng)然同一個ThreadLocal做兩次set操作后，會以最后一次為準。

3、綜上所述，在線程之間并行，ThreadLocal可以像局部變量一樣使用，且線程安全，且不同的ThreadLocal變量之間的數(shù)據(jù)毫無沖突。

我們繼續(xù)看看get方法和remove方法，其實就簡單了：

public T get() {
 Thread t = Thread.currentThread();
 ThreadLocalMap map = getMap(t);
 if (map != null) {
 ThreadLocalMap.Entry e = map.getEntry(this);
 if (e != null)
  return (T)e.value;
 }
 return setInitialValue();
}

通過根據(jù)當(dāng)前線程調(diào)用getMap方法，也就是調(diào)用了t.threadLocalMap，然后在map中查找，注意Map中找到的是Entry，也就是K-V基本結(jié)構(gòu)，因為你set寫入的僅僅有值，所以，它會設(shè)置一個e.value來返回你寫入的值，因為Key就是ThreadLocal本身。你可以看到map.getEntry也是通過this來獲取的。

同樣remove方法為：

public void remove() {
 ThreadLocalMap m = getMap(Thread.currentThread());
 if (m != null)
  m.remove(this);
}

同樣根據(jù)當(dāng)前線程獲取map，如果不為空，則remove，通過this來remove。

補充下（2013-6-29），搞忘寫有什么坑了，這個ThreadLocal有啥坑呢，大家從前面應(yīng)該可以看出來，這個ThreadLocal相關(guān)的對象是被綁定到一個Map中的，而這個Map是Thread線程的中的一個屬性，那么就有一個問題是，如果你不自己remove的話或者說如果你自己的程序中不知道什么時候去remove的話，那么線程不注銷，這些被set進去的數(shù)據(jù)也不會被注銷。

反過來說，寫代碼中除非你清晰的認識到這個對象應(yīng)該在哪里set，哪里remove，如果是模糊的，很可能你的代碼中不會走remove的位置去，或?qū)е乱恍┻壿媶栴}，另外，如果不remove的話，就要等線程注銷，我們在很多應(yīng)用服務(wù)器中，線程是被復(fù)用的，因為在內(nèi)核分配線程還是有開銷的，因此在這些應(yīng)用中線程很難會被注銷掉，那么向ThreadLocal寫入的數(shù)據(jù)自然很不容易被注銷掉，這些可能在我們使用某些開源框架的時候無意中被隱藏用到，都有可能會導(dǎo)致問題，最后發(fā)現(xiàn)OOM得時候數(shù)據(jù)竟然來自ThreadLocalMap中，還不知道這些數(shù)據(jù)是從哪里設(shè)置進去的，所以你應(yīng)當(dāng)注意這個坑，可能不止一個人掉進這個坑里去過。

最新評論