double locking on atomic reference(is it correct?)

double_locking_ar

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;


public class Test {
    private AtomicReference<Config> configHolder = new AtomicReference<Config>();
    private static final class Config {
        private final Map<String, Double> factorsMap;
        Config(Map<String, Double> factorsMap) {
            this.factorsMap = factorsMap;            
        }
    }
    private Config get() {
        if (configHolder.get() == null) {
            synchronized (configHolder) {
                if (configHolder.get() == null) {
                    //suppose long initialization here for factorsMap
                    Map<String, Double> factorsMap = new HashMap<String, Double>();
                    Config config = new Config(factorsMap);
                    configHolder.set(config);
                }
            }
        }
        return configHolder.get();
    }
    public Double getFactor(String key) {
        return get().factorsMap.get(key);
    }
}

enough to use volatile(didn't remember if volatile supports references) instead of AtomicReference. The last has meaning of continuous read-write. Here we have 1 time initialization