同步方法與塊的性能

Question

我有一個類，所有方法都需要同步（沒有靜態方法）。 其中一種方法將每50 ms調用一次。

我想知道在哪里放置synchronized關鍵字有最短的執行時間？

即關於執行時間的2個選項之間是否有任何差異？

選項1（同步方法）

public class MyNativeObject{

     private boolean released = false;

     public synchronized String read(){
         if(released) return null;
         return Read(); 
     }

     public synchronized void release(){
         if(released) return;
         released = true;
         Release();
     }
     private native String Read();
     private native void Release();
}

選項2（同步塊）

public class MyNativeObject{

     private Boolean released = false;

     public String read(){
         synchronized(released){
             if(released) return null;
             return Read(); 
         }
     }

     public void release(){
         synchronized(released){
             if(released) return;
             released = true;
             Release();
         }
     }
     private native String Read();
     private native void Release();
}

Answer 1

選項＃1工作，並且幾乎是完美的，除了同步對象對外部可見，如果可能應該避免。

選項＃2是非常危險的，可能是錯誤的，因為您同步的對象發生了更改（當released從Boolean.TRUE更改為Boolean.FALSE它將在另一個對象上同步！

選項＃3將是這樣的：

public class MyNativeObject{

     private boolean released = false;
     private final Object monitor = new Object[0];

     public String read(){
         synchronized(monitor){
             if(released) return null;
             return Read(); 
         }
     }

     public void release(){
         synchronized(monitor){
             if(released) return;
             released = true;
             Release();
         }
     }
     private native String Read();
     private native void Release();
}

我們的想法是使用一個對象作為無法從代碼外部訪問的監視器（請參閱此頁面以了解我使用new Object[0]代替更常見的new Object() ）。 這樣，沒有其他同步會干擾您的同步。

Answer 2

你不能有一個同步的類。

正如約阿希姆指出的那樣，選項2是錯誤的，因為你鎖定a）一個改變的領域和b）一個全局對象。

同步方法不僅是唯一有效的方法，而且是最簡單的方法，我將使用它。

典型的鎖定需要大約50納秒，所以如果你每50,000,000納秒調用這些方法，它就不太可能產生任何差別。

public class MyNativeObject{

     private boolean released = false;

     public synchronized String read(){
         return released ? null : Read(); 
     }

     public synchronized void release(){
         if(released) return;
         released = true;
         Release();
     }

     // make the native methods static if you can.
     private static native String Read();
     private static native void Release();
}

Answer 3

同步方法只是語法糖！

這兩個是等價的：

 public synchronized String read(){
      return released ? null : Read(); 
 }

 public String read(){
      synchronized(this) {
           return released ? null : Read(); 
      }
 }

因此，沒有性能改進。

如果其中任何一個為真，“手動”（ synchronized() ）同步是有意義的：

• 有不同的關鍵部分可能取決於不同的鎖

• 臨界區可能比方法短