同步方法与块的性能

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() ）同步是有意义的：

• 有不同的关键部分可能取决于不同的锁

• 临界区可能比方法短