Has Java checked the lock twice, forcing synchronization of synchronization is working?

Question

I read all about how double locking checks never work, and I don't like lazy initialization, but it would be nice to fix outdated code, and such a problem is too tempting to not try to solve the problem.

Here is my example: private int timesSafelyGotten = 0; private Helper helper = null;

public getHelper()
{
    if (timesSafelyGotten < 1) {
        synchronized (this) {
            if (helper == null) {
                helper = new Helper();
            } else {
                timesSafelyGotten++;
            }
        }
    }
    return helper;
}

Thus, the synchronized code must be run once to create a helper and once when it is received for the first time, so theoretically timesSafelyGotten cannot be increased until the synchronized code that created the helper releases the lock, and the helper should be initialization completed.

, , , , ?

Answer 1

(synchronized, volatile java.util.concurrent) , , .

timesSafelyGotten , , timesSafelyGotten , helper. null .

. .

, . , , .

Answer 2

JDK5 +, java.util.concurrent, , , AtomicInteger.

, , , .

Answer 3

. timeSafelyGotten > 1. :

• Thread1 ,
• Thread2 , .
• Thread3 , .
• Thread1 , .
• Thread2 , increment timeSafelyGotten .
• Thread3 , increment timeSafelyGotten .

, timeSafelyGotten = 2.

:

if (helper == null) {
    helper = new Helper();
} else if (timesSafelyGotten < 1) {
    timesSafelyGotten++;
}

:

synchronized(this) {
   if (timeSafelyGotten < 1) {
       ...
   }
}

, .

: synchronize (this), - . :

classs MyClass {
    private Object syncRoot = new Object();

    ...
    synchronized(syncRoot) {
        ....
    }
}