互联网公司必备Memcached缓存技术实战指南从架构设计到性能优化的全解析

1. Memcached简介与核心原理

Memcached是一个自由开源的、高性能、分布式内存对象缓存系统，最初由Danga Interactive为LiveJournal而开发，并于2003年开源。它的设计目标是通过缓存数据和对象来减少数据库负载，从而加快动态Web应用的速度。

1.1 Memcached的核心特性

Memcached的核心存储模型是基于键值对（Key-Value）的，这种模型简单而高效。在Memcached中，键是一个字符串，用于唯一标识一个值。值可以是任意类型的数据，如字符串、整数、浮点数，甚至是复杂的数据结构，如JSON或序列化的对象。这种设计使得Memcached非常适合存储临时数据，如会话状态、页面缓存、数据库查询结果等。

1.2 Memcached的工作原理

Memcached的工作原理相对简单：它将数据存储在内存中，以键值对的形式组织。当应用程序需要访问数据时，首先检查Memcached中是否存在该数据。如果存在（缓存命中），则直接从内存中返回数据，避免了访问数据库的开销；如果不存在（缓存未命中），则应用程序从数据库获取数据，然后将数据存储到Memcached中，以备后续使用。

1.3 Memcached的内存管理机制

Memcached使用高效的内存管理机制来优化性能。它采用slab allocation的内存分配和管理方式，将内存划分为多个大小不同的slab class，每个slab class管理特定大小的内存块。当需要存储数据时，Memcached会根据数据大小选择合适的slab class，这样可以减少内存碎片，提高内存利用率。

2. Memcached架构设计

2.1 Memcached的基本架构

Memcached采用客户端-服务器架构，由Memcached服务器和客户端库组成。服务器负责存储和管理数据，客户端库负责与服务器通信，包括数据的存储、获取、删除等操作。

2.2 Memcached的网络模型

Memcached使用基于事件驱动的非阻塞网络模型，可以高效处理大量并发连接。它支持TCP和UDP协议，默认使用TCP协议进行数据传输，但在某些场景下也可以使用UDP协议以提高传输速度和降低延迟。

2.3 Memcached的多线程架构

现代版本的Memcached支持多线程架构，可以充分利用多核CPU的优势。在多线程架构中，主线程负责接受和管理网络连接，工作线程负责处理实际的请求，这样可以提高系统的并发处理能力。

3. Memcached分布式实现与一致性哈希算法

3.1 Memcached的分布式特性

Memcached的分布式特性是其强大之处。它允许将数据分散存储在多台服务器上，形成一个大的内存池。这种分散存储的方式不仅提高了缓存的容量，还增加了系统的并发处理能力。

3.2 一致性哈希算法

在分布式缓存系统中，一致性哈希算法是关键的分布式算法。与传统哈希取模算法相比，一致性哈希算法在节点增减时，只会影响到部分数据，而不是全部数据，从而大大减少了缓存失效带来的系统压力。

一致性哈希算法的工作原理如下：

首先求出Memcached服务器（节点）的哈希值，并将其配置到0～2^32-1的圆上。
然后采用同样的方法求出存储数据的键的哈希值，并映射到相同的圆上。
然后从数据映射到的位置开始顺时针查找，将数据保存到找到的第一个服务器上。如果超过2^32-1仍然找不到服务器，就会保存到第一台Memcached服务器上。

这种算法的优点是当增加或删除节点时，只会影响到该节点在圆上相邻的数据，而不会影响其他数据，从而最大限度地减少了缓存失效带来的影响。

3.3 虚拟节点机制

为了解决数据分布不均匀的问题，一致性哈希算法引入了虚拟节点的概念。每个物理节点可以对应多个虚拟节点，这些虚拟节点在圆上均匀分布。这样，即使物理节点数量较少，也可以通过增加虚拟节点的数量来使数据分布更加均匀。

4. Memcached与Redis的比较

4.1 数据结构的支持

Memcached主要支持简单的键值对存储，而Redis支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。这使得Redis在处理复杂数据结构时更加灵活。

4.2 持久化机制

Memcached不支持数据的持久化，一旦服务器重启，所有数据都会丢失。而Redis提供了RDB快照和AOF日志两种持久化机制，确保数据的安全性。

4.3 性能比较

在简单的键值存储场景下，Memcached的性能通常略优于Redis，特别是在多线程环境下。但在处理复杂数据结构或需要持久化的场景下，Redis则更具优势。

4.4 内存使用效率

Memcached采用slab allocation的内存管理方式，内存利用率较高，但可能会有一定的内存浪费。Redis则采用更灵活的内存管理方式，可以根据数据大小动态调整内存分配，但在某些情况下可能会产生内存碎片。

4.5 功能特性

Redis提供了丰富的功能特性，如事务、发布/订阅、Lua脚本支持、主从复制、哨兵系统、集群模式等，而Memcached则专注于提供简单高效的缓存服务。

5. Memcached在互联网公司的应用场景

5.1 数据库查询结果缓存

Memcached最常见的应用场景是缓存数据库查询结果。对于频繁执行但结果变化不频繁的查询，可以将查询结果存储在Memcached中，以减少数据库的负载。

例如，在一个电商网站中，商品的基本信息（如名称、描述、价格等）通常不会频繁变化，可以将这些信息缓存到Memcached中：

// 伪代码示例：缓存商品基本信息 public Product getProductInfo(long productId) { // 1. 尝试从缓存获取 String cacheKey = "product_info_" + productId; Product product = memcachedClient.get(cacheKey); if (product != null) { return product; // 缓存命中 } // 2. 缓存未命中，从数据库获取 product = productDao.getProductById(productId); if (product != null) { // 3. 将结果存入缓存，设置过期时间为1小时 memcachedClient.set(cacheKey, 3600, product); } return product; }

5.2 会话存储

在分布式系统中，用户会话信息可以存储在Memcached中，以实现会话共享和负载均衡。这样，即使用户请求被分发到不同的服务器，也能获取到一致的会话信息。

// 伪代码示例：使用Memcached存储用户会话 public UserSession getUserSession(String sessionId) { // 1. 尝试从缓存获取会话 UserSession session = memcachedClient.get(sessionId); if (session != null) { // 更新会话过期时间 memcachedClient.touch(sessionId, 1800); // 30分钟 return session; } // 2. 会话不存在或已过期 return null; } public void saveUserSession(String sessionId, UserSession session) { // 将会话存入缓存，设置过期时间为30分钟 memcachedClient.set(sessionId, 1800, session); }

5.3 页面片段缓存

对于动态生成的网页，可以将页面的某些部分（如导航栏、页脚等）缓存到Memcached中，以减少页面生成时间。

// 伪代码示例：缓存页面片段 public String getNavigationHtml() { // 1. 尝试从缓存获取导航栏HTML String navHtml = memcachedClient.get("navigation_html"); if (navHtml != null) { return navHtml; // 缓存命中 } // 2. 缓存未命中，生成导航栏HTML navHtml = generateNavigationHtml(); // 3. 将结果存入缓存，设置过期时间为1天 memcachedClient.set("navigation_html", 86400, navHtml); return navHtml; }

5.4 计数器

Memcached的原子递增递减操作可以用来实现各种计数器功能，如页面访问量、点赞数等。

// 伪代码示例：使用Memcached实现计数器 public long incrementPageView(long articleId) { String counterKey = "article_view_" + articleId; // 尝试递增计数器，如果不存在则初始化为1 long count = memcachedClient.incr(counterKey, 1, 1); // 同时更新数据库（异步） asyncUpdateArticleViewInDB(articleId, count); return count; }

6. Memcached性能优化策略

6.1 内存分配优化

Memcached使用slab allocation机制管理内存，通过合理配置slab class的大小和数量，可以优化内存使用效率。对于不同大小的数据，应该选择合适的slab class，以减少内存浪费。

# Memcached配置示例：优化slab分配 # 增加最小slab大小，减少小对象内存浪费 -I 128 # 增加slab class数量，适应不同大小的数据 -f 1.25

6.2 连接池优化

在高并发场景下，合理配置连接池参数可以显著提高Memcached的性能。连接池大小应该根据应用的并发量和服务器负载情况进行调整。

// 伪代码示例：配置Memcached连接池 public MemcachedClient createMemcachedClient() { // 配置连接池 ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder() .setProtocol(Protocol.BINARY) // 使用二进制协议，性能更高 .setOpTimeout(1000) // 操作超时时间1秒 .setMaxReconnectDelay(30) // 最大重连延迟30秒 .setInitialObservers(5) // 初始观察者数量 .setFailureMode(FailureMode.Redistribute) // 失败重分配模式 .setDaemon(true) // 使用守护线程 .setNagle(false) // 禁用Nagle算法，提高响应速度 .setUseNagleAlgorithm(false); // 禁用Nagle算法 // 配置连接池大小 connectionFactoryBuilder.setInitialConnections(10) // 初始连接数 .setMinConnections(10) // 最小连接数 .setMaxConnections(100) // 最大连接数 .setIdleTime(30 * 1000); // 空闲时间30秒 // 创建Memcached客户端 List<InetSocketAddress> servers = Arrays.asList( new InetSocketAddress("memcached1.example.com", 11211), new InetSocketAddress("memcached2.example.com", 11211), new InetSocketAddress("memcached3.example.com", 11211) ); return new MemcachedClient(connectionFactoryBuilder.build(), servers); }

6.3 数据序列化优化

选择高效的序列化方式可以减少数据大小，提高网络传输效率。Java原生序列化效率较低，可以考虑使用更高效的序列化框架，如Kryo、Protobuf等。

// 伪代码示例：使用Kryo序列化优化Memcached public class KryoTranscoder implements Transcoder<Object> { private final Kryo kryo; public KryoTranscoder() { this.kryo = new Kryo(); // 配置Kryo，注册需要序列化的类 kryo.register(Product.class); kryo.register(UserSession.class); // 其他配置... } @Override public CachedData encode(Object o) { try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); Output output = new Output(baos)) { kryo.writeClassAndObject(output, o); output.flush(); byte[] bytes = baos.toByteArray(); return new CachedData(0, bytes, bytes.length); } catch (IOException e) { throw new RuntimeException("Kryo serialization failed", e); } } @Override public Object decode(CachedData cachedData) { try (Input input = new Input(new ByteArrayInputStream(cachedData.getData()))) { return kryo.readClassAndObject(input); } } // 其他方法实现... } // 使用自定义序列化器 MemcachedClient client = new MemcachedClient( new ConnectionFactoryBuilder() .setTranscoder(new KryoTranscoder()) .build(), servers );

6.4 批量操作优化

Memcached支持批量获取操作（get multi），使用批量操作可以减少网络往返次数，提高性能。

// 伪代码示例：使用批量获取优化性能 public Map<String, Product> getProductsBulk(List<Long> productIds) { // 构建批量获取的键列表 List<String> keys = new ArrayList<>(productIds.size()); Map<String, Long> keyToIdMap = new HashMap<>(productIds.size()); for (Long productId : productIds) { String key = "product_info_" + productId; keys.add(key); keyToIdMap.put(key, productId); } // 批量获取 Map<String, Object> cachedResults = memcachedClient.getBulk(keys); // 处理缓存结果 Map<String, Product> results = new HashMap<>(productIds.size()); List<Long> missingIds = new ArrayList<>(); for (Map.Entry<String, Object> entry : cachedResults.entrySet()) { String key = entry.getKey(); Long productId = keyToIdMap.get(key); Product product = (Product) entry.getValue(); results.put(key, product); } // 找出缓存中缺失的商品ID for (Long productId : productIds) { String key = "product_info_" + productId; if (!cachedResults.containsKey(key)) { missingIds.add(productId); } } // 如果有缺失的商品，从数据库获取并缓存 if (!missingIds.isEmpty()) { List<Product> missingProducts = productDao.getProductsByIds(missingIds); for (Product product : missingProducts) { String key = "product_info_" + product.getId(); results.put(key, product); // 将缺失的商品存入缓存 memcachedClient.set(key, 3600, product); } } return results; }

6.5 缓存预热

在系统启动或高峰期前，可以预先加载热点数据到Memcached中，避免缓存未命中导致的数据库压力。

// 伪代码示例：缓存预热 public void warmUpCache() { // 获取热点商品ID列表 List<Long> hotProductIds = productDao.getHotProductIds(1000); // 获取1000个热点商品 // 分批获取商品信息并缓存 int batchSize = 100; for (int i = 0; i < hotProductIds.size(); i += batchSize) { int end = Math.min(i + batchSize, hotProductIds.size()); List<Long> batchIds = hotProductIds.subList(i, end); // 批量获取商品信息 List<Product> products = productDao.getProductsByIds(batchIds); // 批量缓存商品信息 Map<String, Object> items = new HashMap<>(products.size()); for (Product product : products) { String key = "product_info_" + product.getId(); items.put(key, product); } memcachedClient.setBulk(items, 3600); // 设置过期时间为1小时 // 避免短时间内大量请求压垮数据库 try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); break; } } }

7. Memcached高可用与容灾方案

7.1 客户端故障转移

虽然Memcached服务器本身不提供高可用机制，但可以通过客户端实现故障转移。当某个Memcached节点不可用时，客户端可以自动将请求重定向到其他节点。

// 伪代码示例：客户端故障转移 public class FailoverMemcachedClient { private final List<MemcachedClient> clients; private final ConsistentHash<MemcachedClient> consistentHash; public FailoverMemcachedClient(List<InetSocketAddress> servers) { this.clients = new ArrayList<>(); for (InetSocketAddress server : servers) { try { clients.add(new MemcachedClient( new ConnectionFactoryBuilder() .setOpTimeout(1000) .setDaemon(true) .build(), Collections.singletonList(server) )); } catch (IOException e) { // 初始化失败，记录日志 logger.error("Failed to create Memcached client for " + server, e); } } // 初始化一致性哈希 this.consistentHash = new ConsistentHash<>(clients, 3); // 每个节点3个虚拟节点 } public Object get(String key) { // 根据键选择客户端 MemcachedClient primaryClient = consistentHash.get(key); try { // 首先尝试从主节点获取 return primaryClient.get(key); } catch (Exception e) { // 主节点失败，尝试从其他节点获取 logger.warn("Primary node failed for key " + key + ", trying other nodes", e); for (MemcachedClient client : clients) { if (client != primaryClient) { try { Object value = client.get(key); if (value != null) { // 从其他节点找到数据，记录日志 logger.info("Found key " + key + " on backup node"); return value; } } catch (Exception ex) { // 备份节点也失败，继续尝试下一个节点 logger.warn("Backup node failed for key " + key, ex); } } } // 所有节点都失败 return null; } } // 其他方法实现... }

7.2 数据复制与备份

为了进一步提高数据的可用性，可以实现数据的跨节点复制。当一个节点上的数据更新时，自动将更新复制到其他节点。

// 伪代码示例：数据复制 public class ReplicatedMemcachedClient { private final List<MemcachedClient> clients; private final ConsistentHash<MemcachedClient> consistentHash; private final int replicationFactor; // 复制因子 public ReplicatedMemcachedClient(List<InetSocketAddress> servers, int replicationFactor) { this.replicationFactor = Math.min(replicationFactor, servers.size()); this.clients = new ArrayList<>(); for (InetSocketAddress server : servers) { try { clients.add(new MemcachedClient( new ConnectionFactoryBuilder() .setOpTimeout(1000) .setDaemon(true) .build(), Collections.singletonList(server) )); } catch (IOException e) { logger.error("Failed to create Memcached client for " + server, e); } } this.consistentHash = new ConsistentHash<>(clients, 3); } public void set(String key, int exp, Object value) { // 获取应该存储的节点列表 List<MemcachedClient> targetClients = consistentHash.getNodes(key, replicationFactor); // 异步复制到多个节点 List<Future<Boolean>> futures = new ArrayList<>(targetClients.size()); for (MemcachedClient client : targetClients) { futures.add(client.set(key, exp, value)); } // 等待所有复制操作完成 for (Future<Boolean> future : futures) { try { future.get(1, TimeUnit.SECONDS); // 最多等待1秒 } catch (Exception e) { logger.warn("Failed to replicate key " + key, e); } } } public Object get(String key) { // 获取应该存储的节点列表 List<MemcachedClient> targetClients = consistentHash.getNodes(key, replicationFactor); // 按顺序尝试从各个节点获取数据 for (MemcachedClient client : targetClients) { try { Object value = client.get(key); if (value != null) { return value; } } catch (Exception e) { logger.warn("Failed to get key " + key + " from node", e); } } return null; } // 其他方法实现... }

7.3 监控与告警

建立完善的监控和告警系统，及时发现Memcached节点的问题，并采取相应的措施。

// 伪代码示例：Memcached监控 public class MemcachedMonitor { private final List<MemcachedClient> clients; private final ScheduledExecutorService scheduler; public MemcachedMonitor(List<MemcachedClient> clients) { this.clients = clients; this.scheduler = Executors.newScheduledThreadPool(1); // 每30秒执行一次健康检查 scheduler.scheduleAtFixedRate(this::healthCheck, 30, 30, TimeUnit.SECONDS); } private void healthCheck() { for (MemcachedClient client : clients) { try { // 获取Memcached服务器状态 Map<String, String> stats = client.getStats(); // 检查关键指标 long currConnections = Long.parseLong(stats.get("curr_connections")); long cmdGet = Long.parseLong(stats.get("cmd_get")); long getHits = Long.parseLong(stats.get("get_hits")); double hitRate = (double) getHits / cmdGet; long bytes = Long.parseLong(stats.get("bytes")); long limitMaxbytes = Long.parseLong(stats.get("limit_maxbytes")); double memoryUsage = (double) bytes / limitMaxbytes; // 检查是否超过阈值 if (currConnections > 1000) { sendAlert("High connection count: " + currConnections); } if (hitRate < 0.8) { sendAlert("Low hit rate: " + hitRate); } if (memoryUsage > 0.9) { sendAlert("High memory usage: " + memoryUsage); } } catch (Exception e) { sendAlert("Failed to get stats from Memcached node: " + e.getMessage()); } } } private void sendAlert(String message) { // 实现告警逻辑，如发送邮件、短信或调用告警API logger.warn("Memcached alert: " + message); // alertService.sendAlert(message); } public void shutdown() { scheduler.shutdown(); } }

8. Memcached与其他缓存技术的集成

8.1 多级缓存架构

在高并发系统中，可以构建多级缓存架构，将Memcached作为分布式缓存层，与其他缓存技术（如本地缓存、CDN等）结合使用，形成完整的缓存体系。

// 伪代码示例：多级缓存实现 public class MultiLevelCache { private final Cache localCache; // 本地缓存（如Caffeine） private final MemcachedClient memcachedClient; // 分布式缓存 private final ProductDao productDao; // 数据库访问 public MultiLevelCache(Cache localCache, MemcachedClient memcachedClient, ProductDao productDao) { this.localCache = localCache; this.memcachedClient = memcachedClient; this.productDao = productDao; } public Product getProduct(long productId) { String key = "product_" + productId; // 1. 首先检查本地缓存 Product product = localCache.getIfPresent(key); if (product != null) { return product; } // 2. 本地缓存未命中，检查分布式缓存 try { product = (Product) memcachedClient.get(key); if (product != null) { // 将数据放入本地缓存 localCache.put(key, product); return product; } } catch (Exception e) { logger.warn("Failed to get product from Memcached", e); } // 3. 分布式缓存未命中，从数据库获取 product = productDao.getProductById(productId); if (product != null) { // 将数据放入分布式缓存和本地缓存 try { memcachedClient.set(key, 3600, product); // 1小时过期 } catch (Exception e) { logger.warn("Failed to set product to Memcached", e); } localCache.put(key, product); } return product; } public void updateProduct(Product product) { // 更新数据库 productDao.updateProduct(product); String key = "product_" + product.getId(); // 删除本地缓存和分布式缓存 localCache.invalidate(key); try { memcachedClient.delete(key); } catch (Exception e) { logger.warn("Failed to delete product from Memcached", e); } } }

8.2 与Redis的混合使用

在某些场景下，可以将Memcached和Redis结合使用，发挥各自的优势。例如，使用Memcached处理简单的键值缓存，使用Redis处理复杂的数据结构和持久化需求。

// 伪代码示例：Memcached与Redis混合使用 public class HybridCache { private final MemcachedClient memcachedClient; // 用于简单键值缓存 private final JedisPool redisPool; // 用于复杂数据结构和持久化 public HybridCache(MemcachedClient memcachedClient, JedisPool redisPool) { this.memcachedClient = memcachedClient; this.redisPool = redisPool; } // 使用Memcached缓存简单对象 public void cacheSimpleObject(String key, Object value, int expiration) { memcachedClient.set(key, expiration, value); } public Object getSimpleObject(String key) { return memcachedClient.get(key); } // 使用Redis处理复杂数据结构 public void cacheProductList(String key, List<Product> products) { try (Jedis jedis = redisPool.getResource()) { // 使用Redis的列表存储产品列表 jedis.del(key); // 先删除旧的列表 for (Product product : products) { // 将产品序列化为JSON字符串 String json = serializeProduct(product); jedis.rpush(key, json); } // 设置过期时间 jedis.expire(key, 3600); // 1小时 } } public List<Product> getProductList(String key) { try (Jedis jedis = redisPool.getResource()) { List<String> jsonList = jedis.lrange(key, 0, -1); List<Product> products = new ArrayList<>(jsonList.size()); for (String json : jsonList) { Product product = deserializeProduct(json); products.add(product); } return products; } } // 使用Redis处理计数器 public long incrementCounter(String key) { try (Jedis jedis = redisPool.getResource()) { return jedis.incr(key); } } // 使用Redis处理发布/订阅 public void publish(String channel, String message) { try (Jedis jedis = redisPool.getResource()) { jedis.publish(channel, message); } } public void subscribe(String channel, JedisPubSub jedisPubSub) { try (Jedis jedis = redisPool.getResource()) { jedis.subscribe(jedisPubSub, channel); } } // 辅助方法：序列化和反序列化产品 private String serializeProduct(Product product) { // 实现产品序列化为JSON字符串 return ""; // 简化示例 } private Product deserializeProduct(String json) { // 实现从JSON字符串反序列化为产品 return null; // 简化示例 } }

9. Memcached实战案例

9.1 电商网站商品详情页缓存优化

在一个大型电商网站中，商品详情页是访问量最大的页面之一。通过合理使用Memcached，可以显著提高页面加载速度，减轻数据库压力。

// 伪代码示例：电商网站商品详情页缓存优化 public class ProductDetailService { private final MemcachedClient memcachedClient; private final ProductDao productDao; private final InventoryService inventoryService; private final ReviewService reviewService; private final RecommendationService recommendationService; public ProductDetailService(MemcachedClient memcachedClient, ProductDao productDao, InventoryService inventoryService, ReviewService reviewService, RecommendationService recommendationService) { this.memcachedClient = memcachedClient; this.productDao = productDao; this.inventoryService = inventoryService; this.reviewService = reviewService; this.recommendationService = recommendationService; } public ProductDetail getProductDetail(long productId) { String cacheKey = "product_detail_" + productId; // 1. 尝试从缓存获取商品详情 ProductDetail detail = (ProductDetail) memcachedClient.get(cacheKey); if (detail != null) { return detail; } // 2. 缓存未命中，从各个服务获取数据 detail = new ProductDetail(); // 获取基本信息 Product product = productDao.getProductById(productId); if (product != null) { detail.setProduct(product); } // 获取库存信息（实时性要求高，不缓存） Inventory inventory = inventoryService.getInventory(productId); if (inventory != null) { detail.setInventory(inventory); } // 获取评价信息 List<Review> reviews = reviewService.getReviews(productId); if (reviews != null) { detail.setReviews(reviews); } // 获取推荐商品 List<Product> recommendations = recommendationService.getRecommendations(productId); if (recommendations != null) { detail.setRecommendations(recommendations); } // 3. 将商品详情存入缓存（不包括库存信息） ProductDetail cacheableDetail = new ProductDetail(); cacheableDetail.setProduct(detail.getProduct()); cacheableDetail.setReviews(detail.getReviews()); cacheableDetail.setRecommendations(detail.getRecommendations()); memcachedClient.set(cacheKey, 1800, cacheableDetail); // 缓存30分钟 return detail; } public void updateProduct(Product product) { // 更新数据库 productDao.updateProduct(product); // 删除缓存 String cacheKey = "product_detail_" + product.getId(); memcachedClient.delete(cacheKey); } public void addReview(Review review) { // 添加评价到数据库 reviewService.addReview(review); // 删除缓存 String cacheKey = "product_detail_" + review.getProductId(); memcachedClient.delete(cacheKey); } }

9.2 社交网站动态流缓存优化

在社交网站中，用户动态流是核心功能之一，通过使用Memcached可以优化动态流的加载速度。

// 伪代码示例：社交网站动态流缓存优化 public class FeedService { private final MemcachedClient memcachedClient; private final PostDao postDao; private final FollowService followService; private final UserService userService; public FeedService(MemcachedClient memcachedClient, PostDao postDao, FollowService followService, UserService userService) { this.memcachedClient = memcachedClient; this.postDao = postDao; this.followService = followService; this.userService = userService; } public List<Post> getUserFeed(long userId, int offset, int limit) { String cacheKey = "user_feed_" + userId + "_" + offset + "_" + limit; // 1. 尝试从缓存获取动态流 List<Post> feed = (List<Post>) memcachedClient.get(cacheKey); if (feed != null) { return feed; } // 2. 缓存未命中，从数据库获取 // 获取用户关注的人 List<Long> followingIds = followService.getFollowing(userId); // 获取这些人的最新动态 feed = postDao.getPostsByUsers(followingIds, offset, limit); // 补充用户信息 for (Post post : feed) { User user = userService.getUserById(post.getUserId()); if (user != null) { post.setUserName(user.getName()); post.setUserAvatar(user.getAvatar()); } } // 3. 将动态流存入缓存 memcachedClient.set(cacheKey, 300, feed); // 缓存5分钟 return feed; } public void publishPost(Post post) { // 保存帖子到数据库 postDao.addPost(post); // 获取发布者的粉丝 List<Long> followerIds = followService.getFollowers(post.getUserId()); // 删除这些粉丝的动态流缓存 for (Long followerId : followerIds) { // 删除前几页的缓存 for (int page = 0; page < 5; page++) { String cacheKey = "user_feed_" + followerId + "_" + (page * 20) + "_20"; memcachedClient.delete(cacheKey); } } } }

9.3 广告系统实时竞价缓存优化

在广告系统中，实时竞价（RTB）对响应时间要求极高，通过使用Memcached可以优化竞价决策过程。

// 伪代码示例：广告系统实时竞价缓存优化 public class AdBiddingService { private final MemcachedClient memcachedClient; private final AdDao adDao; private final UserProfileService userProfileService; private final BudgetService budgetService; public AdBiddingService(MemcachedClient memcachedClient, AdDao adDao, UserProfileService userProfileService, BudgetService budgetService) { this.memcachedClient = memcachedClient; this.adDao = adDao; this.userProfileService = userProfileService; this.budgetService = budgetService; } public Ad bidForAdSlot(long userId, String adSlotId, Map<String, String> targetingParams) { // 1. 获取用户画像 UserProfile userProfile = userProfileService.getUserProfile(userId); // 2. 构建缓存键 String cacheKey = "ad_bid_" + adSlotId + "_" + userProfile.getSegment(); // 3. 尝试从缓存获取候选广告 List<Ad> candidateAds = (List<Ad>) memcachedClient.get(cacheKey); if (candidateAds == null) { // 缓存未命中，从数据库获取 candidateAds = adDao.getAdsBySlotAndSegment(adSlotId, userProfile.getSegment()); // 将候选广告存入缓存 memcachedClient.set(cacheKey, 600, candidateAds); // 缓存10分钟 } // 4. 过滤符合定向条件的广告 List<Ad> targetedAds = new ArrayList<>(); for (Ad ad : candidateAds) { if (matchesTargeting(ad, targetingParams)) { // 检查预算 if (budgetService.hasBudget(ad.getCampaignId())) { targetedAds.add(ad); } } } // 5. 如果没有符合条件的广告，返回默认广告 if (targetedAds.isEmpty()) { return adDao.getDefaultAd(adSlotId); } // 6. 根据竞价策略选择广告 return selectAdByBiddingStrategy(targetedAds, userProfile); } private boolean matchesTargeting(Ad ad, Map<String, String> targetingParams) { // 实现广告定向逻辑 // 检查地理位置、设备类型、兴趣等定向条件 return true; // 简化示例 } private Ad selectAdByBiddingStrategy(List<Ad> ads, UserProfile userProfile) { // 实现竞价策略 // 可以根据eCPM、CTR等因素选择最优广告 return ads.get(0); // 简化示例 } public void updateAd(Ad ad) { // 更新数据库 adDao.updateAd(ad); // 删除相关缓存 String cacheKey = "ad_bid_" + ad.getAdSlotId() + "_" + ad.getTargetSegment(); memcachedClient.delete(cacheKey); } }