Java多線程編程—鎖優化

併發環境下進行編程時，須要使用鎖機制來同步多線程間的操做，保證共享資源的互斥訪問。加鎖會帶來性能上的損壞，彷佛是衆所周知的事情。然而，加鎖自己不會帶來多少的性能消耗，性能主要是在線程的獲取鎖的過程。若是隻有一個線程競爭鎖，此時並不存在多線程競爭的狀況，那麼JVM會進行優化，那麼這時加鎖帶來的性能消耗基本能夠忽略。所以，規範加鎖的操做，優化鎖的使用方法，避免沒必要要的線程競爭，不只能夠提升程序性能，也能避免不規範加鎖可能形成線程死鎖問題，提升程序健壯性。下面闡述幾種鎖優化的思路。

1、儘可能不要鎖住方法

在普通成員函數上加鎖時，線程得到的是該方法所在對象的對象鎖。此時整個對象都會被鎖住。這也意味着，若是這個對象提供的多個同步方法是針對不一樣業務的，那麼因爲整個對象被鎖住，一個業務業務在處理時，其餘不相關的業務線程也必須wait。下面的例子展現了這種狀況：

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

public class LockMethod   {
    public synchronized void busiA() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "deal with bussiness A:"+i);
        }
    }
    public synchronized void busiB() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "deal with bussiness B:"+i);
        }
    }
}

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（）方法：

public class BUSSB extends Thread {
    LockMethod lockMethod;
    void deal(LockMethod lockMethod){
        this.lockMethod = lockMethod;
    }

    @Override
    public void run() {
        super.run();
        lockMethod.busiB();
    }
}

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

public class TestLockMethod extends Thread {

    public static void main(String[] args) {
        LockMethod lockMethod = new LockMethod();
        BUSSA bussa = new BUSSA();
        BUSSB bussb = new BUSSB();
        bussa.deal(lockMethod);
        bussb.deal(lockMethod);
        bussa.start();
        bussb.start();

    }
}

運行程序，能夠看到在線程bussa 執行的過程當中，bussb是不可以進入函數 busiB()的，由於此時lockMethod 的對象鎖被線程bussa獲取了。

2、縮小同步代碼塊，只鎖數據

有時候爲了編程方便，有些人會synchnoized很大的一塊代碼，若是這個代碼塊中的某些操做與共享資源並不相關，那麼應當把它們放到同步塊外部，避免長時間的持有鎖，形成其餘線程一直處於等待狀態。尤爲是一些循環操做、同步I/O操做。不止是在代碼的行數範圍上縮小同步塊，在執行邏輯上，也應該縮小同步塊，例如多加一些條件判斷，符合條件的再進行同步，而不是同步以後再進行條件判斷，儘可能減小沒必要要的進入同步塊的邏輯。

3、鎖中儘可能不要再包含鎖

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

synchronized(A){

   synchronized(B){
  
      }  
}

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

synchronized(A){

    B  b = objArrayList.get(0);
    b.method(); //這是一個同步方法
}

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

{
     B b = null;
   
 synchronized(A){
    b = objArrayList.get(0);
  }
  b.method();
}

 

4、將鎖私有化，在內部管理鎖

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

class A {
    public void method1() {
    }
}

class B {
    public void method1() {
        A a = new A();
        synchronized (a) { //直接進行加鎖
　　　　　　a.method1();

        }
    }
}

這種使用方式下，對象a的對象鎖被外部所持有，讓這把鎖在外部多個地方被使用是比較危險的，對代碼的邏輯流程閱讀也形成困擾。一種更好的方式是在類的內部本身管理鎖，外部須要同步方案時，也是經過接口方式來提供同步操做：

class A {
    private Object lock = new Object();
    public void method1() {
        synchronized (lock){
            
        }
    }
}

class B {
    public void method1() {
        A a = new A();
        a.method1();
    }
}

 

5、進行適當的鎖分解

 考慮下面這段程序：

public class GameServer {
  public Map<String, List<Player>> tables = new HashMap<String, List<Player>>();

  public void join(Player player, Table table) {
    if (player.getAccountBalance() > table.getLimit()) {
      synchronized (tables) {
        List<Player> tablePlayers = tables.get(table.getId());
        if (tablePlayers.size() < 9) {
          tablePlayers.add(player);
        }
      }
    }
  }
  public void leave(Player player, Table table) {/*省略*/} 
  public void createTable() {/*省略*/} 
  public void destroyTable(Table table) {/*省略*/}
}

在這個例子中，join方法只使用一個同步鎖，來獲取tables中的List<Player>對象，而後判斷玩家數量是否是小於9，若是是，就調增長一個玩家。當有成千上萬個List<Player>存在tables中時，對tables鎖的競爭將很是激烈。在這裏，咱們能夠考慮進行鎖的分解：快速取出數據以後，對List<Player>對象進行加鎖，讓其餘線程可快速競爭得到tables對象鎖：

public class GameServer {
  public Map<String, List<Player>> tables = new HashMap<String, List<Player>>();

  public void join(Player player, Table table) {
    if (player.getAccountBalance() > table.getLimit()) {
      List<Player> tablePlayers = null;
      synchronized (tables) {
          tablePlayers = tables.get(table.getId());
      }
      
      synchronized (tablePlayers) {
        if (tablePlayers.size() < 9) {
          tablePlayers.add(player);
        }
      }
    }
  }

 public void leave(Player player, Table table) {/*省略*/} 
 public void createTable() {/*省略*/} 
 public void destroyTable(Table table) {/*省略*/}
}

 

（完）

 

個人博客即將搬運同步至騰訊雲+社區，邀請你們一同入駐：https://cloud.tencent.com/developer/support-plan?invite_code=2da2gtpfllwkk