2

我有一个类，所有方法都需要同步（没有静态方法）。其中一种方法将每 50 毫秒调用一次。

我想知道将同步关键字放在哪里具有最短的执行时间？

即下面详述的关于执行时间的两个选项之间有什么区别吗？

选项 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();
}
4

3 回答 3

6

选项 #1 有效，并且几乎是完美的，除了同步的对象对外部可见，如果可能的话应该避免。

选项 #2 非常危险并且可能是错误的，因为您在更改时同步的对象（当对它的released更改将在另一个对象上同步时！Boolean.TRUEBoolean.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();
}

这个想法是使用一个对象作为无法从您的代码外部访问的监视器（请参阅此页面以了解我使用 anew Object[0]代替更常见的new Object()）。这样，其他同步不会干扰您的同步。

于 2013-05-06T13:30:12.740 回答
6

你不能有一个同步的类。

正如 Joachim 指出的那样，选项 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();
}
于 2013-05-06T13:30:15.600 回答
3

同步方法只是语法糖！

这两个是等价的：

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

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

因此不会有性能提升。

如果任一为真， “手动”( synchronized()) 同步就有意义：

  • 有不同的临界区可能取决于不同的锁

  • 临界区可能比方法短

于 2013-05-06T13:38:00.003 回答