编码素养问题收集1:基于名称映射的单例模式的并发控制
2013-12-05 16:51
507 查看
MemcachedClientFactory是一个容器,管理着从名称到MemcachedClient的映射关系,对外提供的服务是调用者给一个名字,就能返回这个名字对应的MemcachedClient,而且相同的名称,MemcachedClient是单例;不同的名称,是不同实例。
问题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的单例。
重构后的样例代码:
简单说明:
(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,太昂贵。另外实际运行环境下并发冲突点不大。如果非昂贵对象可类似这样:
//记录每个类产生的实例的个数
我们再展开一下,如果并发度很高,而且很多不同名称的name呢? 这样上述并发控制显然粒度太粗,把原本不同name不会产生竞争的都视为竞争处理。解决思路有两个,一个是找个替身,另一个是Future Patten。
方案1:替身锁,思路是虽然MemcachedClient是比较昂贵的,但是我们可以找个不昂贵的普通对象先把NAME->VAUE映射的“坑”占上,然后对替身加锁,这样就保证不同的NAME不竞争了,相同的NAME在替身上竞争。
方案2:Future Patten,思路是我们在map.put的时候,虽然必须使用的MemcachedClient对象,但是此时的用途仅仅是“占坑”,而并非真正需要开始做操作了,也就是说真正操作还在以后(return出去的时候),这个场景很容易让大家想到Future Pattern,期权模式说的是发期权时并不是就要钱,而是等未来有钱的时候,有个索要凭证,也是先“占坑”。这个机制跟Spring AOP借助Spring IoC对Bean做偷梁换柱的道理是一样的,实现Future Pattern就是用Proxy Pattern,坏处就是要基于接口(基于CGLib显然没有必要)。可是MemcachedClient不是接口,为了说明这个方案,我们假设返回的是IFuture。
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; } }
相关文章推荐
- 编码素养问题收集2:连接不归还池,不学TemplateCallback惹的祸
- 编码素养问题收集4:MySQL数据导入导出如何证明结果是正确的?
- 编码素养问题收集3:TeamLeader应该“有教无类”
- Unity3d基于订阅者模式实现事件机制_解决装箱拆箱问题和注册的监听事件单一问题
- 基于Windows下处理Java错误:编码GBK的不可映射字符的解决方案
- [置顶] CXF出现编码 GBK 的不可映射字符问题解决
- 在基于WCF开发的Web Service导出WSDL定义问题及自定义wsdl:port 名称
- java 导出为doc时 解决 编码 GBK 的不可映射字符 问题
- Android Studio中文注释提示编码问题,Gradle: 警告:编码 GBK 的不可映射字符的方法...
- 基于C#开发中的那些编码问题(详谈)
- 关于通过网站下载中文名称的文件的编码问题
- 【问题一】notepad++编辑器写Java代码,无法编译出现错误:编码GBK的不可映射字符
- Java问题解决:"错误:编码GBK 的不可映射字符"
- Java入门之编码GBK映射问题
- JavaWeb中使用Filter以及装饰者设计模式解决全局编码格式问题
- 关于java源码在编译时提示:编码GBK的不可映射字符 的问题
- UTF-8编码格式导致编码GBK的不可映射字符问题
- jsp编码UTF_8的不可映射问题
- 依赖库arr包,提交到Nexus搭建的Maven私服,编译过程中出现的问题:错误: 编码GBK的不可映射字符
- Maven(九)”编码 gbk 的不可映射字符“ 问题解决方案