memcached 构建分布式缓存
分布式缓存设计
分布式缓存设计缓存是提高系统性能的关键组件之一，而分布式缓存则在分布式系统的环境下实现了数据的共享和高效访问。
本文将介绍分布式缓存的设计原理和实践，以及一些常见的分布式缓存方案。
一、缓存的作用缓存是将计算结果、数据库查询结果等常用数据存储在高速读写的存储介质中，以提高系统的性能和响应速度。
在分布式系统中，缓存的作用尤为重要，可以减轻后端数据库的压力，提高系统的可扩展性和可用性。
二、分布式缓存的设计原则1. 数据一致性：分布式缓存需要保证数据的一致性，即缓存中的数据和后端存储中的数据保持同步。
常见的解决方案包括使用缓存更新策略、缓存伪装技术等。
2. 高可用性：分布式缓存需要保证在各种异常情况下都能够正常工作，如节点故障、网络分区等。
常见的解决方案包括使用数据复制、故障检测与恢复机制等。
3. 高性能：分布式缓存需要具备快速读写的能力，以满足系统对高并发读写的需求。
常见的解决方案包括使用缓存预热、数据分片、分布式存储等。
4. 可扩展性：分布式缓存需要支持系统的水平扩展，以应对日益增长的数据访问需求。
常见的解决方案包括使用分布式哈希、一致性哈希等。
三、常见的分布式缓存方案1. Redis：Redis 是一个开源的高性能分布式缓存系统，支持多种数据结构和丰富的功能，如持久化、发布订阅、事务等。
它通过将数据存储在内存中，提供了非常快速的读写性能。
2. Memcached：Memcached 是一个免费的、高性能的分布式内存对象缓存系统，适用于访问模式相对简单的场景。
它通过缓存的方式，将数据存储在内存中，从而提供快速的数据访问速度。
3. Hazelcast：Hazelcast 是一个开源的分布式缓存和计算平台，支持多种数据结构和分布式计算模型。
它可以无缝地集成到 Java 应用中，提供快速的数据访问和计算能力。
四、分布式缓存的设计实践1. 数据划分：根据业务需求和数据访问特点，将数据划分到不同的缓存节点中。
可以采用按数据分片方式，将数据均匀地分布在不同的节点上，提高并发读写能力。
Memcache分布式内存缓存系统
Memcache是什么？memcached是高性能的，分布式的内存对象缓存系统，用于在动态应用中减少数据库教程负载，提升访问速度。
Memcache是的一个项目，目前全世界不少人使用这个缓存项目来构建自己大负载的网站，来分担数据库的压力。
它可以应对任意多个连接，使用非阻塞的网络IO。
由于它的工作机制是在内存中开辟一块空间，然后建立一个HashTable，Memcached自管理这些HashTable。
Memcache官方网站：/memcached，更多详细的信息可以来这里了解关于Memcache和memcached其实应该说这不是个问题，但网上有很多地方用着这两个不同的单词。
Memcache是这个项目的名称，Memcached是这个项目的主程序的文件名，就这么简单。
工作原理：首先 memcached 是以守护程序方式运行于一个或多个服务器中，随时接受客户端的连接操作，客户端可以由各种语言编写，目前已知的客户端 API 包括 Perl/PHP/Python/Ruby/Java/C#/C 等等。
客户端在与 memcached 服务建立连接之后，接下来的事情就是存取对象了，每个被存取的对象都有一个唯一的标识符 key，存取操作均通过这个 key 进行，保存到 memcached 中的对象实际上是放置内存中的，并不是保存在 cache 文件中的，这也是为什么 memcached 能够如此高效快速的原因。
注意，这些对象并不是持久的，服务停止之后，里边的数据就会丢失。
与许多 cache 工具类似，Memcached 的原理并不复杂。
它采用了C/S的模式，在 server 端启动服务进程，在启动时可以指定监听的 ip，自己的端口号，所使用的内存大小等几个关键参数。
一旦启动，服务就一直处于可用状态。
Memcached 的目前版本是通过C实现，采用了单进程，单线程，异步I/O，基于事件 (event_based) 的服务方式.使用 libevent 作为事件通知实现。
memcache_engine + memcachedb = 高性能分布式内存数据库
memcachedb是一个由新浪网的开发人员开放出来的开源项目，给memcached分布式缓存服务器添加了Berkeley DB的持久化存储机制和异步主辅复制机制，让memcached具备了事务恢复能力、持久化能力和分布式复制能力，非常适合于需要超高性能读写速度，但是不需要严格事务约束，能够被持久化保存的应用场景，例如memcachedb被应用在新浪博客上面。
memcachedb给memcached添加了一些数据库才具备的特性，但是我们还不能说memcachedb已经是一个数据库了，这是因为memcached不支持内存对象的遍历操作，当然更加不能支持复杂的查询操作，只能支持根据已知的key去查询对应的value。
因此如果想把memcachedb当成一个高性能的分布式内存数据库来使用的话，查询的问题就没有办法解决，只能在应用程序里面配合其他方案做一些折衷。
然而memcached的另外一个开源项目完美的填补了这一个缺陷，就是memcache_engine。
memcache_engine是一个MySQL数据库的存储引擎，目前只支持MySQL5.1数据库，他能够把memcachedb作为MySQL数据库的一个存储引擎和MySQL集成起来，让用户通过标准的SQL查询语句访问memcachedb中存放的数据，请看如下示例：CREATE TABLE `a` (`a` int(11) NOT NULL DEFAULT "0",`b` int(11) DEFAULT NULL,`c` int(11) DEFAULT NULL,PRIMARY KEY (`a`)) ENGINE=MEMCACHE DEFAULT CHARSET=latin1CONNECTION="localhost:6666;localhost:6688";创建表a，存放在分布式memcached server：localhost:6666和localhost:6688当中。
Memcached开源高性能分布式内存对象缓存系统教程说明书
About the T utorialMemcached is an open source, high-performance, distributed memory object caching system.This tutorial provides a basic understanding of all the relevant concepts of Memcached needed to create and deploy a highly scalable and performance-oriented system.AudienceThis tutorial is designed for software professionals who wish to learn and apply the concepts of Memcached in simple and easy steps.PrerequisitesBefore proceeding with this tutorial, you need to know the basics of data structures.Copyright & DisclaimerCopyright 2018 by Tutorials Point (I) Pvt. Ltd.All the content and graphics published in this e-book are the property of Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain, copy, distribute or republish any contents or a part of contents of this e-book in any manner without written consent of the publisher.We strive to update the contents of our website and tutorials as timely and as precisely as possible, however, the contents may contain inaccuracies or errors. Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy, timeliness or completeness of our website or its contents including this tutorial. If you discover any errors on our website or inthistutorial,******************************************T able of ContentsAbout the Tutorial (i)Audience (i)Prerequisites (i)Copyright & Disclaimer (i)Table of Contents (ii)PART 1 BASICS (1)1.Memcached ─ Overview (2)2.Memcached ─ Environment (3)Installing Memcached on Ubuntu (3)Memcached Java Environment Setup (3)3.Memcached ─ Connection (4)Connection from Java Application (4)PART 2 STORAGE COMMANDS (6)4.Memcached ─ Set Data (7)Set Data Using Java Application (8)5.Memc ached ─ Add Data (9)Add Data Using Java Application (10)6.Memcached ─ Replace Data (11)Replace Data Using Java Application (12)7.Memcached ─ Append Data (14)Append Data Using Java Application (15)8.Memcached ─ Prepend Data (17)Prepend Data Using Java Application (18)9.Memcached ─ CAS Command (20)CAS Using Java Application (21)PART 3 RETRIEVAL COMMANDS (23)10.Memcached ─ Get Data (24)Get Data Using Java Application (24)11.Memcached ─ Get CAS Data (26)Get CAS Data Using Java Application (26)12.Memcached ─ Delete Data (28)Delete Data Using Java Application (28)13.Memcached ─ Increment Decrement Data (30)Incr/Decr Using Java Application (31)PART 4 STATISTICAL COMMANDS (33)14.Memcached ─ Stats (34)Stats Using Java Application (35)15.Memcached ─ Stats Items (37)16.Memcached ─ Stats Slabs (38)17.Memcached ─ Stats Sizes (39)18.Memcached ─ Clear Data (40)Clear Data Using Java Application (40)MemcachedPart 1Basics4Memcached5Memcached is an open source, high-performance, distributed memory caching system intended to speed up dynamic web applications by reducing the database load. It is a key-value dictionary of strings, objects, etc., stored in the memory, resulting from database calls, API calls, or page rendering.Memcached was developed by Brad Fitzpatrick for LiveJournal in 2003. However, it is now being used by Netlog, Facebook, Flickr, Wikipedia, Twitter, and YouTube among others The key features of Memcached are as follows:∙ It is open source.∙ Memcached server is a big hash table. ∙ It significantly reduces the database load.∙ It is perfectly efficient for websites with high database load.∙ It is distributed under Berkeley Software Distribution (BSD) license. ∙It is a client-server application over TCP or UDP.Memcached is not:∙ a persistent data store ∙ a database∙ application-specific ∙ a large object cache∙ fault-tolerant or highly available1. Memcached ─ OverviewInstalling Memcached on UbuntuTo install Memcached on Ubuntu, go to terminal and type the following commands:$sudo apt-get update$sudo apt-get install memcachedConfirming Memcached InstallationTo confirm if Memcached is installed or not, you need to run the command given below. This command shows that Memcached is running on the default port11211.$ps aux | grep memcachedTo run Memcached server on a different port, execute the command given below. This command starts the server on the TCP port 11111 and listens on the UDP port 11111 as a daemon process.$memcached -p 11111 -U 11111 -dYou can run multiple instances of Memcached server through a single installation. Memcached Java Environment SetupTo use Memcached in your Java program, you need to download spymemcached-2.10.3.jar and setup this jar into the classpath.6To connect to a Memcached server, you need to use the telnet command on HOST and PORT names.SyntaxThe basic syntax of Memcached telnet command is as shown below:$telnet HOST PORTHere,HOST and PORT are machine IP and port number respectively, on which the Memcached server is executing.ExampleThe following example shows how to connect to a Memcached server and execute a simple set and get command. Assume that the Memcached server is running on host 127.0.0.1 and port 11211.$telnet 127.0.0.1 11211Trying 127.0.0.1...Connected to 127.0.0.1.Escape character is '^]'.// now store some data and get it from memcached serverset tutorialspoint 0 900 9memcachedSTOREDget tutorialspointVALUE tutorialspoint 0 9memcachedENDConnection from Java ApplicationTo connect the Memcached server from your java program, you need to add the Memcached jar into your classpath as shown in the previous chapter. Assume that the Memcached server is running on host 127.0.0.1 and port 11211.7MemcachedExampleimport net.spy.memcached.MemcachedClient;public class MemcachedJava {public static void main(String[] args) {// Connecting to Memcached server on localhostMemcachedClient mcc = new MemcachedClient(newInetSocketAddress("127.0.0.1", 11211));System.out.println("Connection to server sucessfully");//not set data into memcached serverSystem.out.println("set status:"+mcc.set("tutorialspoint", 900,"memcached").done);//Get value from cacheSystem.out.println("Get from Cache:"+mcc.get("tutorialspoint"));}}OutputOn compiling and executing the program, you get to see the following output:Connection to server successfullyset status:trueGet from Cache:memcached8MemcachedPart 2Storage Commands9Memcached 10Memcached set command is used to set a new value to a new or existing key. SyntaxThe basic syntax of Memcached set command is as shown below: set key flags exptime bytes [noreply]valueThe keywords in the syntax are as described below:∙ key: It is the name of the key by which data is stored and retrieved from Memcached. ∙flags: It is the 32-bit unsigned integer that the server stores with the data provided by the user, and returns along with the data when the item is retrieved. ∙exptime: It is the expiration time in seconds. 0 means no delay. If exptime is more than 30 days, Memcached uses it as UNIX timestamp for expiration. ∙bytes: It is the number of bytes in the data block that needs to be stored. This is the length of the data that needs to be stored in Memcached. ∙ noreply (optional): It is a parameter that informs the server not to send any reply. ∙ value: It is the data that needs to be stored. The data needs to be passed on the new line after executing the command with the above options.OutputThe output of the command is as shown below:STORED∙STORED indicates success. ∙ERROR indicates incorrect syntax or error while saving data.4. Memcached ─ Set DataMemcachedEnd of ebook previewIf you liked what you saw…Buy it from our store @ https://11。
MySQL分布式缓存和数据共享的实现方法
MySQL分布式缓存和数据共享的实现方法随着互联网应用的不断发展，越来越多的应用程序对于数据库读写的需求也越来越高，这对于数据库服务器的性能提出了更高的要求。
MySQL是一种常用的关系型数据库管理系统，但是在高并发读写的场景下，单个MySQL服务器可能无法满足需求。
为了提高数据库的性能和可扩展性，MySQL分布式缓存和数据共享成为了解决方案之一。
一、MySQL分布式缓存的概念和原理MySQL分布式缓存是指将数据缓存在分布式的缓存层中，减少对数据库的访问和负载。
常用的MySQL分布式缓存方案有Memcached和Redis。
1. MemcachedMemcached是一种内存缓存系统，它将数据存储在内存中，以键值对的方式进行访问。
当一个应用程序需要访问数据库时，可以首先尝试从Memcached中获取数据，如果缓存中存在，则直接返回缓存数据；如果缓存中不存在，则从数据库中查询数据，并将数据存储到缓存中，供下次使用。
2. RedisRedis也是一种内存缓存系统，和Memcached类似，但是Redis具有更丰富的数据结构和功能。
除了支持键值对的存储方式外，Redis还支持列表、集合、哈希等数据结构，并提供了各种操作这些数据结构的方法。
Redis的性能也比Memcached更好，但是占用的内存也更多。
二、MySQL数据共享的概念和原理MySQL数据共享是指多个MySQL服务器共同管理一份数据，实现数据库的读写分离和负载均衡。
常用的MySQL数据共享方案有主从复制和分片。
1. 主从复制主从复制是一种典型的MySQL数据共享方案，它通过复制主数据库上的数据到从数据库上实现数据共享。
主数据库负责写操作，而从数据库负责读操作。
当主数据库上的数据发生变化时，通过二进制日志的方式将变化的数据同步到从数据库上，保持数据的一致性。
这样一来，读操作可以分散到多个从数据库上，提高了数据库的读写并发性能。
2. 分片分片是将数据按照一定的规则划分为多个部分，分别存储在不同的MySQL服务器上。
Java分布式缓存使用Redis和Memcached进行缓存管理
Java分布式缓存使用Redis和Memcached进行缓存管理随着互联网应用的快速发展，对于高并发请求的支持成为了一个重要的挑战。
为了提高应用程序的性能和稳定性，缓存是一种常见的解决方案。
本文将介绍如何通过使用Redis和Memcached 进行缓存管理来实现Java分布式缓存。
一、Redis缓存管理Redis是一个开源的内存键值数据库，它支持持久化、集群和事务等特性，非常适合用作缓存存储。
下面是一个使用Redis进行缓存管理的示例代码：1. 引入Redis客户端依赖在pom.xml文件中添加以下依赖项：```<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.10.2</version></dependency>```2. 初始化Redis连接池在应用程序启动时，初始化Redis连接池并创建一个Redis连接对象。
以下是示例代码：```JedisPool redisPool = new JedisPool("localhost", 6379);Jedis jedis = redisPool.getResource();```3. 设置和获取缓存数据使用Redis进行缓存管理时，可以使用set和get方法来设置和获取缓存数据。
以下是示例代码：```// 设置缓存数据jedis.set("key", "value");// 获取缓存数据String value = jedis.get("key");```4. 缓存失效设置为了避免缓存数据过期而导致的脏数据访问问题，可以为每个缓存数据设置一个失效时间。
以下是示例代码：```// 设置缓存数据，并设置失效时间为60秒jedis.setex("key", 60, "value");```二、Memcached缓存管理Memcached是一个高性能的分布式内存对象缓存系统，它以键值对的形式存储数据，并且可以通过哈希算法将数据分布到多个节点上。
Memcached分布式缓存简介
一.什么是MemcachedMemcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。
它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提供动态、数据库驱动网站的速度。
相信很多人都用过缓存，在.net 中也有内置的缓存机制，还有很多第三方工具如apache，nginx等可以做静态资源的缓存，同时我们也可以制定自己的缓存机制，缓存数据库查询的数据以减少对数据库的频繁操作。
但是很多时候我们总是感觉这些缓存总不尽人意，Memcached可以解决你不少的烦恼问题。
最少在我的学习中解决了我不少问题，所以决定记录下来分享。
Memcached基于一个存储键/值对的hashmap。
其守护进程是用C写的，但是客户端可以用任何语言来编写(本文使用C#作为例子)，并通过memcached协议与守护进程通信。
可能这些东西都太高深了，我们暂不做研究。
二.分布式缓存其实 Memcached作为一个分布式缓存数据服务，但是每个服务之间根本没有进行相互通信，这里可能与我理解的分布式有点区别，可能是我才疏学浅，也可能是每个人思考问题的角度不同。
Memcached 客户端就是通过一种分布式算法将数据保存到不同的Memcached服务器上，将数据进行缓存。
分布式缓存，可以而知memcached可以进行大数据量的缓存。
这点可以弥补我们之前很多人都遇到的将数据缓存到应用服务器上，而且只能缓存少量数据，否则对应用服务器的影响非常大。
Memcached应用机制图:这个图是有点简陋了，但是问题还是能够描述的清楚的，缓存机制的基本原理就是先查询数据保存到memcached中，地址在此请求就直接从Memcached缓存中取数据，这样就可以减少对服务器请求压力。
三.Memcached 特征(1)协议简单: 不使用复杂的xml格式，而是使用文本格式(2)基于libevent的事件处理机制 (不懂)(3)内置内存存储方式: 数据存在在内存中，所以重启机器会导致数据丢失（4）Memcached相互不通信的分布式: Memcached 服务器之间不会进行通信，数据都是通过客户端的分布式算法存储到各个服务器中四.Memcached的安装首先这里是在windows系统上做测试，Memcached在linux等非windows平台上性能会更高。
天翼云分布式缓存服务Memcache介绍
天翼云分布式缓存服务Memcache介绍MemCache是一套高性能分布式的高速缓存系统，用于动态Web应用以减轻数据库负载，由LiveJournal的Brad Fitzpatrick开发。
目前被许多网站使用以提升网站的访问速度，尤其对于一些大型的、需要频繁访问数据库的网站访问速度提升效果十分显著。
这是一套开放源代码软件，以BSD license授权发布。
MemCache通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高了网站访问的速度。
MemCache是一个存储键值对的HashMap，在内存中对任意的数据(比如字符串、对象等)所使用的key-value存储，数据可以来自数据库调用、API调用，或者页面渲染的结果。
MemCache设计理念就是小而强大，它简单的设计促进了快速部署、易于开发并解决面对大规模的数据缓存的许多难题，而所开放的API使得MemCache能用于Java、C/C++/C#、Perl、Python、PHP、Ruby等大部分流行的程序语言。
MemCache工作原理MemCache采用C/S架构，在服务器端启动后，以守护程序的方式，监听客户端的请求。
启动时可以指定监听的IP(服务器的内网ip/外网ip)、端口号(所以做分布式测试时，一台服务器上可以启动多个不同端口号的MemCached进程)、使用的内存大小等关键参数。
一旦启动，服务就会一直处于可用状态。
为了提高性能，MemCache缓存的数据全部存储在MemCache 管理的内存中，所以重启服务器之后缓存数据会清空，不支持持久化。
MemCache内存管理内存结构每个slab_class里面包含若干个slab。
每个slab里面包含若干个page，page的默认大小是1M。
每个page里面包含若干个chunk，chunk是数据的实际存放单位，每个slab 里面的chunk大小相同内存分配方式Memcached使用slab allocation机制来分配和管理内存。
Memcached分布式缓存系统的应用
在 Ｍｅ ｍｃ ａ ｃ ｈ ｅ ｄ缓存系统 中，服务器和客户端使用 简单 的基于 文本行的协议通 信 ，提供 了多种方式从 服务 器 ｉ 获 取数据 ． ， ２ ． ２ 基于 Ｋ ｅ ｙ — Ｖ ａ ｌ ｕ ｅ的数据管理
个独立的机制 ．已经不能适用分 布式环境 ，引入 分布式缓
存机制是大势所趋 ，分布式缓能够横跨 多个服务器，能够在 处理能力上进行扩展。由于现在内存价格越来越低 ，网卡速 度 越来越快和节点服务器配置要求 不高 ，这些为分布式缓存 系统 的应用提供 了条件。分布式缓存很 容易进行扩展 ，虽然
２ ． １ 协 议 简 单
为硬盘读 取速度慢 ，限制了系统整体性能的提高 。单机引
入Ｃ ａ ｃ ｈ ｅ为用户和数据库之间增加 了一级缓存机制 ，经常访
问的数据可 以常驻 内存缓存 区，大大提高 了数据库查 询效
率 但 现 在 的 环境 是 多服 务 器 、多处 理 器 ，原 有 的 Ｃ ａ ｃ ｈ ｅ 是
Ｍｅ ｍ ｃ ａ ｅ ｈ ｅ ｄ是一 个高性 能的分布式 内存对象缓存 系统 ，
可以用来缓存 数据 ，如果没有它 ，就必须 从数据库 中获取 数据 ，加重数据库的负担 。Ｍｅ ｍ ｃ ａ ｃ ｈ ｅ ｄ 是一个开源的数据库
给 多个 服 务 器 分 配 了 数据 ．但 对 用 户来 说 是 透 明 的 ，用 户就
在 实际应用 时 ，Ｍｅ ｍ ｃ ａ ｃ ｈ ｅ ｄ以守护进程驻 留服 务器 内 存 ，等待客 户端 的连接 。当客户端和服务 器通信 时 ，客户
端首先和服务器建立连接 。后存取数据。存取数据的每条记 录都有一个 唯一 Ｋ ｅ ｙ 值 ，对数据的操作都基于这个 Ｋ ｅ ｙ 值。
…
…
memcached工作原理
memcached工作原理
memcached是一款高性能的分布式内存缓存系统，主要用于减轻数据库负载，提高应用程序的性能。
其工作原理如下：
1. 客户端向memcached服务器发送请求，请求可以是获取或设置缓存数据。
2. 如果请求是获取缓存数据，memcached服务器首先检查是否有该数据的缓存副本，如果有，则返回该数据给客户端。
3. 如果请求是设置缓存数据，memcached服务器将数据存储到其内存中，并设置相应的索引。
4. 当memcached服务器的内存空间不足时，会采用LRU（最近最少使用）算法将一些旧的缓存数据删除，以腾出更多的内存空间。
5. 当多个memcached服务器组成一个分布式缓存集群时，客户端需要通过一致性哈希算法来选择具体的服务器，以保证缓存数据的一致性。
6. 当客户端对缓存数据进行修改时，需要同时更新所有memcached服务器上的缓存数据，以保证数据一致性。
总之，memcached工作原理简单、高效，可以提高应用程序的响应速度和吞吐
量，同时减少数据库的负载。
memcache,redis分布式缓存详解
memcache,redis分布式缓存详解本答应⼤家这⼀篇⽂章讲解AutoMapper，但是为了满⾜旁边同事⼩法师的强烈要求，就先写⼀篇关于分布式缓存的⽂章吧。
⼀、问题⼀：为什么要有分布式缓存？什么时候⽤分布式缓存？答：举个例⼦，当你的⽹站随着业务的扩⼤，访问量会很⼤，很有可能在同⼀时间有⼏个⼈，共同操作⼀条数据，但是数据库锁机制，有可能会造成死锁，简单点就是服务器卡死，宕机（cpu 100%）！先普及⼀下数据库锁机制：select * from table1//此时会给这个表加上S锁（共享锁）update table1 set colum="somedata"//此时给table1加上X锁T1:begin transelect * from table (holdlock) (holdlock意思是加共享锁，直到事物结束才释放)update table set column1='hello'T2:begin transelect * from table(holdlock)update table set column1='world'假设T1和T2同时达到select，T1对table加共享锁，T2也对加共享锁，当T1的select执⾏完，准备执⾏update时，根据锁机制，T1的共享锁需要升级到排他锁才能执⾏接下来的update.在升级排他锁前，必须等table上的其它共享锁释放，但因为holdlock这样的共享锁只有等事务结束后才释放，所以因为T2的共享锁不释放⽽导致T1等(等T2释放共享锁，⾃⼰好升级成排他锁），同理，也因为T1的共享锁不释放⽽导致T2等。
死锁产⽣了。
⼀个表上可以有很多个s锁，但是⼀个表上只会有⼀个X锁存在，也就是说，在Update的时候这条数据只能被⼀个⽤户使⽤，别⼈是⽆法查询或者修改的。
随着访问量的增⼤，并发⼏率就会增⾼，所谓并发就是同意时间操作同⼀个数据。
Discuz!NT中集成Memcached分布式缓存
大约在两年前我写过一篇关于Discuz!NT缓存架构的文章，在那篇文章的结尾介绍了在IIS中如果开启多个应用程序池会造成多个缓存实例之间数据同步的问题。
虽然给出了一个解决方案，但无形中却把压力转移到了磁盘I/O上（多个进程并发访问cache.config文件）。
其实从那时起我就开始关注有什么更好的方案，当然今天本文中所说的Memcached，以及Velocity等这类的分布式缓存方案之前都考虑过，但一直未能决定该使用那个。
起码Velocity要在.net 4.0之后才会提供，虽然是原生态，但有些远水解不了近火。
我想真正等到Velocity能堪当重任还要等上一段时间。
于是我就开始将注意力转移到了Memcached,必定有Facebook这只“超级小白鼠”使用它并且反响还不错。
所以就开始尝试动手在产品中集成Memcached。
其实在之前的那篇关于Discuz!NT缓存架构的文章中已提到过，使用了设计模式中的“策略模式”来构造。
所以为了与以往使用缓存的代码格式相兼容，所以这里采用新添加MemCachedStrategy(MemCached策略)来构造一个缓存策略类以便于当管理后台开启“MemCached”时以“MemCached策略模式”来做为当前系统默认的策略模式。
其代码段如下（Discuz.Cache/MemCached.cs）：///<summary>/// MemCache缓存策略类///</summary>public class MemCachedStrategy : Discuz.Cache.ICacheStrategy{///<summary>///添加指定ID的对象///</summary>///<param name="objId"></param>///<param name="o"></param>public void AddObject(string objId, object o){RemoveObject(objId);if (TimeOut > 0){MemCachedManager.CacheClient.Set(objId, o, System.DateTim e.Now.AddMinutes(TimeOut));}else{MemCachedManager.CacheClient.Set(objId, o);}}///<summary>///添加指定ID的对象(关联指定文件组)///</summary>///<param name="objId"></param>///<param name="o"></param>///<param name="files"></param>public void AddObjectWithFileChange(string objId, object o, strin g[] files){;}///<summary>///添加指定ID的对象(关联指定键值组)///</summary>///<param name="objId"></param>///<param name="o"></param>///<param name="dependKey"></param>public void AddObjectWithDepend(string objId, object o, string [] dependKey){;}///<summary>///移除指定ID的对象///</summary>///<param name="objId"></param>public void RemoveObject(string objId){if (MemCachedManager.CacheClient.KeyExists(objId))MemCachedManager.CacheClient.Delete(objId);}///<summary>///返回指定ID的对象///</summary>///<param name="objId"></param>///<returns></returns>public object RetrieveObject(string objId){return MemCachedManager.CacheClient.Get(objId); }///<summary>///到期时间///</summary>public int TimeOut { set; get; }}上面类实现的接口Discuz.Cache.ICacheStrategy定义如下：///<summary>///公共缓存策略接口///</summary>public interface ICacheStrategy{///<summary>///添加指定ID的对象///</summary>///<param name="objId"></param>///<param name="o"></param>void AddObject(string objId, object o);///<summary>///添加指定ID的对象(关联指定文件组)///</summary>///<param name="objId"></param>///<param name="o"></param>///<param name="files"></param>void AddObjectWithFileChange(string objId, object o, string[] fi les);///<summary>///添加指定ID的对象(关联指定键值组)///</summary>///<param name="objId"></param>///<param name="o"></param>///<param name="dependKey"></param>void AddObjectWithDepend(string objId, object o, string[] depend Key);///<summary>///移除指定ID的对象///</summary>///<param name="objId"></param>void RemoveObject(string objId);///<summary>///返回指定ID的对象///</summary>///<param name="objId"></param>///<returns></returns>object RetrieveObject(string objId);///<summary>///到期时间///</summary>int TimeOut { set;get;}}当然在MemCachedStrategy类中还有一个对象要加以说明，就是MemCachedManager，该类主要是对Memcached一些常操作和相关初始化实例调用的“封装”，下面是是其变量定义和初始化构造方法的代码：///<summary>/// MemCache管理操作类///</summary>public sealed class MemCachedManager{#region静态方法和属性private static MemcachedClient mc = null;private static SockIOPool pool = null;private static MemCachedConfigInfo memCachedConfigInfo = MemCache dConfigs.GetConfig();private static string [] serverList = null;static MemCachedManager(){CreateManager();}private static void CreateManager(){serverList = Utils.SplitString(memCachedConfigInfo.ServerLis t, ""r"n");pool = SockIOPool.GetInstance(memCachedConfigInfo.PoolName); pool.SetServers(serverList);pool.InitConnections = memCachedConfigInfo.IntConnections;//初始化链接数pool.MinConnections = memCachedConfigInfo.MinConnections;//最少链接数pool.MaxConnections = memCachedConfigInfo.MaxConnections;//最大连接数pool.SocketConnectTimeout = memCachedConfigInfo.SocketConnect Timeout;//Socket链接超时时间pool.SocketTimeout = memCachedConfigInfo.SocketTimeout;// Soc ket超时时间pool.MaintenanceSleep = memCachedConfigInfo.MaintenanceSleep; //维护线程休息时间pool.Failover = memCachedConfigInfo.FailOver; //失效转移(一种备份操作模式)pool.Nagle = memCachedConfigInfo.Nagle;//是否用nagle算法启动so cketpool.HashingAlgorithm = HashingAlgorithm.NewCompatibleHash; pool.Initialize();mc = new MemcachedClient();mc.PoolName = memCachedConfigInfo.PoolName; mc.EnableCompression = false;}///<summary>///缓存服务器地址列表///</summary>public static string[] ServerList{set{if (value != null)serverList = value;}get { return serverList; }}///<summary>///客户端缓存操作对象///</summary>public static MemcachedClient CacheClient{get{if (mc == null)CreateManager();return mc;}}public static void Dispose(){if (pool != null)pool.Shutdown();}上面代码中构造方法会初始化一个池来管理执行Socket链接，并提供静态属性CacheClient以便MemCachedStrategy来调用。
分布式缓存解决方案
分布式缓存解决方案随着互联网应用的发展和用户量的激增，对系统性能和响应速度的要求也越来越高。
而分布式缓存作为一种常见的解决方案，在提升系统性能方面发挥着重要的作用。
本文将介绍什么是分布式缓存以及常见的分布式缓存解决方案。
一、什么是分布式缓存分布式缓存是指将缓存数据存储和处理分布在多台计算机节点上，通过统一的接口对外提供缓存服务。
相比于单机缓存，分布式缓存具有多台节点可扩展性好、容错性强的优点，能够有效提高系统的性能和可用性。
二、常见的分布式缓存解决方案1. MemcachedMemcached是一种广泛应用、轻量级的开源分布式缓存解决方案。
它采用内存存储数据，通过哈希分区将数据分布在多台服务器上，实现数据的快速读写。
Memcached具有高性能、简单易用的特点，适用于缓存热点数据、加速数据库访问等场景。
2. RedisRedis是一种高性能、高可用的开源分布式缓存和存储系统。
它支持丰富的数据结构和功能，如字符串、哈希表、列表、集合、有序集合等，并提供了多种持久化方式。
Redis通过主从复制和分片等机制实现数据的高可用和水平扩展。
它适用于缓存、消息队列、分布式锁等场景。
3. HazelcastHazelcast是一种基于Java的开源分布式数据存储和计算平台，其中包含了分布式缓存功能。
它提供了分布式数据结构和分布式计算接口，支持多种数据模型，如Map、List、Set、Queue等。
Hazelcast具有良好的可扩展性和可靠性，适用于分布式计算、缓存共享等场景。
4. CouchbaseCouchbase是一种面向文档的分布式数据库，但也提供了内置的缓存功能。
它采用Memcached协议和Redis协议实现缓存功能，并支持多数据中心复制、跨数据中心同步等高级特性。
Couchbase具有高可用、高性能、水平扩展的优点，适用于大规模数据存储和缓存的场景。
三、如何选择分布式缓存解决方案在选择分布式缓存解决方案时，需要考虑以下几个方面的因素：1. 需求场景：根据具体的业务需求，选择适合的分布式缓存解决方案。
java分布式方案
Java分布式方案概述随着互联网的快速发展，大规模分布式系统的需求日益增加。
Java作为一种广泛应用于分布式系统开发的编程语言，具有良好的可扩展性和易于维护的特点。
本文将介绍一些常见的Java分布式方案，包括分布式缓存、分布式消息队列和分布式计算等技术。
分布式缓存什么是分布式缓存分布式缓存是一种将缓存数据存储在多台服务器上的技术，通过提高缓存的命中率和可用性来加速系统的访问速度。
常见的分布式缓存解决方案有Redis和Memcached。
RedisRedis是一个高性能的键值存储系统，支持多种数据结构，如字符串、列表、哈希、有序集合等。
它通过将数据存储在内存中，以提供快速的读写访问速度。
Redis提供了分布式功能，可以将数据在多个节点上进行分片存储，以实现高可用性和横向扩展。
1. 通过Redis Cluster模式来搭建分布式缓存集群。
Redis Cluster将数据分片存储在多个节点上，每个节点负责一部分数据的读写操作，实现了数据的分布式存储与负载均衡。
2. 利用Redis的发布订阅机制来构建分布式缓存解决方案。
应用程序可以通过订阅某个特定的频道来实时接收其他节点发送的缓存更新消息，从而保持多个节点之间的缓存一致性。
MemcachedMemcached是一个开源的分布式内存对象缓存系统，也是一种键值存储系统，用于减轻数据库负载和提高网站性能。
Memcached将缓存数据存储在内存中，通过使用哈希算法和一致性哈希算法将数据分片存储在多台服务器上。
1. 通过配置Memcached服务器的分布式集群来构建分布式缓存系统。
应用程序可以通过客户端库连接多个Memcached节点，实现数据的分布式存储和访问。
2. 可以使用Memcached的CAS（Check And Set）协议来实现缓存的分布式锁。
CAS协议允许多个节点同时对缓存进行写入操作，通过比较缓存数据的版本信息来判断是否有其他节点并发操作。
分布式消息队列什么是分布式消息队列分布式消息队列是一种通过将消息发送到队列中，实现不同系统或组件之间异步通信的技术。
分布式缓存系统Memcached入门指导
分布式缓存系统Memcached入门指导摘要：这篇Memcached入门介绍涵盖的主题包括安装、配置、memcached 客户机命令和评估缓存效率，主要讨论与 memcached 服务器的直接交互，其目的是为您提供监控memcahed 实例所需的工具。
首先介绍一下，memcached 是由 Danga Interactive 开发并使用 BSD 许可的一种通用的分布式内存缓存系统Memcached示意图（来自）Danga Interactive 开发 memcached 的目的是创建一个内存缓存系统来处理其网站 的巨大流量。
每天超过 2000 万的页面访问量给 LiveJournal 的数据库施加了巨大的压力，因此 Danga 的 Brad Fitzpatrick 便着手设计了 memcached。
memcached 不仅减少了网站数据库的负载，还成为如今世界上大多数高流量网站所使用的缓存解决方案。
本文首先全面概述memcached，然后指导您安装memcached 以及在开发环境中构建它。
我还将介绍 memcached 客户机命令（总共有 9 个）并展示如何在标准和高级 memcached 操作中使用它们。
最后，我将提供一些使用 memcached 命令测量缓存的性能和效率的技巧。
如何将 memcached 融入到您的环境中？在开始安装和使用 using memcached 之前，我们需要了解如何将 memcached 融入到您的环境中。
虽然在任何地方都可以使用 memcached，但我发现需要在数据库层中执行几个经常性查询时，memcached 往往能发挥最大的效用。
我经常会在数据库和应用服务器之间设置一系列 memcached 实例，并采用一种简单的模式来读取和写入这些服务器。
图 1 可以帮助您了解如何设置应用程序体系结构：图 1. 使用 memcached 的示例应用程序体系结构体系结构相当容易理解。
如何利用云中间件进行分布式缓存(一)
云中间件是一种基于云计算的技术，可以帮助开发者更好地管理和利用分布式系统资源。
在分布式系统中，缓存是一项关键的技术，它可以显著提升系统的性能和吞吐量。
本文将探讨如何利用云中间件进行分布式缓存，并介绍其中的一些经典案例。
一、云中间件简介云中间件作为云计算的支撑技术之一，是连接云平台和应用程序的桥梁。
通过云中间件，开发者可以在云平台上部署自己的应用程序，并实现资源的动态调度和管理。
在云中间件中最常见的一项功能就是分布式缓存，它通过将应用程序的数据存储在内存中，提高数据读写速度，减轻后端数据库的压力。
二、分布式缓存的原理在传统的单节点缓存中，数据存储在单台机器的内存中，而分布式缓存则将数据分布存储在多台机器的内存中，通过一致性哈希算法或其他分片算法将数据分布在不同的节点上。
当应用程序需要读取数据时，先通过缓存服务的接口查询缓存中是否存在相应的数据，如果有则直接返回给应用程序；如果没有，则从后端存储系统（如数据库）中读取数据，并将数据写入缓存中，以便下次查询时可以直接返回。
这样，就可以大幅提高系统的读取性能和吞吐量。
三、云中间件的分布式缓存案例1. RedisRedis是一个性能优秀的分布式缓存中间件，支持多种数据结构，并提供了丰富的命令集合。
通过使用Redis，开发者可以轻松地将数据存储在内存中，提高系统的读取响应速度。
同时，Redis还支持数据的持久化和集群部署，保证了数据的安全和高可用性。
2. MemcachedMemcached是另一种常用的分布式缓存中间件，具有高性能和低延迟的特点。
Memcached采用分布式内存存储方式，将数据存储在多台机器的内存中，并通过一致性哈希算法实现数据的分布式存储。
Memcached支持多种数据类型的存储，并提供了简单的键值对操作接口。
3. HazelcastHazelcast是一个开源的分布式数据网格系统，具有良好的可扩展性和高可用性。
Hazelcast的分布式缓存模块使用内存存储数据，并提供了多种数据结构和查询方式。
分布式缓存
分布式缓存（memcached）】memcached是一个用C语言开发的分布式的缓存，内部基于类似hashMap的结构。
它的优点是协议简单，内置内存存储，并且他的分布式算法是在客户端完成的，不需要服务器端进行通信了解(不必主动说，但别人问的话一定要知道)memcached是以KEY-VALUE的方式进行数据存储的，KEY的大小限制：Key（max）<=250个字符；VALUE在存储时有限制：Value（max）<= 1M；根据最近最少使用原则删除对象即LRU.memcached默认过期时间：ExpiresTime（max）= 30（days）Memcached是通过hash一致性的算法完成数据的存取的.Memcached在存储自定义对象时候需要序列化即实现Serializable接口Memcache + cookie 来模拟session：用户登录成功后，将生成一个唯一的uuid，用此uuid做为memcached中的key，用户登录后获取的用户信息充当value，将其缓存时间设置为30分钟（默认为30天），并且将生成的uuid做为cookie缓存到客户端，当客户再次登录时，获取对应的cookie的值，用这个值来做为memcached的key，从而获取所对应的用户信息，如果该用户信息为空，则证明用户没有登录，跳转到登录页面让用户重新登录，如果不为空，则证明用户已经成功登录，则直接跳转到对应的后台页面，并且将这些判断逻辑都写在filter中，避免造成冗余代码，影响整个程序的结构融入自学redis的过程Redis是一个key-value存储系统，和memcached一样，为了保证效率，数据都是缓存在内存中，但是redis支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型) 这些数据类型都支持push/pop，add/remove及取交集并集差集及更丰富的操作，而且这些操作都是原子性的，此外redis支持各种不同方式的排序，而且会周期性的把更新的数据写入磁盘，或者把修改操作写入追加的记录文件（支持持久化），并且在此基础上实现了master-slave（主从）同步。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Memcached
什么是Memcached
许多Web 应用程序都将数据保存到RDBMS中，应用服务器从中读取数据并在浏览器中显示。
但随着数据量的增大，访问的集中，就会出现REBMS的负担加重，数据库响应恶化，网站显示延迟等重大影响。
Memcached是高性能的分布式内存缓存服务器。
一般的使用目的是通过缓存数据库查询结果，减少数据库的访问次数，以提高动态Web 应用的速度、提高扩展性。
如图：
Memcached的特点：
Memcached作为高速运行的分布式缓存服务器具有以下特点。
1.协议简单：memcached的服务器客户端通信并不使用复杂的MXL等格式，
而是使用简单的基于文本的协议。
2.基于libevent的事件处理：libevent是个程序库，他将Linux 的epoll、BSD
类操作系统的kqueue等时间处理功能封装成统一的接口。
memcached使
用这个libevent库，因此能在Linux、BSD、Solaris等操作系统上发挥其高
性能。
3.内置内存存储方式：为了提高性能，memcached中保存的数据都存储在
memcached内置的内存存储空间中。
由于数据仅存在于内存中，因此重
启memcached，重启操作系统会导致全部数据消失。
另外，内容容量达
到指定的值之后memcached回自动删除不适用的缓存。
4.Memcached不互通信的分布式：memcached尽管是“分布式”缓存服务器，
但服务器端并没有分布式功能。
各个memcached不会互相通信以共享信
息。
他的分布式主要是通过客户端实现的。
Memcached的内存管理
最近的memcached默认情况下采用了名为Slab Allocatoion的机制分配，管理内存。
在改机制出现以前，内存的分配是通过对所有记录简单地进行malloc 和free来进行的。
但是这中方式会导致内存碎片，加重操作系统内存管理器的负担。
Slab Allocator的基本原理是按照预先规定的大小，将分配的内存分割成特定长度的块，已完全解决内存碎片问题。
Slab Allocation 的原理相当简单。
将分配的内存分割成各种尺寸的块（chucnk），并把尺寸相同的块分成组（chucnk的集合）如图：
而且slab allocator 还有重复使用已分配内存的目的。
也就是说，分配到的内存不会释放，而是重复利用。
Slab Allocation 的主要术语
Page :分配给Slab 的内存空间，默认是1MB。
分配给Slab 之后根据slab 的大小切分成chunk.
Chunk : 用于缓存记录的内存空间。
Slab Class:特定大小的chunk 的组。
在Slab 中缓存记录的原理
Memcached根据收到的数据的大小，选择最合适数据大小的Slab (图2) memcached中保存着slab内空闲chunk的列表，根据该列表选择chunk,然后将数据缓存于其中。
Memcached在数据删除方面有效里利用资源
Memcached删除数据时数据不会真正从memcached中消失。
Memcached不会释放已分配的内存。
记录超时后，客户端就无法再看见该记录（invisible 透明），其存储空间即可重复使用。
Lazy Expriationmemcached内部不会监视记录是否过期，而是在get时查看记录的时间戳，检查记录是否过期。
这种技术称为lazy expiration.因此memcached 不会再过期监视上耗费CPU时间。
LRU:从缓存中有效删除数据的原理
Memcached会优先使用已超时的记录空间，但即使如此，也会发生追加新纪录时空间不足的情况。
此时就要使用名为Least Recently Used (LRU)机制来分配空间。
这就是删除最少使用的记录的机制。
因此当memcached的内存空间不足时（无法从slab class）获取到新空间时，就从最近未使用的记录中搜索，并将空间分配给新的记录。
Memcached分布式
Memcached虽然称为“分布式“缓存服务器，但服务器端并没有“分布式”的功能。
Memcached的分布式完全是有客户端实现的。
现在我们就看一下memcached是怎么实现分布式缓存的。
例:
下面假设memcached服务器有node1～node3三台，应用程序要保存键名为“tokyo”“kanagawa”“chiba”“saitama”“gunma” 的数据。
首先向memcached中添加“tokyo”。
将“tokyo”传给客户端程序库后，客户端实现的算法就会根据“键”来决定保存数据的memcached服务器。
服务器选定后，即命令它保存“tokyo”及其值。
同样，“kanagawa”“chiba”“saitama”“gunma”都是先选择服务器再保存。
接下来获取保存的数据。
获取时也要将要获取的键“tokyo”传递给函数库。
函数库通过与数据保存时相同的算法，根据“键”选择服务器。
使用的算法相同，就能选中与保存时相同的服务器，然后发送get命令。
只要数据没有因为某些原因被删除，就能获得保存的值。
这样，将不同的键保存到不同的服务器上，就实现了memcached的分布式。
memcached服务器增多后，键就会分散，即使一台memcached服务器发生故障无法连接，也不会影响其他的缓存，系统依然能继续运行。