编码素养问题收集1：基于名称映射的单例模式的并发控制

MemcachedClientFactory是一个容器，管理着从名称到MemcachedClient的映射关系，对外提供的服务是调用者给一个名字，就能返回这个名字对应的MemcachedClient，而且相同的名称，MemcachedClient是单例；不同的名称，是不同实例。

public class MemcachedClientFactory {
    private static final Logger LOG = LoggerFactory.getLogger(MemcachedClientFactory.class);

    private static Map<String, MemcachedClient> caches = new HashMap<String, MemcachedClient>();
    private static String configFile = "/memcached.properties";

    private MemcachedClientFactory() {
    }

    private static synchronized MemcachedClient createClient(final String name) throws Exception {
        final Properties prop = new Properties();
        prop.load(MemcachedClientFactory.class.getResourceAsStream(configFile));
        IMemcachedConfiguration config = new IMemcachedConfiguration() {
            @Override
            public String getName() {
                return name;
            }

            @Override
            public String getServers() {
                return prop.getProperty(name + ".servers");
            }

            @Override
            public int getConnectionPoolSize() {
                return Integer.parseInt(prop.getProperty(name + ".connectionpoolsize"));
            }
        };
        return createClient(config);
    }

    private static synchronized MemcachedClient createClient(IMemcachedConfiguration config) throws Exception {
        final String name = config.getName();
        final String servers = config.getServers();
        final int connectionPoolSize = config.getConnectionPoolSize();
        assert name != null;
        assert servers != null;
        assert connectionPoolSize <= 0 : 1;

        MemcachedClient client = caches.get(name);
        if (client == null) {
            MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(servers));
            builder.setConnectionPoolSize(connectionPoolSize);
            client = builder.build();
            caches.put(name, client);
            // LOG.info("create client name:{}, servers:{}, connectionpoolsize:{}",
            // new Object[]{name, servers, connectionPoolSize});
        }
        // LOG.info("return client name:{}", name);
        return client;
    }

    public static MemcachedClient getClient(String name) throws Exception {
        MemcachedClient client = caches.get(name);
        if (client == null || client.isShutdown()) {
            System.out.println("reconnect memcached");
            caches.remove(name);
            client = createClient(name);
        }
        return client;
    }
}

问题1：createClient() 不应该暴露出去，因为你没法保证每个使用者都不犯错误。
问题2：getClient() 不是线程安全的，不管程序设计者运行在什么环境，但作为一个服务器端程序开发人员应该预计用在并发环境是很正常的。
问题3：Factory的构造方法私有化其实没有必要。private MemcachedClientFactory() {   }  设计者之所以这么写，是因为混淆了一个概念，这段代码想要保证的是Name->MemcacheClient 的单例，如果把Factory弄成private就变成了想把Factory弄成单例或不可见，而实际上设计者期望对Factory的使用就是静态提取（因为Factory上并没有实例成员方法），并不需要构造实例的。
问题4：在createClient()方法中坐caches.put(name,client)违背了单一职责原则。实际上createClient()和getClient()是要明确分工的，createClient()就是负责创建连接，而getClient()就负责基于name的单例。
重构后的样例代码：

public class MemcachedClientFactory {
    private static final Logger LOG = LoggerFactory.getLogger(MemcachedClientFactory.class);

//    private static Map<String, MemcachedClient> caches = new ConcurrentHashMap<String, MemcachedClient>();
    private static ConcurrentHashMap<String, MemcachedClient> caches = new ConcurrentHashMap<String, MemcachedClient>();
    private static String configFile = "/memcached.properties";
    private static AtomicInteger counter = new AtomicInteger();

//    private MemcachedClientFactory() {
//    }


    private static volatile Properties singletonProp = null;
    private static Object lockProp = new Object();
    private static Properties getProperties() throws Exception {
        if (singletonProp==null) {
            synchronized (lockProp) {
                if (singletonProp==null) {
                    Properties prop = new Properties();
                    prop.load(MemcachedClientFactory.class.getResourceAsStream(configFile));
                    singletonProp = prop;
                }
            }
        }
        return singletonProp;
    }

    private static MemcachedClient createClient(final String name) throws Exception {
        int num = counter.incrementAndGet();
        LOG.info("MemcachedClient initialize: {}#{}" ,name, num);

//        final Properties prop = new Properties();
//        prop.load(MemcachedClientFactory.class.getResourceAsStream(configFile));
        final Properties prop = getProperties();
        IMemcachedConfiguration config = new IMemcachedConfiguration() {
            @Override
            public String getName() {
                return name;
            }

            @Override
            public String getServers() {
                return prop.getProperty(name + ".servers");
            }

            @Override
            public int getConnectionPoolSize() {
                return Integer.parseInt(prop.getProperty(name + ".connectionpoolsize"));
            }
        };
        return createClient(config);
    }



    private static MemcachedClient createClient(IMemcachedConfiguration config) throws Exception {
        final String name = config.getName();
        final String servers = config.getServers();
        final int connectionPoolSize = config.getConnectionPoolSize();
        assert name != null;
        assert servers != null;
        assert connectionPoolSize <= 0 : 1;
        MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(servers));
        builder.setConnectionPoolSize(connectionPoolSize);
        MemcachedClient client = builder.build();
//        caches.put(name, client);//职责不单一
        return client;
    }

    public static MemcachedClient getClient(String name) throws Exception {
        MemcachedClient client = caches.get(name);
        if (client == null || client.isShutdown()) {
            LOG.info("reconnect memcached");
            synchronized(MemcachedClient.class) {
                client = caches.get(name);//ConcurrentHashMap.putIfAbsent 需要额外增加一个MemcachedClient，太昂贵
                if (client == null || client.isShutdown()) {
                    client = createClient(name);
                    if (client != null) {
                        caches.put(name, client);
                    }
                }
            }
        }
        return client;
    }
}

简单说明：
（1）private static AtomicInteger counter = new AtomicInteger(); 是为了简单证明在服务器多线程环境下只产生一个实例，可忽略。
（2）ConcurrentHashMap似乎没什么用。但笔者基于普通单例模式double-check时，static _instacne 常常用volatile来做可见性保证。因此Map.put(KEY,VALUE)时，为了保证put后的KEY赋值的可见性。
（3）getClient方法中没有利用ConcurrentHashMap.putIfAbsent是因为需要额外增加一个MemcachedClient，太昂贵。另外实际运行环境下并发冲突点不大。如果非昂贵对象可类似这样：
//记录每个类产生的实例的个数

@SuppressWarnings("rawtypes")
    private final ConcurrentHashMap<Class, AtomicInteger> classInstanceCounter = new ConcurrentHashMap<Class, AtomicInteger>();
    @SuppressWarnings("rawtypes")
    private int incrAndGet(Class Key) {
        return incrAndGet(Key, 1);
    }
    @SuppressWarnings("rawtypes")
    private int incrAndGet(Class key, final int incrValue) {
        AtomicInteger bookIdCount = classInstanceCounter.get(key);
        if (bookIdCount == null) {
            AtomicInteger bookIdPrev = classInstanceCounter.putIfAbsent(key, new AtomicInteger(incrValue));
            if (bookIdPrev != null) {
                return bookIdPrev.addAndGet(incrValue);
            } else {
                return incrValue;
            }
        } else {
            return bookIdCount.addAndGet(incrValue);
        }
    }

我们再展开一下，如果并发度很高，而且很多不同名称的name呢？ 这样上述并发控制显然粒度太粗，把原本不同name不会产生竞争的都视为竞争处理。解决思路有两个，一个是找个替身，另一个是Future Patten。
方案1：替身锁，思路是虽然MemcachedClient是比较昂贵的，但是我们可以找个不昂贵的普通对象先把NAME->VAUE映射的“坑”占上，然后对替身加锁，这样就保证不同的NAME不竞争了，相同的NAME在替身上竞争。

public static MemcachedClient getClient(String name) throws Exception {
        MemcachedClient client = caches.get(name);
        if (client == null || client.isShutdown()) {
            LOG.info("reconnect memcached");
            ReentrantLock stuntman = getStuntmanInstanceByName(name);
            try {
                stuntman.lock();
                client = caches.get(name);
                if (client == null || client.isShutdown()) {
                    client = createClient(name);
                    if (client != null) {
                        caches.put(name, client);
                    }
                }

            } finally {
                stuntman.unlock();
            }

        }
        return client;
    }

    /* 替身解决MemcachedClient在ConcurrentHashMap.putIfAbsent时比较昂贵的问题 */
    private static final ConcurrentHashMap<String, ReentrantLock> stuntmanContainer = new ConcurrentHashMap<String,ReentrantLock>();
    private static ReentrantLock getStuntmanInstanceByName(String name) {
        ReentrantLock stuntman = stuntmanContainer.get(name);
        if (stuntman == null) {
            ReentrantLock newStuntman = new ReentrantLock();
            ReentrantLock preStuntman = stuntmanContainer.putIfAbsent(name, newStuntman);
            stuntman = (preStuntman!=null ? preStuntman : newStuntman);
        }
        return stuntman;
    }

方案2：Future Patten，思路是我们在map.put的时候，虽然必须使用的MemcachedClient对象，但是此时的用途仅仅是“占坑”，而并非真正需要开始做操作了，也就是说真正操作还在以后（return出去的时候），这个场景很容易让大家想到Future Pattern，期权模式说的是发期权时并不是就要钱，而是等未来有钱的时候，有个索要凭证，也是先“占坑”。这个机制跟Spring AOP借助Spring IoC对Bean做偷梁换柱的道理是一样的，实现Future Pattern就是用Proxy Pattern，坏处就是要基于接口（基于CGLib显然没有必要）。可是MemcachedClient不是接口，为了说明这个方案，我们假设返回的是IFuture。

private static final ConcurrentHashMap<String, IFuture> futureContainer = new ConcurrentHashMap<String, IFuture>();

    private static IFuture getRealmanFutureByName(String name) {
        IFuture stuntman = futureContainer.get(name);
        if (stuntman == null) {
            IFuture newStuntman = new RealmanFuture();
            IFuture preStuntman = futureContainer.putIfAbsent(name, newStuntman);
            stuntman = (preStuntman != null ? preStuntman : newStuntman);
        }
        return stuntman;
    }

    public static interface IFuture {
        public Object doSomething(Object arg);
    }

    public static class Realman implements IFuture {
        @Override
        public Object doSomething(Object arg) {
            // do something
            return null;
        }
    }

    public static class RealmanFuture implements IFuture {
        @Override
        public Object doSomething(Object arg) {
            Realman delegate = getRealmanInstance();//把Realman的实例化推迟到使用的时候，而不是占坑的时候
            return delegate.doSomething(arg);
        }

        private volatile Realman realman = null;
        private final ReentrantLock lock = new ReentrantLock();
        private Realman getRealmanInstance() {
            if (realman == null) {
                try {
                    lock.lock();
                    if (realman == null) {
                        realman = new Realman();
                    }
                }finally {
                    lock.unlock();
                }
            }//end if
            return realman;
        }
    }