memcached缓存

  1. 什么是缓存

    凡是位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为缓存

  2. 分类
    • 操作系统磁盘缓存，减少磁盘机械操作
    • 数据库缓存，减少文件系统IO
    • 应用程序缓存，减少数据库操作
    • WEB服务器缓存，减少应用服务器请求
    • 客户端浏览器缓存，减少网站访问
  3. web相关
    • 数据库缓存
    • 系统配置参数缓存
    • ORM提供的对象缓存、查询缓存
    • 缓存服务器 EHCache、OSCache、JBossCache
    • 通用缓存 memcached、radis
    • 页面缓存（动态页面静态化、Servlet缓存、页面局部缓存）
    • ajax查询结果缓存
    • 浏览器缓存
    • 代理服务器缓存
    • CDN加速
  4. 适用范围

    频繁访问且时效性不高的数据。例如：用户信息、菜单权限、功能权限、历史数据查询等

  5. memcached缓存

    Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。[http://baike.baidu.com/view/794242.htm]

  6. alisoft Memcached Client

    尽管是“分布式”缓存服务器，但服务器端并没有分布式功能。各个memcached不会互相通信以共享信息。那么，怎样进行分布式呢？这完全取决于客户端的实现。所以，alisoft Memcached Client是一个支持分布式集群的管理客户端。

  7. 单客户端配置
<?xml version="1.0" encoding="UTF-8"?>
<memcached>
    <client name="mclient0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0">
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
    </client>
    <socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11211,127.0.0.1:11212</servers>
        <weights>3,7</weights>
    </socketpool>
</memcached>
  • 创建memcached的标签
  • 创建 client的标签

    name 属性是程序中使用Cache的唯一标识。

    socketpool 属性将会关联到后面的socketpool配置。

    errorHandler 可选，用来处理出错情况。注意在Tag中不要使用空格或者Tab键。

    • 创建socketpool的标签

      name 属性和client 配置中的socketpool 属性相关联。

      maintSleep属性是后台线程管理SocketIO池的检查间隔时间，如果设置为0，则表明不需要后台线程维护SocketIO线程池，默认需要管理。

      socketTO 属性是Socket操作超时配置，单位ms。

      aliveCheck 属性表示在使用Socket以前是否先检查Socket状态。

    • 创建 servers 标签作为socketPool的子标签.设置memcache服务端实例地址，支持多个地址设置，例如“127.0.0.1:11211” 或 “127.0.0.1:11211, 127.0.0.1:11212”
    • 创建 weights 标签作为socketPool的子标签(可选),它表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights>表示30% load 在 127.0.0.1:11211, 70% load 在 127.0.0.1:11212
      1. 单客户端代码
/**
 * lincl
 * 2016年7月12日 下午4:56:35
 *
 */
package com.lezic.core.cache.memcached;

import java.util.Calendar;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import com.alisoft.xplatform.asf.cache.ICacheManager;
import com.alisoft.xplatform.asf.cache.IMemcachedCache;
import com.alisoft.xplatform.asf.cache.memcached.CacheUtil;
import com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;

/**
 * 单客户端
 *
 * @author lincl
 *
 */
public class MemcachedClient {
    static ICacheManager<IMemcachedCache> manager;

    /**
     * 初始化上下文，加载配置文件
     *
     * @throws Exception
     */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        manager = CacheUtil.getCacheManager(IMemcachedCache.class, MemcachedCacheManager.class.getName());
        manager.setConfigFile("memcached0.xml");
        manager.setResponseStatInterval(5 * 1000);
        manager.start();
    }

    /**
     * 摧毁管理器
     *
     * @throws java.lang.Exception
     */
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        manager.stop();
    }

    /**
     * 测试获取
     *
     */
    @Test
    public void testGet() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            cache.remove("key1");
            cache.remove("key2你好");
            cache.put("key1", "1");
            cache.put("key2你好", "你好123");
            Assert.assertEquals(cache.get("key1"), "1");
            Assert.assertEquals(cache.get("key2你好"), "你好123");
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    /**
     * 测试删除
     */
    @Test
    public void testRemove() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            cache.remove("key1");
            cache.put("key1", "value1");
            Assert.assertEquals(cache.get("key1"), "value1");
            cache.remove("key1");
            Assert.assertNull(cache.get("key1"));
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    /**
     * 测试是否包含key
     */
    @Test
    public void testContainsKey() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            cache.remove("key1");
            cache.put("key1", "value1");
            Assert.assertTrue(cache.containsKey("key1"));
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testAdd() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            cache.remove("key1");
            Assert.assertTrue(cache.add("key1", "value1"));
            Assert.assertFalse(cache.add("key1", "value1"));
            Assert.assertEquals(cache.get("key1"), "value1");
            cache.remove("key1");
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    /**
     * Test method for {@link com.alisoft.xplatform.asf.cache.ICache#clear()}.
     */
    @Test
    public void testClear() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            cache.remove("key1");
            cache.put("key1", "value1");
            Assert.assertEquals(cache.get("key1"), "value1");
            cache.clear();
            Assert.assertNull(cache.get("key1"));
            Thread.sleep(2000);
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    /**
     * 保存有有效期的数据 Test method for
     * {@link com.alisoft.xplatform.asf.cache.ICache#put(java.lang.Object, java.lang.Object, java.util.Date)} .
     */
    @Test
    public void testPutKVDate() {
        try {
            IMemcachedCache cache = manager.getCache("mclient0");
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.SECOND, 5);
            cache.remove("key1");
            cache.put("key1", "value1", calendar.getTime());
            Assert.assertEquals(cache.get("key1"), "value1");
            Thread.sleep(5 * 1000 + 1000);
            Assert.assertNull(cache.get("key1"));
        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }
}

9.集群配置

<?xml version="1.0" encoding="UTF-8"?>
<memcached>

    <client name="mclient" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0">
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
    </client>

    <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">
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
    </client>

    <client name="mclient3" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool3">
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
    </client>

    <client name="mclient4" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool4">
        <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
    </client>

    <socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11210</servers>
    </socketpool>

    <socketpool name="pool1" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11211</servers>
    </socketpool>

    <socketpool name="pool2" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11212</servers>
    </socketpool>

    <socketpool name="pool3" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11213</servers>
    </socketpool>

    <socketpool name="pool4" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="0" nagle="false"
        socketTO="3000" aliveCheck="true">
        <servers>127.0.0.1:11214</servers>
    </socketpool>

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

    <cluster name="cluster2" mode="standby">
        //mode = active,standby
        <memCachedClients>mclient3,mclient4</memCachedClients>
    </cluster>

</memcached>
  • 创建cluster标签
  • 创建memCachedClients

    标签作为cluster的子标签，然后将客户端配置到memCachedClients 标签中

  • 可以配置cluster mode（如果没有设置mode属性，默认采用active）
  • 集群当前的特性
    1. 集群中多节点软负载均衡。（当前采用简单的Hash算法加取余来分发数据）
    2. 数据在多节点上异步冗余存储。（防止数据丢失最基本要求）
    3. 节点不可用切换功能。（当根据算法分发到某一失败节点时可以转向到其他可用节点）
    4. 节点恢复可用后数据Lazy复制。（当A,B两台机器作为集群的时候，如果A出现了问题，系统会去B获取数据，当A正常以后，如果应用在A中没有拿到数据可以去B获取数据，并且复制到A上，这种方式也是一种lazy的复制。）
    1. 集群代码
/**
 *
 */
package com.alisoft.xplatform.asf.cache;

import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;

import com.alisoft.xplatform.asf.cache.memcached.CacheUtil;
import com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;

/**
 * 集群测试类
 * @author wenchu.cenwc
 *
 */
public class MemcachedClusterTest {

    static ICacheManager<IMemcachedCache> manager;

    /**
     * @throws java.lang.Exception
     */
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        manager = CacheUtil.getCacheManager(IMemcachedCache.class, MemcachedCacheManager.class.getName());
        manager.setConfigFile("memcached_cluster.xml");
        manager.start();
    }

    /**
     * @throws java.lang.Exception
     */
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        manager.stop();
    }

    @Test
    public void testActiveMode() {
        try {
            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失效(结束服务端)，有出错日志在控制台打印
            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");

            Assert.assertEquals(cache2.get("key1"), "value1");
            Assert.assertEquals(cache2.get("key2"), "value2");
            Assert.assertEquals(cache2.get("key3"), "value3");
            Assert.assertEquals(cache2.get("key4"), "value4");
            Assert.assertEquals(cache2.get("key5"), "value5");
            Assert.assertEquals(cache2.get("key6"), "value6");

            // 恢复mclient1，无出错日志在控制台打印
            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");

            Assert.assertEquals(cache2.get("key1"), "value1");
            Assert.assertEquals(cache2.get("key2"), "value2");
            Assert.assertEquals(cache2.get("key3"), "value3");
            Assert.assertEquals(cache2.get("key4"), "value4");
            Assert.assertEquals(cache2.get("key5"), "value5");
            Assert.assertEquals(cache2.get("key6"), "value6");

        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    @Test
    @Ignore
    public void testStandByMode() {
        IMemcachedCache cache1 = manager.getCache("mclient3");
        IMemcachedCache cache2 = manager.getCache("mclient4");

        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失效(结束服务端)，有出错日志在控制台打印
        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");

        Assert.assertEquals(cache2.get("key1"), "value1");
        Assert.assertEquals(cache2.get("key2"), "value2");
        Assert.assertEquals(cache2.get("key3"), "value3");
        Assert.assertEquals(cache2.get("key4"), "value4");
        Assert.assertEquals(cache2.get("key5"), "value5");
        Assert.assertEquals(cache2.get("key6"), "value6");

        // 恢复mclient1，无出错日志在控制台打印
        Assert.assertNull(cache1.get("key1"));
        Assert.assertEquals(cache1.get("key2"), "value2");
        Assert.assertNull(cache1.get("key3"));
        Assert.assertEquals(cache1.get("key4"), "value4");
        Assert.assertNull(cache1.get("key5"));
        Assert.assertEquals(cache1.get("key6"), "value6");

        Assert.assertNull(cache2.get("key1"));
        Assert.assertEquals(cache2.get("key2"), "value2");
        Assert.assertNull(cache2.get("key3"));
        Assert.assertEquals(cache2.get("key4"), "value4");
        Assert.assertNull(cache2.get("key5"));
        Assert.assertEquals(cache2.get("key6"), "value6");
    }

    /**
     * 集群复制
     *
     */
    @Test
    public void testClusterCopy() {
        try {
            IMemcachedCache cache = manager.getCache("mclient");
            IMemcachedCache cache1 = manager.getCache("mclient1");
            IMemcachedCache cache2 = manager.getCache("mclient2");

            cache.put("key1", "value1");
            cache.put("key2", "value2");
            cache.put("key3", "value3");
            cache.put("key4", "value4");
            cache.put("key5", "value5");
            cache.put("key6", "value6");

            cache1.remove("key1");
            cache1.remove("key2");
            cache1.remove("key3");
            cache1.remove("key4");
            cache1.remove("key5");
            cache1.remove("key6");

            cache2.remove("key1");
            cache2.remove("key2");
            cache2.remove("key3");
            cache2.remove("key4");
            cache2.remove("key5");
            cache2.remove("key6");

            manager.clusterCopy("mclient", "cluster1");

            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");

            Assert.assertEquals(cache2.get("key1"), "value1");
            Assert.assertEquals(cache2.get("key2"), "value2");
            Assert.assertEquals(cache2.get("key3"), "value3");
            Assert.assertEquals(cache2.get("key4"), "value4");
            Assert.assertEquals(cache2.get("key5"), "value5");
            Assert.assertEquals(cache2.get("key6"), "value6");

        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

    @Test
    public void testReload() {
        try {
            IMemcachedCache cache = manager.getCache("mclient");
            IMemcachedCache cache1 = manager.getCache("mclient1");
            IMemcachedCache cache2 = manager.getCache("mclient2");
            IMemcachedCache cache5 = manager.getCache("mclient5");
            IMemcachedCache cache6 = manager.getCache("mclient6");

            Assert.assertNull(cache5);
            Assert.assertNull(cache6);

            cache.clear();
            Thread.sleep(1000);
            cache1.clear();
            Thread.sleep(1000);
            cache2.clear();
            Thread.sleep(1000);

            cache.put("key1", "1");
            cache1.put("key2", "2");

            Assert.assertNull(cache.get("key2"));
            Assert.assertNull(cache1.get("key1"));

            Thread.sleep(2000);

            // manager.reload("http://10.2.226.41/sip/memcached_cluster2.xml");
            manager.reload("memcached_cluster2.xml");

            Thread.sleep(2000);

            cache1 = manager.getCache("mclient1");
            cache2 = manager.getCache("mclient2");
            cache5 = manager.getCache("mclient5");
            cache6 = manager.getCache("mclient6");

            Assert.assertNull(cache1);
            Assert.assertNull(cache2);
            Assert.assertNotNull(cache5);
            Assert.assertNotNull(cache6);

            cache5.clear();
            Thread.sleep(1000);
            cache6.clear();
            Thread.sleep(3000);

            manager.reload("memcached_cluster3.xml");

            Thread.sleep(2000);

            cache = manager.getCache("mclient");
            cache1 = manager.getCache("mclient1");
            cache2 = manager.getCache("mclient2");
            cache5 = manager.getCache("mclient5");
            cache6 = manager.getCache("mclient6");

            Assert.assertEquals(cache.get("key2"), "2");
            Assert.assertEquals(cache1.get("key1"), "1");

            Assert.assertEquals(cache2.get("key2"), "2");
            Assert.assertEquals(cache5.get("key2"), "2");
            Assert.assertNull(cache2.get("key1"));
            Assert.assertNull(cache5.get("key1"));
            Assert.assertNull(cache6.get("key1"));
            Assert.assertNull(cache6.get("key2"));

        } catch (Exception ex) {
            ex.printStackTrace();
            Assert.assertTrue(false);
        }
    }

}
时间： 2024-10-12 19:49:57

memcached缓存的相关文章

部署网站运行平台LNMP + Memcached缓存

部署网站运行平台LNMP + Memcached缓存  *本实验的LNMP和Memcached都安装在同一台服务器上 *Nginx   提供网站服务 *MySQL   提供数据库服务 *PHP    提供动态网站编程语言 *Memcached 提供数据缓存(通过降低对Database的访问来加速web应用程序) 一.搭建LNMP平台(源码包安装) Linux+Nginx+Mysql+PHP(perl) 1)基本环境准备 安装"开发工具"和"开发库""Dev

应对Memcached缓存失效，导致高并发查询DB的几种思路

原文地址: http://blog.csdn.net/hengyunabc/article/details/20735701 当Memcached缓存失效时,容易出现高并发的查询DB,导致DB压力骤然上升. 这篇blog主要是探讨如何在缓存将要失效时,及时地更新缓存,而不是如何在缓存失效之后,如何防止高并发的DB查询. 个人认为,当缓存将要失效时,及时地把新的数据刷到memcached里,这个是解决缓存失效瞬间高并发查DB的最好方法.那么如何及时地知道缓存将要失效? 解决这个问题有几种思路: 比

Java MemCached 缓存实现

首先创建MemCached 缓存管理类,此代码测试需要添加 java_memcached-release_2.6.3.jar,commons-pool-1.5.6.jar,slf4j-api-1.6.1.jar,slf4j-simple-1.6.1.jar 这几个jar包 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

Memcached缓存框架

开发基于BS模式的程序,都有报表模块,那么如何开发报表模块. 1.定时发布报表数据到指定的临时表(可能是定时任务) 2.用户通过HTTP请求后台,访问临时表,查询报表数据 3.增加memcached缓存,再次访问是直接访问缓存. memcached原理:基于内存的缓存分布式系统,基于libevent(epoll)或者的事件机制,保证非阻塞的网络IO,内部数据结构采取链表,Hash索引.内存管理图:分配的内存分割成各种尺寸的块(chunk), 并把尺寸相同的块分成组(chunk的集合) memca

memcached学习笔记5--socke操作memcached 缓存系统

使用条件:当我们没有权限或者不能使用服务器的时候,我们需要用socket操作memcached memcached-client操作 特点: 无需开启memcache扩展 使用fsocketopen()套接字连接memcached 同样执行CRUD require_once(CLASS_PATH.'memcached-client.php');//CLASS_PATH 是我定义的类文件文件夹路径 $mc = new memcached( array( 'servers' => array( '1

受教了，memcache比较全面点的介绍，受益匪浅,适用memcached的业务场景有哪些？memcached的cache机制是怎样的？在设计应用时，可以通过Memcached缓存那些内容？

基本问题 1.memcached的基本设置 1)启动Memcache的服务器端 # /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid -d选项是启动一个守护进程, -m是分配给Memcache使用的内存数量,单位是MB,我这里是10MB, -u是运行Memcache的用户,我这里是root, -l是监听的服务器IP地址,如果有多个地址的话,我这里指定了服

Memcached 缓存用法实例

本文实例讲述了C#中Memcached缓存的用法,分享给大家供大家参考.具体方法如下: ICacheStrategy.cs文件如下: 复制代码 代码如下: public interface ICacheStrategy {         /// <summary>         /// 添加数据到缓存         /// </summary>         /// <param name="objId">缓存名称</param>

memcached 缓存服务器

Memcached 缓存服务器 Memcached 是高性能的分布式内存缓存服务器. 一般的使用目的是,通过缓存数据库查询结果,减少数据库访问次数,以提高动态web应用的速度.提高可扩展性. 主要特点: 1.C/S架构,协议简单: 2.基于libevent的事件处理(epoll): 3.Slab Allocation内存管理机制: 4.基于客户端的分布式: Memcached中保存的数据都在内存中,因此重启memcached,会导致全部数据丢失: 另外,内存容量达到指定值之后,就基于LRU(Le

清除memcached缓存数据的方式

第一.连接:telnet 127.0.0.1 11211 第二.按回车键 第三.flush_all 后回车 控制台显示OK,表示操作成功 说明: 1.清空所有键值 flush_all 注:flush并不会将items删除,只是将所有的items标记为expired,因此这时memcache依旧占用所有内存. 2.退出 quit 清除memcached缓存数据的方式

nginx+tomact+memcached(缓存)集群

关于Nginx+tomcat+memcached(缓存)配置集群负载均衡的下载与安装流程: 实现的整体步骤 一:安装memcached.(memcached可以一个或者多个) 二:安装两个tomcat 三:配置msm. 四:安装nginx,实现负载均衡. 以下是详细步骤: 第一步:安装memcached 1.       下载memcached服务端memcached-1.2.6-win32-bin.zip,地址:csdn 第二步:安装tomcat 1.       安装两个tomcat6,如果