亚洲成AV人片在,亚洲国产综合无码一区,国产亚洲精品VA片在线播放

memcached 客户端代�?Java memcached client学习

Chan Chen — Fri, 19 Apr 2013 04:16:00 GMT

Refer to:http://makemyownlife.iteye.com/blog/1439581

java memcached client源码�Q��ȝ��代码量还是很��的
主要是如下两个类:
MemcachedClient.java
SockIOPool.java

�?先看推荐的测试代�?

Java代码  

/**
* Copyright (c) 2008 Greg Whalin
* All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the BSD license
*
* This library is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE.
*
* You should have received a copy of the BSD License along with this
* library.
*
* @author greg whalin
*/
package com.meetup.memcached.test;

import com.meetup.memcached.*;
import org.apache.log4j.*;

public class TestMemcached  {
    public static void main(String[] args) {
              // memcached should be running on port 11211 but NOT on 11212

        BasicConfigurator.configure();
        String[] servers = { "localhost:11211"};
        SockIOPool pool = SockIOPool.getInstance();
        pool.setServers( servers );
        pool.setFailover( true );
        pool.setInitConn( 10 );
        pool.setMinConn( 5 );
        pool.setMaxConn( 250 );
        pool.setMaintSleep( 30 );
          //�q�是开启一个nagle ��法。改��法避免�|�络中充塞小��包�Q�提高网�l�的利用�?nbsp;
        pool.setNagle( false );
        pool.setSocketTO( 3000 );
        pool.setAliveCheck( true );
        pool.initialize();

        MemcachedClient mcc = new MemcachedClient();

        // turn off most memcached client logging:
        com.meetup.memcached.Logger.getLogger( MemcachedClient.class.getName() ).setLevel( com.meetup.memcached.Logger.LEVEL_WARN );

        for ( int i = 0; i < 10; i++ ) {
            boolean success = mcc.set( "" + i, "Hello!" );
            String result = (String)mcc.get( "" + i );
            System.out.println( String.format( "set( %d ): %s", i, success ) );
            System.out.println( String.format( "get( %d ): %s", i, result ) );
        }

}

其实对于我来�?我很��x��白的是连接池是如何配�|�的,关键在于 pool.initialize(); �q�个�Ҏ��如何初始化的�?nbsp;

Java代码  

/**
     * Initializes the pool.
     */
    public void initialize() {

        synchronized( this ) {

            // check to see if already initialized
            if ( initialized
                    && ( buckets != null || consistentBuckets != null )
                    && ( availPool != null )
                    && ( busyPool != null ) ) {
                log.error( "++++ trying to initialize an already initialized pool" );
                return;
            }

            // pools
            availPool   = new HashMap>( servers.length * initConn );
            busyPool    = new HashMap>( servers.length * initConn );
            deadPool    = new IdentityHashMap();

            hostDeadDur = new HashMap();
            hostDead    = new HashMap();
            maxCreate   = (poolMultiplier > minConn) ? minConn : minConn / poolMultiplier;       // only create up to maxCreate connections at once

            if ( log.isDebugEnabled() ) {
                log.debug( "++++ initializing pool with following settings:" );
                log.debug( "++++ initial size: " + initConn );
                log.debug( "++++ min spare   : " + minConn );
                log.debug( "++++ max spare   : " + maxConn );
            }

            // if servers is not set, or it empty, then
            // throw a runtime exception
            if ( servers == null || servers.length <= 0 ) {
                log.error( "++++ trying to initialize with no servers" );
                throw new IllegalStateException( "++++ trying to initialize with no servers" );
            }

            // initalize our internal hashing structures
            if ( this.hashingAlg == CONSISTENT_HASH )
                populateConsistentBuckets();
            else
                populateBuckets();

            // mark pool as initialized
            this.initialized = true;

            // start maint thread
            if ( this.maintSleep > 0 )
                this.startMaintThread();
        }
    }

如上代码��程如下�Q?nbsp;
1 ��是否已�l�被初始�?nbsp;
2 定义可用链接 �Q�繁忙链接池
3 判断是否一致性hash��法 �q�是普通的��法
4 定义一个后台线�E?�Q�来�l�护
�?�Q�首先来分析下一致性hash��法�?nbsp;

从如下代码来分析 �Q?nbsp;

Java代码  

  if (
         this.hashingAlg == CONSISTENT_HASH )
        populateConsistentBuckets();
}

Java代码  

/** ��server��d��C��致性hash�?�?2��?nbsp;圆环  **/
    private void populateConsistentBuckets() {
        if ( log.isDebugEnabled() )
            log.debug( "++++ initializing internal hashing structure for consistent hashing" );

        // store buckets in tree map
        this.consistentBuckets = new TreeMap();

        MessageDigest md5 = MD5.get();
        //得到�ȝ��权重
        if ( this.totalWeight <= 0 && this.weights !=  null ) {
            for ( int i = 0; i < this.weights.length; i++ )
                this.totalWeight += ( this.weights[i] == null ) ? 1 : this.weights[i];
        }
        else if ( this.weights == null ) {
            this.totalWeight = this.servers.length;
        }


        for ( int i = 0; i < servers.length; i++ ) {
            //每台服务器的权重
            int thisWeight = 1;
            if ( this.weights != null && this.weights[i] != null ) {
                thisWeight = this.weights[i];
            }

            //有兴��的朋友可以参考��^衡Hash ��法的另一个指标是�q��?nbsp;(Balance) �Q�定义如下：    �q��性　�q��性是指哈希的�l�果能够��可能分布到所有的�~�冲中去�Q�这样可以��得所有的�~�冲�I�间都得到利�?nbsp;
            //了解册��U�情况， consistent hashing 引入�?#8220;虚拟节点”的概念，它可以如下定义： “虚拟节点”�Q?nbsp;virtual node �Q�是实际节点�?nbsp;hash �I�间的复制品�Q?nbsp;replica �Q�，一实际个节点对应了若干�?#8220;虚拟节点”�Q�这个对应个��C��成�ؓ“复制个数”�Q?#8220;虚拟节点”�?nbsp;hash �I�间中以 hash 值排列�?nbsp;
            double factor = Math.floor(((double)(40 * this.servers.length * thisWeight)) / (double)this.totalWeight);

            for ( long j = 0; j < factor; j++ ) { //加密规则�c�M�� 127.0.0.1_1
                byte[] d = md5.digest( ( servers[i] + "-" + j ).getBytes() ); //转化�?6位的字节数组
                //16位二�q�制数组�?位�ؓ一�l�，每组�W?个值左�U?4位，�W�三个值左�U?6位，�W�二个值左�U?位，�W�一个��g��U�M��。进行或�q�算�Q�得��C��个小�?�?2 �ơ方的long�?nbsp;
                for ( int h = 0 ; h < 4; h++ ) { //因�ؓ�?6�?nbsp;
                    Long k =  //实际上每个字节进行了�q�算
                          ((long)(d[3+h*4]&0xFF) << 24)
                        | ((long)(d[2+h*4]&0xFF) << 16)
                        | ((long)(d[1+h*4]&0xFF) << 8)
                        | ((long)(d[0+h*4]&0xFF));

                    consistentBuckets.put( k, servers[i] );
                    if ( log.isDebugEnabled() )
                        log.debug( "++++ added " + servers[i] + " to server bucket" );
                }
            }



            // create initial connections
            if ( log.isDebugEnabled() )
                log.debug( "+++ creating initial connections (" + initConn + ") for host: " + servers[i] );

            //创徏链接
            for ( int j = 0; j < initConn; j++ ) {
                SockIO socket = createSocket( servers[i] );
                if ( socket == null ) {
                    log.error( "++++ failed to create connection to: " + servers[i] + " -- only " + j + " created." );
                    break;
                }
                //加入socket到连接池 �q�里慢慢�?nbsp;
                addSocketToPool( availPool, servers[i], socket );
                if ( log.isDebugEnabled() )
                    log.debug( "++++ created and added socket: " + socket.toString() + " for host " + servers[i] );
            }
        }

    }

�?比如�?我们调用�?如下代码:

Java代码  

MemcachedClient mcc = new MemcachedClient();
mcc.set("6", 1);

�q�里key 如何定位��C��台server呢？我先把一致性hash��法的定位方法说下�?nbsp;

Java代码  

//得到定位server的Socket��装对象
SockIOPool.SockIO sock = pool.getSock( key, hashCode );

Java代码  

//计算出key对应的hash�?md5) �Q�然�?nbsp;
long bucket = getBucket( key, hashCode );

Java代码   

//得到大于hash的map�Q�因为treemap已经排好序了。调用tailMap可以得到大于�{�于�q�个hash的对�?nbsp;�Q�然后调用firstKey得到圆环上的hash�?nbsp;
SortedMap tmap =
            this.consistentBuckets.tailMap( hv );
        return ( tmap.isEmpty() ) ? this.consistentBuckets.firstKey() : tmap.firstKey();

Chan Chen 2013-04-19 12:16 发表评论

Memcached实现内存�~�存(一)

Chan Chen — Thu, 19 Apr 2012 09:36:00 GMT

Memcached是danga.com�Q�运营LiveJournal的技术团队）开发的一套分布式内存对象�~�存�pȝ��Q�用于在动态系�l�中减少数据库负载，提升性能。LJ每秒动态页面访问量几千�ơ，用户700万。Memcached��数据库负蝲大幅度降低，更好的分配资源，更快速访问�?/span>

关于�q�个东西�Q�相信很多�h都用�q�，本文意在通过对memcached的实现及代码分析�Q�获得对�q�个��的开源��Y件更深入的了解，�q�可以根据我们的需要对其进行更�q�一步的优化。末了将通过对BSM_Memcache扩展的分析，加深�?memcached的��用方式理解。�?/span>

1.Memcached是什�?/span>

在阐�q�这个问题之前，我们首先要清楚它“不是什�?#8221;。很多�h把它当作和SharedMemory那种形式的存储蝲体来使用�Q�虽然memcached使用了同��L��“Key=>Value”方式�l�织数据�Q�但是它和共享内存、APC�{�本地缓存有非常大的区别。Memcached是分布式的，也就是说它不是本地的。它��Z��|�络�q�接�Q�当然它也可以��用localhost�Q�方式完成服务，本��n它是一个独立于应用的程序或守护�q�程�Q�Daemon方式�Q�。即Memcached是高性能的，分布式的内存对象�~�存�pȝ��Q�用于在动态应用中减少数据库负载，提升讉K��速度�?/span>

Memcached 使用libevent库实现网�l�连接服务，理论上可以处理无限多的连接，但是它和Apache不同�Q�它更多的时候是面向�E�_��的持�l�连接的�Q�所以它实际的�ƈ发能力是有限制的。在保守情况下memcached的最大同时连接数�?00�Q�这和Linux�U�程能力有关�p�，�q�个数值是可以调整的。关�?libevent可以参考相��x��档�?Memcached内存使用方式也和APC不同。APC是基于共享内存和MMAP的，memcachd有自��q��内存分配��法和管理方式，它和�׃�n内存没有关系�Q�也没有�׃�n内存的限�Ӟ��通常情况下，每个memcached�q�程可以��理2GB的内存空��_��如果需要更多的�I�间�Q�可以增加进�E�数�?/span>

2. Memcached适合什么场�?/span>

在很多时候，memcached都被滥用了，�q�当然少不了对它的抱怨。我�l�常在论坛上看见有�h发脓�Q�类��g��“如何提高效率”�Q�回复是“用memcached”�Q�至于怎么用，用在哪里�Q�用来干什么一句没有。memcached不是万能的，它也不是适用在所有场合�?/span>

Memcached �?#8220;分布�?#8221;的内存对象缓存系�l�，那么��是��_��那些不需�?#8220;分布”的，不需要共享的�Q�或者干脆规模小到只有一台服务器的应用， memcached不会带来��M��好处�Q�相反还会拖慢系�l�效率，因�ؓ�|�络�q�接同样需要资源，即��是UNIX本地�q�接也一栗��在我之前的��试数据中显�C�， memcached本地��d��速度要比直接PHP内存数组慢几十倍，而APC、共享内存方式都和直接数�l�差不多。可见，如果只是本地�U�缓存，使用 memcached是非�怸�划算的�?/span>

Memcached在很多时候都是作为数据库前端cache使用的。因为它比数据库��了很多SQL解析、磁盘操作等开销�Q�而且它是使用内存来管理数据的�Q�所以它可以提供比直接读取数据库更好的性能�Q�在大型�pȝ��中，讉K��同样的数据是很频�J�的�Q?memcached可以大大降低数据库压力，使系�l�执行效率提升。另外，memcached也经�怽�为服务器之间数据�׃�n的储媒介�Q�例如在SSO�pȝ��中保存系�l�单点登陆状态的数据��可以保存在memcached中，被多个应用共享�?/span>

需要注意的是，memcached使用内存��理数据�Q�所以它是易��q��Q�当服务器重启，或者memcached�q�程中止�Q�数据便会丢失，所�?memcached不能用来持久保存数据。很多�h的错误理解，memcached的性能非常好，好到了内存和��盘的对比程度，其实memcached使用内存�q�不会得到成百上千的��d��速度提高�Q�它的实际瓶颈在于网�l�连接，它和使用��盘的数据库�pȝ��相比�Q�好处在于它本��n非常“�?#8221;�Q�因为没有过多的开销和直接的��d��方式�Q�它可以��L��应付非常大的数据交换量，所以经�怼�出现两条千兆�|�络带宽都满负荷了，memcached�q�程本��n�q�不占用多少CPU资源的情��c�?/span>

通常的网��늼�存方式有动态缓存和静态缓存等几种�Q�在ASP.NET中已�l�可以实现对��面局部进行缓存，而��用memcached的缓存比 ASP.NET的局部缓存更加灵�z�，可以�~�存��L��的对象，不管是否在页面上输出。而memcached最大的优点是可以分布式的部�|Ԍ��q�对于大规模应用来说也是必不可少的要求�?/span>

LiveJournal.com使用了memcached在前端进行缓存，取得了良好的效果�Q�而像wikipedia,sourceforge�{�也采用了或卛_��采用memcached作�ؓ�~�存工具。memcached可以大规模网站应用发挥巨大的作用�?/span>

2.1 memcached 的工作原�?/span>

首先 memcached 是以守护�E�序方式�q�行于一个或多个服务器中�Q�随时接受客��L��的连接操作，客户端可以由各种语言�~�写�Q�目前已知的客户�?API 包括 Perl/PHP/Python/Ruby/Java/C#/C �{�等。PHP �{�客��L��在与 memcached 服务建立�q�接之后�Q�接下来的事情就是存取对象了�Q�每个被存取的对象都有一个唯一的标识符 key�Q�存取操作均通过�q�个 key �q�行�Q�保存到 memcached 中的对象实际上是攄��内存中的�Q��ƈ不是保存�?cache 文�g中的�Q�这也是��Z��?memcached 能够如此高效快速的原因。注意，�q�些对象�q�不是持久的�Q�服务停止之后，里边的数据就会丢失�?/span>

.2 memcached 安装

首先是下�?memcached 了，目前最新版本是 1.1.12�Q�直接从官方�|�站卛_��下蝲�?memcached-1.1.12.tar.gz。除此之外，memcached 用到�?libevent�Q�我下蝲的是 libevent-1.1a.tar.gz

接下来是分别��?libevent-1.1a.tar.gz �?memcached-1.1.12.tar.gz 解开包、编译、安装：

# tar -xzf libevent-1.1a.tar.gz
# cd libevent-1.1a
# ./configure --prefix=/usr
# make
# make install
# cd ..
# tar -xzf memcached-1.1.12.tar.gz
# cd memcached-1.1.12
# ./configure --prefix=/usr
# make
# make install

安装完成之后�Q�memcached 应该�?/usr/bin/memcached�?/span>

3.如何使用memcached-Server�?

在服务端�q�行�Q?/span>

# ./memcached -d -m 2048 -l 10.0.0.40 -p 11211 -u httpd

-d 以守护程序（daemon�Q�方式运�?memcached�Q?/span>

-m 讄�� memcached 可以使用的内存大��，单位�?M�Q?/span>

-l 讄��监听�?IP&nb

sp;地址�Q�如果是本机的话�Q�通常可以不设�|�此参数�Q?/span>

-p 讄��监听的端口，默认�?11211�Q�所以也可以不设�|�此参数�Q?/span>

-u 指定用户�Q�如果当前�ؓ root 的话�Q�需要��用此参数指定用户�?/span>

�q�将会启动一个占�?G内存的进�E�，�q�打开11211端口用于接收��h��。由�?2位系�l�只能处�?G内存的寻址�Q�所以在大于4G内存使用PAE�?2位服务器上可以运�?-3个进�E�，�q�在不同端口�q�行监听�?/span>

4. 如何使用memcached-Client�?

在应用端包含一个用于描�q�Client的Class后，��可以直接��用，非常��单�?/span>

PHP Example:

$options["debug"] = false;

$memc = new MemCachedClient($options);

$myarr = array("one","two", 3);

$memc->set("key_one", $myarr);
$options["servers"] = array("192.168.1.41:11211", "192.168.1.42:11212");

$val = $memc->get("key_one");

print $val[0]."\n"; // prints 'one‘

print $val[1]."\n"; // prints 'two‘

print $val[2]."\n"; // prints 3

5.��Z��么不使用数据库做�q�些�Q?/span>

暂且不考虑使用什么样的数据库(MS-SQL, Oracle, Postgres, MysQL-InnoDB, etc..), 实现事务(ACID�Q�Atomicity, Consistency, Isolation, and Durability )需要大量开销�Q�特别当使用到硬盘的时候，�q�就意味着查询可能会阻塞。当使用不包含事务的数据库（例如Mysql-MyISAM�Q�，上面的开销不存在，但读�U�程又可能会被写�U�程��d��。Memcached从不��d��Q�速度非常快�?/span>

6.��Z��么不使用�׃�n内存?

最初的�~�存做法是在�U�程内对对象�q�行�~�存�Q�但�q�样�q�程间就无法�׃�n�~�存�Q�命中率非常低，��D��~�存效率极低。后来出��C��׃�n内存的缓存，多个�q�程或者线�E�共享同一块缓存，但毕竟还是只能局限在一台机器上�Q�多台机器做相同的缓存同��h��一�U�资源的��费�Q�而且命中率也比较低�?/span>

Memcached Server和Clients共同工作�Q�实现跨服务器分布式的全局的缓存。�ƈ且可以与Web Server共同工作�Q�Web Server对CPU要求高，对内存要求低�Q�Memcached Server对CPU要求低，对内存要求高�Q�所以可以搭配��用�?/span>

7.Mysql 4.x的缓存怎么�?

Mysql查询�~�存不是很理惻I��因�ؓ以下几点�Q?/span>

当指定的表发生更新后�Q�查询缓存会被清�I�。在一个大负蝲的系�l�上�q�样的事情发生的非常频繁�Q�导致查询缓存效率非�怽��Q�有的情况下甚至�q�不如不开�Q�因为它对cache的管理还是会有开销�?/span>

�?2位机器上�Q�Mysql对内存的操作�q�是被限制在4G以内�Q�但memcached可以分布开�Q�内存规模理��Z��不受限制�?/span>

Mysql上的是查询缓存，而不是对象缓存，如果在查询后�q�需要大量其它操作，查询�~�存��帮不上忙了�?/span>

如果要缓存的数据不大�Q��ƈ且查询的不是非常频繁�Q�这��L��情况下可以用Mysql 查询�~�存�Q�不然的话memcached更好�?/span>

8.数据库同步怎么��P��

�q�里的数据库同步是指的类似Mysql Master-Slave模式的靠日志同步实现数据库同步的机制�?/span>

你可以分布读操作�Q�但无法分布写操作，但写操作的同步需要消耗大量的资源�Q�而且�q�个开销是随着slave服务器的增长而不断增长的�?/span>

下一步是要对数据库进行水�q�_��分，从而让不同的数据分布到不同的数据库服务器组上，从而实现分布的��d��Q�这需要在应用中实现根据不同的数据�q�接不同的数据库�?/span>

当这一模式工作后（我们也推荐这样做�Q�，更多的数据库��D��更多的让人头疼的��g错误�?/span>

Memcached可以有效的降低对数据库的讉K��Q�让数据库用主要的精力来做不频繁的写操作�Q�而这是数据库自己控制的，很少会自己阻�?自己�?/span>

9.Memcached快吗�Q?/span>

非常快，它��用libevent�Q�可以应付�Q意数量打开的连接（使用epoll�Q�而非poll�Q�，使用非阻塞网�l�IO�Q�分布式散列对象��C��同的服务器，查询复杂度是O(1)�?/span>

10.memcached的相��x��象类

public abstract class BaseManagerextends BaseObject> implements Manager {

     private MemcachedClient memcached;

     protected int default_cache_time_second = 3600;

      public void setMemcached(MemcachedClient memcached) {

         this.memcached = memcached;

      }

      public MemcachedClient getMemcached() {

         return memcached;

     }

      public void setDefault_cache_time_second(int default_cache_time_second) {

         this.default_cache_time_second = default_cache_time_second;

    } public Object getCacheValueFromMemcached(String key) {

        return getCacheValueFromMemcached(key, null);

    }

    public Object getCacheValueFromMemcached(String key, Object obj) {

        Object new_obj = null;

        try {

            new_obj = memcached.get(key);

            } catch (Exception e) {

            if (logger.isWarnEnabled()) {

logger.warn("Failed to get from MeMCache", e);

             }

         }

         return (new_obj != null) ? new_obj : obj;
       }

       public void setCacheValueToMemcached(String cacheKey, int time_to_live, Serializable obj) {

          if (null != memcached.get(cacheKey)) {

             memcached.replace(cacheKey, time_to_live, obj);

          } else {

             memcached.add(cacheKey, time_to_live, obj);

         }

       }
     }

11.service调用memcache的一个例子：

public List getLastModifyAlbumMember(int limit) {

        String cacheKey = this.createCachekey(new

       Object[]{"schedule","lastmodifyalbumember",limit});

        List list = (List) this.getCacheValueFromMemcached(cacheKey);

        List list1 = new ArrayList();

        if(null!=list&&list.size()>0){

            for (Object aList : list) {

                list1.add(Integer.parseInt(String.valueOf(aList)));

            }

        }

        return list1;

    }

参考资料：

http://www.danga.com/

http://www.linuxjournal.com/article/7451

Chan Chen 2012-04-19 17:36 发表评论