Java——多線程編程學習/01

標籤：alt   lin   訪問   hnoi   解決   dex   行業   損壞   安全   

原文章：http://www.cnblogs.com/QG-whz/p/8351298.html  註：建議去看原博主的文章，單就這個知識點而論，比書本講的透徹，如有違規，聯絡必刪！

並發環境下進行編程時，需要使用鎖機制來同步多線程間的操作，保證共用資源的互斥訪問。加鎖會帶來效能上的損壞，似乎是眾所周知的事情。然而，加鎖本身不會帶來多少的效能消耗，效能主要是線上程的擷取鎖的過程。如果只有一個線程競爭鎖，此時並不存在多線程競爭的情況，那麼JVM會進行最佳化，那麼這時加鎖帶來的效能消耗基本可以忽略。因此，規範加鎖的操作，最佳化鎖的使用方法，避免不必要的線程競爭，不僅可以提高程式效能，也能避免不規範加鎖可能造成線程死結問題，提高程式健壯性。下面闡述幾種鎖最佳化的思路。

一、盡量不要鎖住方法----鎖方法-----方法的對象鎖

在普通成員函數上加鎖時，線程獲得的是該方法所在對象的對象鎖。此時整個對象都會被鎖住。這也意味著，如果這個對象提供的多個同步方法是針對不同業務的，那麼由於整個對象被鎖住，一個業務業務在處理時，其他不相關的業務線程也必須wait。下面的例子展示了這種情況：

LockMethod類包含兩個同步方法，分別在兩種業務處理中被調用：

 1 public class LockMethod   { 2     public synchronized void busiA() { 3         for (int i = 0; i < 10000; i++) { 4             System.out.println(Thread.currentThread().getName() + "deal with bussiness A:"+i); 5         } 6     } 7     public synchronized void busiB() { 8         for (int i = 0; i < 10000; i++) { 9             System.out.println(Thread.currentThread().getName() + "deal with bussiness B:"+i);10         }11     }12 }

 

BUSSA是線程類，用來處理A業務，調用的是LockMethod的busiA（）方法：

public class BUSSA extends Thread {    LockMethod lockMethod;    void deal(LockMethod lockMethod){        this.lockMethod = lockMethod;    }    @Override    public void run() {        super.run();        lockMethod.busiA();    }}

 

BUSSB是線程類，用來處理B業務，調用的是LockMethod的busiB（）方法：

 1 public class BUSSB extends Thread { 2     LockMethod lockMethod; 3     void deal(LockMethod lockMethod){ 4         this.lockMethod = lockMethod; 5     } 6   7     @Override 8     public void run() { 9         super.run();10         lockMethod.busiB();11     }12 }

 

TestLockMethod類，使用線程BUSSA與BUSSB進行業務處理：

 1 public class TestLockMethod extends Thread { 2   3     public static void main(String[] args) { 4         LockMethod lockMethod = new LockMethod(); 5         BUSSA bussa = new BUSSA(); 6         BUSSB bussb = new BUSSB(); 7         bussa.deal(lockMethod); 8         bussb.deal(lockMethod); 9         bussa.start();10         bussb.start();12     }13 }

 

運行程式，可以看到線上程bussa 執行的過程中，bussb是不能夠進入函數 busiB()的，因為此時lockMethod 的對象鎖被線程bussa擷取了。

二、縮小同步代碼塊，只鎖資料

有時候為了編程方便，有些人會synchnoized很大的一塊代碼，如果這個代碼塊中的某些操作與共用資源並不相關，那麼應當把它們放到同步塊外部，避免長時間的持有鎖，造成其他線程一直處於等待狀態。尤其是一些迴圈操作、同步I/O操作。不止是在代碼的行數範圍上縮小同步塊，在執行邏輯上，也應該縮小同步塊，例如多加一些條件判斷，合格再進行同步，而不是同步之後再進行條件判斷，盡量減少不必要的進入同步塊的邏輯。

三、鎖中盡量不要再包含鎖---易死結

這種情況經常發生，線程在得到了A鎖之後，在同步方法塊中調用了另外對象的同步方法，獲得了第二個鎖，這樣可能導致一個呼叫堆疊中有多把鎖的請求，多線程情況下可能會出現很複雜、難以分析的異常情況，導致死結的發生。下面的代碼顯示了這種情況：

synchronized (A){　　// 調用     synchronized (B){　　        }  } 

或是在同步塊中調用了同步方法：

1 synchronized(A){2     B  b = objArrayList.get(0);3     b.method(); //這是一個同步方法4 }

 

 

解決的辦法是跳出來加鎖，不要包含加鎖：

1 {2  B b = null;3  synchronized(A){4     b = objArrayList.get(0);5   }6   b.method();7 }

四、將鎖私人化，在內部管理鎖

把鎖作為一個私人的對象，外部不能拿到這個對象，更安全一些。對象可能被其他線程直接進行加鎖操作，此時線程便持有了該對象的對象鎖，例如下面這種情況：

 1 class A { 2     public void method1() { 3     } 4 } 5   6 class B { 7     public void method1() { 8         A a = new A(); 9         synchronized (a) { //直接進行加鎖10 　　　　　　a.method1();11         }12     }13 }

 

這種使用方式下，對象a的對象鎖被外部所持有，讓這把鎖在外部多個地方被使用是比較危險的，對代碼的邏輯流程閱讀也造成困擾。一種更好的方式是在類的內部自己管理鎖，外部需要同步方案時，也是通過介面方式來提供同步操作：

 1 class A { 2     private Object lock = new Object(); 3     public void method1() { 4         synchronized (lock){ 5               6         } 7     } 8 } 9  10 class B {11     public void method1() {12         A a = new A();13         a.method1();14     }15 }

五、進行適當的鎖分解

考慮下面這段程式：

 1 public class GameServer { 2   public Map<String, List<Player>> tables = new HashMap<String, List<Player>>(); 3   4   public void join(Player player, Table table) { 5     if (player.getAccountBalance() > table.getLimit()) { 6       synchronized (tables) { 7         List<Player> tablePlayers = tables.get(table.getId()); 8         if (tablePlayers.size() < 9) { 9           tablePlayers.add(player);10         }11       }12     }13   }14   public void leave(Player player, Table table) {/*省略*/} 15   public void createTable() {/*省略*/} 16   public void destroyTable(Table table) {/*省略*/}17 }

 

在這個例子中，join方法只使用一個同步鎖，來擷取tables中的List<Player>對象，然後判斷玩家數量是不是小於9，如果是，就調增加一個玩家。當有成千上萬個List<Player>存在tables中時，對tables鎖的競爭將非常激烈。在這裡，我們可以考慮進行鎖的分解：快速取出資料之後，對List<Player>對象進行加鎖，讓其他線程可快速競爭獲得tables對象鎖：

 

 1 public class GameServer { 2   public Map<String, List<Player>> tables = new HashMap<String, List<Player>>(); 3   4   public void join(Player player, Table table) { 5     if (player.getAccountBalance() > table.getLimit()) { 6       List<Player> tablePlayers = null; 7       synchronized (tables) { 8           tablePlayers = tables.get(table.getId()); 9       }10        11       synchronized (tablePlayers) {12         if (tablePlayers.size() < 9) {13           tablePlayers.add(player);14         }15       }16     }17   }18  19  public void leave(Player player, Table table) {/*省略*/} 20  public void createTable() {/*省略*/} 21  public void destroyTable(Table table) {/*省略*/}22 }

 

Java——多線程編程學習/01