使用原子和无限循环在JAVA中执行同步(Using Atomic and infinite loop to do synchronisation in JAVA)

 考虑下面的代码 
 
static AtomicBoolean initialized = new AtomicBoolean(false);
static AtomicBoolean initStarted= new AtomicBoolean(false);

public static void init() {
    if (!initialized.get() && !initStarted.getAndSet(true)) {
        doInitialization();
        initialized.set(true);
    }
    // start waiting
    while (!initialized.get());
    // finished waiting
    doMoreStuff();
}
 
 它实现了我想要确保在doInitialization()完成之前不会调用doInitialization() ，只有第一个线程应该调用doInitialization() 。 
 
 我的问题是，这与使用synchronized块到整个init()方法相比如何？ 
 
 正如我所看到的，AtomicReference也使用无限循环（又称繁忙等待）来浪费CPU周期来进行更新（参见AtomicReference#getAndUpdate() ），所以在这里做同样的方法可能不是那么糟糕吗？ 
 
 如果无限循环如此糟糕（例如，浪费CPU周期），那么为什么AtomicReference使用synchronized来停止或唤醒线程呢？ 

Consider the following code
 
static AtomicBoolean initialized = new AtomicBoolean(false);
static AtomicBoolean initStarted= new AtomicBoolean(false);

public static void init() {
    if (!initialized.get() && !initStarted.getAndSet(true)) {
        doInitialization();
        initialized.set(true);
    }
    // start waiting
    while (!initialized.get());
    // finished waiting
    doMoreStuff();
}
 
It achieves what I want to make sure doMoreStuff() is not called until doInitialization() has completed and only the very first thread should call doInitialization().
 
My question is, how does this compare to using synchronized block to the whole init() method?
 
As I see AtomicReference also use infinite loop (a.k.a busy waiting) to waste CPU cycle to do update (see AtomicReference#getAndUpdate()), so may be it is not so bad to do the same here as a synchronisation method?
 
If infinite loop is so bad (e.g. wasting CPU cycle) then why don't AtomicReference use synchronized to stop or wake up threads?

原文：https://stackoverflow.com/questions/41051738