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

原创 2013年12月05日 16:51:33

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;
        }
    }












程序员日常编码的基本素养

本文是在阅读完《代码整洁之道》第四章之后的一些总结,其中也引用了部分原文。我是一名大三学生,读完该书的这一章后感觉即对书中描述的部分情形深有体会,又对自己将来的职业发展很有帮助。 自己的职业道路...
  • aerf5sd
  • aerf5sd
  • 2017年03月27日 17:38
  • 568

数据库并发控制的三个问题

现在主流的数据库管理系统中,都支持多个事务同时执行,这样提高了数据库管理系统的运行效率。试想如果只允许一个事务运行,而这个事务又需要很长的时间,那么其他的用户必须一直等待该事务结束,效率何其低下。执行...
  • ocean1010
  • ocean1010
  • 2010年10月07日 00:02
  • 2141

fjnu 1362 收集样本问题

Description问题描述: 机器人Rob在一个有n*n 个方格的方形区域F 中收集样本。(i,j)方格中样本的价值为v(i,j),如下图所示。 Rob 从方形区域F 的左上角A点出发,向下或向...
  • killua_hzl
  • killua_hzl
  • 2008年04月11日 23:32
  • 1286

eclipse中maven install提示编码GBK的不可映射字符

今天在eclipse中使用Maven编译项目源代码时,结果如下了如下的错误 在Java源码中没有提示任何报错,即便是改掉项目编码也是不行,如下图所示: 第一次遇到这个问题,...
  • AlbertFly
  • AlbertFly
  • 2017年08月04日 21:40
  • 298

mvn 编码GBK的不可映射字符

mvn 编码GBK的不可映射字符 UTF-8
  • hzdxw
  • hzdxw
  • 2016年09月09日 12:32
  • 1040

eclipse中javadoc文档的生成及解决“编码 EUC_CN 的不可映射字符”问题

中文:Eclipse菜单栏-工程-> 生成javadoc 英文:Eclipse菜单栏-Project-> Generate Javadoc...
  • xue_wei_love
  • xue_wei_love
  • 2012年03月16日 15:44
  • 2977

Android Studio: 编码UTF-8的不可映射字符

1. 在代码的下角 将UTF-8 改为 GB2312   (图1) 2. 在弹出的窗口中选择 Reload (图2) 图1  图2  ...
  • bobo553443
  • bobo553443
  • 2017年09月04日 12:05
  • 759

单例模式的七种写法, 面试题:线程安全的单例模式

http://cantellow.iteye.com/blog/838473 http://meizhi.iteye.com/blog/537563 转载请注明出处:h...
  • liangxw1
  • liangxw1
  • 2016年05月09日 15:53
  • 9394

分布式系统阅读笔记(十六)-----事务和并发控制

介绍 在分布式系统中,事务的运用和共享资源的并发控制是非常常见的。简单的说,事务就是一些原子的操作的集合。原子操作的意思就是要么操作成功要么操作失败,没有其他的选择。并发控制是出现在高并发场景的时候...
  • Androidlushangderen
  • Androidlushangderen
  • 2015年01月16日 15:09
  • 2744

Hibernate基于主键一对一映射操作实例

背景: 公民和公民的身份证,是一个一对一的例子,一个公民只有一个身份证。 这个是基于主键的,基于外键的映射在:http://blog.csdn.net/nthack5730/article/...
  • nthack5730
  • nthack5730
  • 2015年04月29日 14:46
  • 11420
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:编码素养问题收集1:基于名称映射的单例模式的并发控制
举报原因:
原因补充:

(最多只允许输入30个字)