题目是并发环境 运行时初始化，有点晕菜，仔细想了下实现

为了保持可见性使用volatile，最开始调用getInstance可能导致写锁竞争，写锁内部还要加个判空


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class SyncSingleton {
    private static volatile SyncSingleton single=null;
    private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static final Lock r=lock.readLock();
    private static final Lock w=lock.writeLock();
                  
    private SyncSingleton(){
    }
                  
    public static SyncSingleton getInstance(){
        if (single == null) { //运行时判断，为空初始化
            w.lock();//上写锁
            try {
                if (single==null) {//写锁可能有多个线程等待，这里需要再判断一下
                    single=new SyncSingleton();
                }
            } finally {
                w.unlock();
            }
                          
        }
        return single;
    }
                  
    public String readMethod(){
        r.lock();
        try {
            //....
        } finally {
            r.unlock();
        }
        return null;
    }
                  
    public void modifySingleton(){
        w.lock();
        try {
            //....
        } finally {
            w.unlock();
        }
    }
}