bighector / memcache-client-forjava Goto Github PK

 client.set(key,0);
 client.incr(key, 1);
此时应该返回 1,但是结果是一个很大的数 35634323

1,关于本地缓存，我看到源代码中使用的ConcurrentHashMap，Concurr
entHashMap不
好的一点是就是无论是put还是get都是需要lock的，针对只是作�
��缓存来使用的话，
如果取出来的数据不需要修改都直接返回给客户端，那么只��
�真多put进行lock就可以
了，get的时候可以不需要lock，建议自己写一个Map，只对put进�
��lock，这样可以提
高获取本地缓存数据的速度。

2，正如你所说，memcached并非是用来做存储使用的，所以很不�
��解为什么要做成集
群式的，我的情况是有多个client对应多个memcached服务器端，��
�于所有服务器都在
一个局域网中，所以一个client对memcached进行了存储操作的同��
�，也会使用局域网
广播的形式通过只所有其他的client，这样所有的client就知道��
�个key值所对应的
value存储到了那一天memcached服务器上，即节省了memcached对内存
的使用，也提高
了多client的命中率问题。

个人建议，如果有什么不妥的地方，欢迎讨论。

xiazhiquan(at)youku.com

在正式环境中，在极少情况下会出现如下错误：
2013-11-27 08:35:54,964:[ERROR]  [pool-5-thread-4] 96137   
com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient.set(MemCachedCl
ient.java:863) ++++ server response: VERSION 1.4.5

根据memcached协议，set只会响应：
"STORED\r\n"
或者
"NOT_STORED\r\n"

不清楚是memcached服务器的问题还是memcached客户端的问题？

源代码是否能提供下载

2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ failed to 
close SockIO obj from deadPool
2013-08-31 17:26:54 [MaintThread] ERROR 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool  - ++++ socket or 
its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call


这边一直不停的报这个错误，找了很久没有结果，请问谁能��
�助我？求解

在使用2.5.2的过程中，发现了一个设计上的问题（可能不一定
正确，望大家相互探讨）。
假设通过客户端使用两个memcached服务器实例A，B做集群，那么
客户端在第一次获取数据并放入服务器A的同时，也异步把相�
��的数据放入到服务器B，而如果在存入带有有效期的数据时��
�使用相对时间，假设有效期30分钟），那么相同的数据分别��
�放入A，B的失效时间点也将不同，因为是异步拷贝的，还不��
�证两台服务器的时钟总是一致的，假设这两种情况都会出现�
��那么存入服务器A，B的数据失效时间点差距就更大了，假设�
��5秒钟（即服务器A的数据失效5秒钟后，B的才达到失效时间��
�，而在这5秒钟之内，A是拿不到数据的了，结果客户端从B那�
��能拿到数据，可以看看这个类MemcachedCache的get方法都做了哪�
��事情：

public Object get(String key)
    {
        Object result = null;
        boolean isError = false;

        try
        {
            result = getCacheClient(key).get(key);  
        }
        catch(MemcachedException ex)
        {
            Logger.error(new StringBuilder(helper.getCacheName())
                .append(" cluster get error"),ex);

            isError = true;
        }


        if (result == null && helper.hasCluster())
            if (isError || helper.getClusterMode().equals
                    (MemcachedClientClusterConfig.CLUSTER_MODE_ACTIVE))
        {
            List<MemCachedClient> caches = helper.getClusterCache();

            for(MemCachedClient cache : caches)
            {
                if (getCacheClient(key).equals(cache))
                    continue;

                try
                {
                    try
                    {
                        result = cache.get(key);
                    }
                    catch(MemcachedException ex)
                    {
                        Logger.error(new StringBuilder(helper.getCacheName())
                            .append(" cluster get error"),ex);

                        continue;
                    }

                    //仅仅判断另一台备份机器，不多次判断，防止效率低下
                    if (helper.getClusterMode()
                            .equals(MemcachedClientClusterConfig.CLUSTER_MODE_ACTIVE) && result != null)
                    {
                        Object[] commands = new Object[]{CacheCommand.RECOVER,key,result};

                        addCommandToQueue(commands);
                    }

                    break;

                }
                catch(Exception e)
                {
                    Logger.error(new StringBuilder(helper.getCacheName())
                                .append(" cluster get error"),e);
                }

            }
        }


        return result;
    }


注意代码块：

//仅仅判断另一台备份机器，不多次判断，防止效率低下
if(helper.getClusterMode().equals(MemcachedClientClusterConfig.CLUSTER_MODE_ACTI
VE) && result != null)
    {
    Object[] commands = new Object[]{CacheCommand.RECOVER,key,result};

    addCommandToQueue(commands);
    }

这里的意思就是把从服务器B获取到的数据拷贝到服务器A，而
且是永久不过期的（命令数组中没有时间），而5秒钟过后，B
服务器中的数据将失效，重复前面所述的过程，把数据从服��
�器A拷贝到服务器B，同样变成永久不过期，最终的结果就是��
�置了有效期的数据，都有可能看起来永久无效一样杯具。

以上分析不知道是否存在，有点先斩后奏了，哥去验证一下��
�…

对于同一个key，调用asf-cache缓存后，使用cache.get(key,30)读取。
然后再使用cache.put(key, 
anothervalue)，这时cache.get(key,30)得到的是前一个
值，不是anothervalue，这样在逻辑上可能会造成一些问题，建��
�在put时顺便清理掉
内存缓存。

不过就是加上这个处理，在多jvm的情况下也是不好处理，还��
�会有这个问题。

通过调用MemcachedCache的put(String key, Object value, int 
TTL)或put(String key, Object value, Date 
expiry)方法，超过设置时间后，还是能读到数据，有些很长一�
��时间才能失效，有些却貌似长期不失效，实在是费解，比如
：设置了10秒钟的有效期，结果有些缓存在8-10分钟后才过期��
�有些却一直不过期。不知道大家是否也碰到过类似的问题？�
��有何解决方案呢？大家来探讨一下！

[AdPushServer] 2012-06-01 13:43:28,855 - 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool - selfMaint - ++++ 
failed to close SockIO obj from deadPool
[AdPushServer] 2012-06-01 13:43:28,856 - 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool - selfMaint - ++++ 
socket or its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose call
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$SockIO.trueClose(SockIOPool.java:2282)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.selfMaint(SockIOPool.java:1420)
    at com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool$MaintThread.run(SockIOPool.java:1989)

目前的Memcached Cluster 模式中的两种 
模式（Active,Standby）,如果配置文件如下：
1、
    <cluster name="cluster1" mode="active">//mode = active,standby
        <memCachedClients>mclient1,mclient2,mclient3</memCachedClients>
    </cluster>

    <cluster name="cluster2" mode="standby">//mode = active,standby
        <memCachedClients>mclient3,mclient4</memCachedClients>
    </cluster>
    <!--自己增加的本地对象文件Cache路径功能-->
    <localCachePath>d:/pool0/</localCachePath>

    形如上面的配置文件，如果我想cluster1中存入数据的时候，那么
mclient3,mclient4 
中都会有数据，这也是可以理解，但是我们在装在配置文件��
�时
候，初始化对象ConcurrentHashMap<IMemcachedCache,MemcachedClientCluster>
cache2cluster; 
的时候就会有问题，因为同一个memcached(mclient3)这中情况是隶
属两个集群的，所以在加载配置文件中之保留了 mclient3 
隶属一个集群（cluster1
or 
cluster2），建议这个逻辑给与考虑（一句话：考虑MemcacheClient�
��属多个集群
的情况）



2、这个memcached client结构非常好用，感谢 wenchu 的风险。
   在这里我有一个个人的想法，就是我们现在已经实现了 进程分布式Memcache +
Local Memory Cache 
,是否有必要在进一步增加三级缓存：即本地文件缓存系统。�
��
于这个功能我做了一个简单的实现，但由于没有代码提交权��
�，所以没能提交到服务
器中。

您好：
    应用中，这边是用c语言存入memcached中的，用此客户端读出内容为空，但是用其他客户端能读出相应内容，请帮忙确认一下问题。

我把memcache重启后，服务报错如下
++++ failed to close SockIO obj from deadPool
++++ socket or its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose 
call

是否支持自动重连机制

java.lang.NullPointerException
        at 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.isFreeSocket(So
ckIOPool.java:968)
        at 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.getConnection(S
ockIOPool.java:905)
        at 
com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool.getSock(SockIOP
ool.java:740)
        at 
com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient.get(MemCac
hedClient.java:1352)
        at 
com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient.get(MemCac
hedClient.java:1296)
        at 
net.rubyeye.memcached.benchmark.asfcached.ReadWriteThread.get(ReadWriteThre
ad.java:21)
        at 
net.rubyeye.memcached.BaseReadWriteThread.run(BaseReadWriteThread.java:52)

烦请wenchu.cen把memcache.xml里配置的参数的用途做一个明确的说�
��吧，有几个参数的英文
没明白代表啥意思，比如设置缓存过期时间的参数是那个啦��
�

replay this bug:

在myeclipse里写段最简单的test代码，程序无法正常结束。会有2
个进程始终在running.

public static void main(String[] args) {
ICacheManager<IMemcachedCache> manager = 
CacheUtil.getCacheManager(IMemcachedCache.class, 
MemcachedCacheManager.class.getName());
    manager.setConfigFile("memcached1.xml");// 可以指定配置文件名
    manager.start();
    try {
     IMemcachedCache cache = manager.getCache("mclient0");
     cache.put("liuqijun", "liuqijuun123");
     System.out.println(cache.get("liuqijun"));
} catch (Exception e) {
e.printStackTrace();
}finally{
manager.stop();
System.out.println("stop");
}
}

配置文件里只配置一个socketpool和一个client.

<?xml version="1.0" encoding="UTF-8"?>
<memcached>
    <!-- name 属性是程序中使用Cache的唯一标识;socketpool 属性将会关联到后面的socketpool配置; -->
    <client name="mclient1" compressEnable="true" defaultEncoding="UTF-8"
        socketpool="pool1">
        <!-- 可选，用来处理出错情况
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler
        </errorHandler> -->
    </client>
    <client name="mclient2" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool2">
    </client>

    <!--
        name 属性和client 配置中的socketpool 属性相关联。
        maintSleep属性是后台线程管理SocketIO池的检查间隔时间，如果设置为0，则表明不需要后台线程维护SocketIO线程池，默认需要管理。
        socketTO 属性是Socket操作超时配置，单位ms。 aliveCheck
        属性表示在使用Socket以前是否先检查Socket状态。
    -->
    <socketpool name="pool1" maintSleep="5000" socketTO="3000"
        failover="true" aliveCheck="true" initConn="5" minConn="5" maxConn="250"
        nagle="false">
        <!-- 设置memcache服务端实例地址.多个地址用","隔开 -->
        <servers>192.168.91.102:11211</servers>
        <!--,192.168.91.100:11211
            可选配置。表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights> 表示30% load 在
            10.2.224.36:33001, 70% load 在 10.2.224.46:33001

        <weights>3,7</weights>
        -->
    </socketpool>
    <socketpool name="pool2" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">
                <servers>192.168.91.100:11211</servers>
         </socketpool>


    <cluster name="cluster1" mode="active">
            <memCachedClients> mclient1, mclient2</memCachedClients>
         </cluster>

</memcached>

这个是我的客户端配置文件。
当我执行如下代码：
IMemcachedCache cache1 = manager.getCache("mclient1");
            IMemcachedCache cache2 = manager.getCache("mclient2");
            cache1.put("key1","value1");
            cache1.put("key2","value2");
            cache1.put("key3","value3");
            cache1.put("key4","value4");
            cache1.put("key5","value5");
            cache1.put("key6","value6");
            //模拟mclient1失效(结束服务端)，有出错日志在控制台打印
//此处结束掉client1的memcache服务后。
再调用cache1的时候就会报错。。不知道怎么透明使用集群
            Assert.assertEquals(cache1.get("key1"),"value1");
            Assert.assertEquals(cache1.get("key2"),"value2");
            Assert.assertEquals(cache1.get("key3"),"value3");
            Assert.assertEquals(cache1.get("key4"),"value4");
            Assert.assertEquals(cache1.get("key5"),"value5");
            Assert.assertEquals(cache1.get("key6"),"value6");

建议 
1.每次更新版本时候 能带个list 方便了解新功能
2.如果有个api手册最好了

hashingAlg在SocketIOPool中有定义，但是MemcachedClientSocketPoolConfig中
没有
定义读这个配置的方法。
我+上试了下，貌似一致性hash算法是可以用的，为什么不加这
个参数配置呢？

HI,

I having an input file(.JSON,.jpg,.txt,etc..).That file i need to store into 
memcached server.
I don't want to convert file to byte[] before passing to memcached server.
If any possibility to store file inside Memcached server?
I am using spymemcached tool.


Example:

MemcachedClient mc=new MemcachedClient(new 
InetSocketAddress("192.168.7.104",11211));  
File file=new File("D:\\test.txt");
mc.set("Key1",3600,file);
mc.get("Key1");


Plz replay if any sollution..
Thanks in Advance..
Sekhar.

我用了这个集群配置了两台服务器以下是我的配置:
<?xml version="1.0" encoding="UTF-8"?>
<memcached>
    <client name="clusterclient1" compressEnable="true"
        defaultEncoding="UTF-8" socketpool="clusterpool1">

<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</e
rrorHandler>
    </client>

    <client name="clusterclient2" compressEnable="true"
        defaultEncoding="UTF-8" socketpool="clusterpool2">

<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</e
rrorHandler>
    </client>

    <socketpool name="clusterpool1" failover="true" initConn="10" minConn="10"
        maxConn="250" maintSleep="0" nagle="false" socketTO="3000"
        aliveCheck="true">
        <servers>192.168.1.12:11200</servers>
    </socketpool>

    <socketpool name="clusterpool2" failover="true" initConn="10" minConn="10"
        maxConn="250" maintSleep="0" nagle="false" socketTO="3000"
        aliveCheck="true">
        <servers>192.168.1.18:11200</servers>
    </socketpool>
    <cluster name="cluster1" mode="active">
        <memCachedClients>clusterclient1,clusterclient2</memCachedClients>  
    </cluster>
</memcached>
每次重启memcached之后里面还会存留数据,为什么

您好，首先非常感谢您贡献的代码：
在我使用memcache-client-forjava作为Jetty 
Session实现的过程中，从memcache中取出保存的Session对象出现了�
��
Caused by: java.lang.ClassNotFoundException: 
org.springframework.security.ui.savedrequest.SavedRequest
    at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
    at java.lang.Class.forName0(Native Method)
    at java.lang.Class.forName(Class.java:247)
    at java.io.ObjectInputStream.resolveClass(ObjectInputStream.java:604)
    at com.alisoft.xplatform.asf.cache.memcached.client.ContextObjectInputStream.resolveClass(ContextObjectInputStream.java:42)
发现是在ContextObjectInputStream中反向序列化对象时抛出的异常��
�

我的应用场景是，memcache-client-forjava在Jetty的启动中加载，用�
��实现Session的分布式缓存。
然后在Web应用中在Session中保存的对象，是在Web应用的ClassPath�
��的。

您的ContextObjectInputStream中默认处理流程：
        if ( mLoader == null )
            return super.resolveClass( v );
会抛出上面的异常。
我参考了一下Jetty的JdbcSession实现，他的处理流程是：
    try
    {
        return Class.forName(cl.getName(), false, Thread.currentThread().getContextClassLoader());
    }
    catch (ClassNotFoundException e)
    {
        return super.resolveClass(cl);
    }
根据Jetty的实现，尝试修改了您的ContextObjectInputStream.resolveClas
s方法，修改后：
    @SuppressWarnings("unchecked")
    protected Class resolveClass( ObjectStreamClass v ) throws IOException, ClassNotFoundException {
        if ( mLoader == null ) {
            try
            {
                return Class.forName(v.getName(), false, Thread.currentThread().getContextClassLoader());
            }
            catch (ClassNotFoundException e)
            {
                return super.resolveClass( v );
            }
        }
        else
            return Class.forName( v.getName(), true, mLoader );
    }
可以解决上述问题。表达的不好，不知是否明确。

What steps will reproduce the problem?
1.请问client为什么用线程池而不用nio呢？nio的性能是不是更好
些呢? 
2.
3.

What is the expected output? What do you see instead?


What version of the product are you using? On what operating system?


Please provide any additional information below.

请问，2.5.2版本有什么新功能

我把memcache重启后，服务报错如下
++++ failed to close SockIO obj from deadPool
++++ socket or its streams already null in trueClose call
java.io.IOException: ++++ socket or its streams already null in trueClose 
call

虽然经过了几次出错之后会重新建立正确的连接。但是我测��
�发现，如果在memcached服务停止期间，客户端进行了请求，那�
��当memcached服务再启动之后，客户端会多报好几次错误然后才
能恢复正常。

很高兴看到国内有这么好的开源项目，非常支持！

我不知道你对OSGi是否有了解，因为我现在所在的项目团队开�
��的产品是基于OSGi
的，想用这个开源项目来实现对缓存的集中管理，但需要现��
�的制品是不支持OSGi
的，还需要我们来封装，虽然工作量不大，但总觉得不方便��
�请问这个项目以后有考
虑提供对OSGi环境的支持吗？还有一个是有没有一个maven仓库��
�提供给像我们用
Maven构建的项目来下载呢？

SVN 不能checkout 工程

代码如下：

//仅仅判断另一台备份机器，不多次判断，防止效率低下
if (helper.getClusterMode()

.equals(MemcachedClientClusterConfig.CLUSTER_MODE_ACTIVE) && result != 
null)
                    {
                        Object[] commands = new 
Object[]{CacheCommand.RECOVER,key,result};


addCommandToQueue(commands);
}

有可能两台服务器时间不一致（相差3毫秒，导致master先过期�
��，导致这个问题。


我在使用时每天都能遇到很多：
如下：
2010-03-07 02:31:14 - set value to master:DUET_MATCH_STATUS_29621127=Sun 
Mar 07 02:31:14 CST 2010

有没有好的办法解决这个问题？比如回写时将过期时间带上��
�

加入wstx-asl-2.9.3.jar后 该客户端无法加载memcached.xml
CacheUtil.loadMemcachedConfigFromURL 
中加载xml的部分改为dom4j来读取后正常使用

比如里面有两个mc：mc1，mc2
mc1宕机了可以自动切换到mc2？

我写了个测试的例子，使用集群，运行时间会比较长，在运��
�过程中如果一个
memcached节点挂掉了，我发现后面的请求还是会去尝试使用这��
�节点，并一直抛出异
常，就是说如果一个key分配到这个节点，后面还是会继续使��
�这个节点，尽管这个节
点已经挂了。这样我觉得不能达到健壮性的要求。

是否可以加上一些检查，在一次连接失败后，自动去使用下��
�个服务器，并更改节点
分配算法，不再使用失败的服务器，同时，最好开一个线程��
�隔段时间检查一下失败
的服务器有没有恢复，如果恢复再使用那台服务器。

1.对重要常用内容给出demo代码，比如：如何遍历（keyset似乎��
�能返回几万个，多
的返回不了），配置文件的详细说明（memcached里有对hash算法�
��设置，在多台mem
机器时的存储办法，尤其是多台web集群时调用mem集群，不同��
�算法设置会导致web间
同步问题，在client里未找到如何配置）

2.对源代码的详细说明，javadoc里大部分说明位置是空白

3.对下个版本进行详细预测说明

大部分推广速度快，应用范围广的开源项目都会满足以上几��
�。作为国内开源的支持
者，希望这个项目也能满足这几点，从而可以快速大范围推��
�

现象是Reload Servlet 
Container不能完全释放内存，会存在多个容器为Web
application创建的实例而最终导致OOM，有些线程也不能被销毁，
如下：

pool-2-thread-1 [WAITING] CPU time: 0:00
sun.misc.Unsafe.park(boolean, long)
java.util.concurrent.locks.LockSupport.parkNanos(Object, long)
java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos
(long)
java.util.concurrent.DelayQueue.take()
java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take()
java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take()
java.util.concurrent.ThreadPoolExecutor.getTask()
java.util.concurrent.ThreadPoolExecutor$Worker.run()
java.lang.Thread.run()

看代码MemcachedCacheManager的stop()方法没有显式销毁创建的SocketPo
ol，看起来
比较有问题。

您好！我在servlet的init函数中调用start函数进行了启动，请问�
��动以后在我的业务功能模
块中怎么能获取到这个已经启动的实例呢？我看了您的那个de
mo没有发现怎么弄。急盼您的回
复！谢谢！

我觉得keySet的实现方式可以优化一下：
目前你的memcached的keySet实现，是采用读取memcached中的items，逐
个进行迭代，判断
key找到需要的key列表的方式实现的；这样的话每一个item都需�
��进行遍历，而且限制大小是
50000个。
其实在进行第一遍的item遍历的时候，只需要遍历出1,2个就行�
��，然后判断如果这个item中包
含了我们需要的key，则再进行第二次的50000次查询遍历，这样
避免了对其他items的遍历操
作，因为针对某一种大小的值，一般情况下都是存放在同一��
�item中的。

目前我是采用这种方式，对于大量的keySet操作，速度提高了��
�少～

//第一遍的只查找对应key的item
Map cacheDump = client.statsCacheDump(dump, 2);
                HashMap firstKey = (HashMap)cacheDump.values().iterator
().next();
                if(firstKey != null && firstKey.size() > 0 && ((String)
firstKey.keySet().iterator().next()).startsWith(cacheName)) {
                        //符合条件的，进行第二次的遍历
                    cacheDump = client.statsCacheDump(dump, 50000);
                }

代码注释里很多乱码，建议作者统一使用utf8编码