Ленивая инициализация/запоминание без volatile

Ваш код не является потокобезопасным, что можно легко показать, удалив все ненужные части:

public class Memoized<T> {
    private T value;
    // irrelevant parts omitted

    public T get() {
        T tempValue = value;

        if (tempValue == null) {
            // irrelevant parts omitted
        }

        return tempValue;
    }
}

Таким образом, value не имеет модификатора volatile, и вы читаете его в методе get() без синхронизации, а если не null, продолжаете использовать его без синхронизации.

Один только этот путь кода уже делает код неработающим, независимо от того, что вы делаете при назначении value, поскольку все потокобезопасные конструкции требуют, чтобы обе стороны, читающая и записывающая стороны, использовали совместимый механизм синхронизации.

Тот факт, что вы используете эзотерические конструкции, такие как if (_volatile);, становится неактуальным, поскольку код уже взломан.

Причина, по которой пример из Википедии использует оболочку с полем final, заключается в том, что неизменяемые объекты, использующие только поля final, невосприимчивы к гонкам данных и, следовательно, являются единственной конструкцией, которая безопасна при чтении ссылки без действия синхронизации.

Обратите внимание, что, поскольку лямбда-выражения попадают в ту же категорию, вы можете использовать их, чтобы упростить пример для вашего варианта использования:

public class Memoized<T> {
    private boolean initialized;
    private Supplier<T> supplier;

    public Memoized(Supplier<T> supplier) {
        this.supplier = () -> {
            synchronized(this) {
                if(!initialized) {
                    T value = supplier.get();
                    this.supplier = () -> value;
                    initialized = true;
                }
            }
            return this.supplier.get();
        };
    }

    public T get() {
        return supplier.get();
    }
}

Здесь supplier.get() внутри Memoized.get() может считать обновленное значение supplier без действия синхронизации, и в этом случае будет считано правильное value, поскольку оно неявно равно final. Если метод считывает устаревшее значение для ссылки supplier, он окажется в блоке synchronized(this), который использует флаг initialized для определения необходимости оценки исходного поставщика.

Поскольку доступ к полю initialized будет осуществляться только внутри блока synchronized(this), оно всегда будет оцениваться как правильное значение. Этот блок будет выполняться не более одного раза для каждого потока, тогда как только первый из них будет оценивать get() для исходного поставщика. После этого каждый поток будет использовать поставщика () -> value, возвращая значение без каких-либо действий по синхронизации.

Вы можете сократить использование volatile, если у вас всего несколько синглетонов. Примечание: вы должны повторить этот код для каждого синглтона.

enum LazyX {
   ;
   static volatile Supplier<X> xSupplier; // set somewhere before use

   static class Holder {
       static final X x = xSupplier.get();
   }

   public static X get() {
       return Holder.x;
   }
}

Если вы знаете Поставщика, это становится проще

enum LazyXpensive {
   ;

   // called only once in a thread safe manner
   static final Xpensive x = new Xpensive();

   // after class initialisation, this is a non volatile read
   public static Xpensive get() {
       return x;
   }
}

Вы можете избежать изменения поля, используя Unsafe

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.function.Supplier;

public class LazyHolder<T> {
    static final Unsafe unsafe = getUnsafe();
    static final long valueOffset = getValueOffset();

    Supplier<T> supplier;
    T value;

    public T get() {
        T value = this.value;
        if (value != null) return value;

        return getOrCreate();
    }

    private T getOrCreate() {
        T value;
        value = (T) unsafe.getObjectVolatile(this, valueOffset);
        if (value != null) return value;

        synchronized (this) {
            value = this.value;
            if (value != null) return value;
            this.value = supplier.get();
            supplier = null;
            return this.value;
        }
    }


    public static Unsafe getUnsafe() {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            return (Unsafe) theUnsafe.get(null);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new AssertionError(e);
        }
    }

    private static long getValueOffset() {
        try {
            return unsafe.objectFieldOffset(LazyHolder.class.getDeclaredField("value"));
        } catch (NoSuchFieldException e) {
            throw new AssertionError(e);
        }
    }
}

Однако дополнительный поиск — это микрооптимизация. Если вы хотите получить синхронизацию один раз для каждого потока, вы можете вообще не использовать volatile.