はJAVA

Question

内のロックに同期使用することから、ロックダブルチェックを変換するJAVA 8に​​キーワードを使用してロックする次のコード実行のダブルチェックを考えてみましょう：

private static void redoHeavyInitialisation() { 
    if (needToReinitialise()) { 
     synchronized (MyClass.class) { 
      if (needToReinitialise()) { 
       doHeavyInitialisation(); 
      } 
     } 
    } 
} 

初期化が重いので、ダブルチェックロックが使用されている理由は、 （したがって、怠け者）、それは複数回起こることがあります（したがって、シングルトンパターンは使用できません。私が間違っていれば修正してください）。

まず、synchronizedキーワードを使用する代わりに、上記のコードをLockを使用してJAVAの同時パッケージからどのように変換しますか？

その後、オプションで、Lockまたはsynchronizedキーワードを使用してコメントすることもできます。

この質問はロックと同期の比較に関するものではありません。コード変換部分に応答しない回答の試みは、受け入れられた回答として選択されません。

Answer 1

ReentrantLockを使用して同期ブロックを等価ブロックに変換するのはかなり簡単です。

まず、ロックしていたオブジェクトと同じスコープと有効期間でロックを作成します。ここではMyClass.classをロックしているので、静的ロックとなるので、これをMyClass.initLockのようなMyClassの静的ロックにマップすることができます。

それからちょうどそれぞれを置き換える：

synchronized (object) { 

すべて一緒にそれを置く

lock.lock(); 
try { 

と

} finally { 
    lock.unlock(); 
} 

とそれぞれ関連する閉じ括弧とあなたが持っている：

private final static ReentrantLock initLock = new ReentrantLock(); 

private static void redoHeavyInitialisation() { 
    if (needToReinitialise()) { 
     MyClass.initLock.lock(); 
     try { 
      if (needToReinitialise()) { 
       doHeavyInitialisation(); 
      } 
     } finally { 
      MyClass.initLock.unlock(); 
     } 
    } 
} 

パフォーマンス面では、アプローチの間に少し日光があります。基本的に同じセマンティクスを持ち、通常は同様の根底にあるメカニズムを使用します。過去にはパフォーマンスの違いがありました.1つまたは2つのJVMに違いがあるような最適化が行われている場合がありますが、ダブルチェックロックの場合は、だから、最も簡単なことをしてください。 needToReinitialise()メソッドが実行されている間は、非常に短い一時的期間だけロックを取得するので、ロッキング・コストには影響はありません。

Answer 2

次のコードを考えてみましょう：Oracle's docから

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 

public class HeavyInitializer { 
static final Logger logger = LoggerFactory.getLogger(HeavyInitializer.class); 
static HeavyInitializer singleton; 
public static synchronized HeavyInitializer getInstance() { 
    if (singleton==null) { 
     singleton = new HeavyInitializer(); 
    } 
    return singleton; 
} 
boolean initialized; 
private HeavyInitializer() { 
    initialized = false; 
} 

public synchronized void initialize() { 
    if (!initialized) { 
     heavyStuffDoneHere(); 
    } 
} 
public synchronized void reInitilize() { 
    if (needToReinitialise()) { 
     heavyStuffDoneHere(); 
    } 
} 

private void heavyStuffDoneHere() { 
    initialized = true; 
} 

private boolean needToReinitialise() { 
    if (!initialized) 
     return false; 
    boolean ret = false; 
    //Do your check here... and set ret  
    return ret; 
} 

} 

を：

...その後、これらのメソッドが同期することは2つの効果があります。

• まず、それは2のために可能ではありません同じオブジェクト上に同期メソッドを呼び出してインターリーブします。あるスレッドがオブジェクトの同期メソッドを実行しているとき、そのオブジェクトで最初のスレッドが完了するまで、同じオブジェクトブロックの同期メソッドを呼び出す他のすべてのスレッド（実行を中断）。

• 第2に、同期化されたメソッドが終了すると、自動的に同じオブジェクトの同期化されたメソッドを呼び出すときに、先行する関係を確立します。これにより、オブジェクトの状態の変更がすべてのスレッドで認識できることが保証されます。

ロックを使用しようとすると、同期ブロックを再実装しようとしています。必要はありません。

Answer 3

シングルトンロックをダブルチェックし、シングルトンオブジェクトがシリアライズを使用して中断するのを防ぎます。

package pattern.core.java; import java.io.Serializable;

パブリッククラスシングルトンオブジェクトがシリアライズ{

private static final long serialVersionUID = 1L; 
private static Singleton sg; 

private Singleton() { 
} 

public static Singleton getSingletonObj() { 
    if (sg == null) { 
     synchronized (sg) { 
      if (sg == null) { 
       sg = new Singleton(); 
      } 
     } 
    } 
    return sg; 
} 


/* 
* this method ensures that new object will not be created for singleton 
* class using serialization and deserialization 
*/ 
protected Object readResolve() { 
    return sg; 
} 

/* 
* @Override protected Object clone() throws CloneNotSupportedException { 
* throw new CloneNotSupportedException(); } 
*/ 

@Override 
protected Object clone() throws CloneNotSupportedException { 
    return sg; 
} 

} [ロックVS同期]の