Redis on Leanku 的博客

PHP + Redis实现订单超时

Fri, 28 Mar 2025 22:33:45 +0800

PHP + Redis实现订单超时

针对秒杀场景下的订单超时未支付自动取消，这是一个典型需求。由于秒杀需要快速释放被占用的库存，所以超时机制的设计非常关键。

一、核心思路

订单创建时：记录超时时间（如 30 分钟），将订单 ID 推入 Redis 的 Sorted Set（有序集合），score 为超时时间戳。
定时轮询：启动一个 PHP 常驻进程，每隔 1-2 秒轮询 Sorted Set，取出已超时的订单 ID。
超时处理：更新 MySQL 订单状态为“已取消”，并恢复 Redis 中的秒杀库存（如果业务要求释放库存）。
无需额外组件：纯 Redis + PHP，不依赖 RabbitMQ 的延迟队列或 RocketMQ。

二、详细设计

1. 订单表增加字段

1ALTER TABLE orders ADD COLUMN status TINYINT DEFAULT 0 COMMENT '0-待支付 1-已支付 2-已取消 3-已超时';
2ALTER TABLE orders ADD COLUMN expire_time DATETIME COMMENT '订单超时时间';

2. 创建订单时：加入超时监控

在秒杀成功、订单写入 MySQL 后（或写入 Redis 队列时），同时将订单 ID 加入 Redis Sorted Set：

PHP 实现 Redis 高并发解决方案

Fri, 28 Mar 2025 22:33:45 +0800

PHP 实现 Redis 高并发解决方案

使用 PHP 实现 Redis 在缓存加速、分布式锁和队列场景中的应用。

首先确保已安装 PHP Redis 扩展

一、缓存加速实现

1. 基本缓存操作

 1<?php
 2$redis = new Redis();
 3$redis->connect('127.0.0.1', 6379);
 4
 5// 设置缓存
 6function setCache($key, $value, $expire = 3600) {
 7 global $redis;
 8 $serialized = serialize($value);
 9 return $redis->setex($key, $expire, $serialized);
10}
11
12// 获取缓存
13function getCache($key) {
14 global $redis;
15 $serialized = $redis->get($key);
16 return $serialized ? unserialize($serialized) : false;
17}
18
19// 删除缓存
20function deleteCache($key) {
21 global $redis;
22 return $redis->del($key);
23}
24
25// 示例：用户数据缓存
26function getUser($userId) {
27 $cacheKey = "user:{$userId}";
28 $user = getCache($cacheKey);
29 
30 if ($user === false) {
31 // 模拟数据库查询
32 $user = [
33 'id' => $userId,
34 'name' => 'User ' . $userId,
35 'email' => "user{$userId}@example.com"
36 ];
37 // 写入缓存，有效期1小时
38 setCache($cacheKey, $user, 3600);
39 }
40 
41 return $user;
42}
43
44// 使用示例
45$user = getUser(123);
46print_r($user);

2. 防止缓存穿透

 1function getProduct($productId) {
 2 global $redis;
 3 $cacheKey = "product:{$productId}";
 4 $product = getCache($cacheKey);
 5 
 6 if ($product === false) {
 7 // 使用互斥锁防止缓存击穿
 8 $lockKey = "lock:product:{$productId}";
 9 $locked = $redis->set($lockKey, 1, ['nx', 'ex' => 10]);
10 
11 if ($locked) {
12 try {
13 // 模拟数据库查询
14 $product = [
15 'id' => $productId,
16 'name' => 'Product ' . $productId,
17 'price' => rand(100, 1000)
18 ];
19 
20 if (empty($product)) {
21 // 缓存空对象防止穿透，有效期5分钟
22 setCache($cacheKey, [], 300);
23 } else {
24 setCache($cacheKey, $product, 3600);
25 }
26 } finally {
27 $redis->del($lockKey);
28 }
29 } else {
30 // 等待其他进程完成缓存设置
31 usleep(500000); // 等待500ms
32 return getProduct($productId); // 重试
33 }
34 }
35 
36 return $product ?: null;
37}

二、分布式锁实现

1. 基本分布式锁

 1class RedisLock {
 2 private $redis;
 3 private $lockKey;
 4 private $identifier;
 5 private $lockTimeout;
 6 
 7 public function __construct($redis, $lockKey, $lockTimeout = 10) {
 8 $this->redis = $redis;
 9 $this->lockKey = $lockKey;
10 $this->lockTimeout = $lockTimeout;
11 $this->identifier = uniqid();
12 }
13 
14 public function acquire($waitTimeout = 5) {
15 $end = microtime(true) + $waitTimeout;
16 
17 while (microtime(true) < $end) {
18 if ($this->redis->set(
19 $this->lockKey, 
20 $this->identifier, 
21 ['nx', 'ex' => $this->lockTimeout]
22 )) {
23 return true;
24 }
25 
26 usleep(10000); // 等待10ms
27 }
28 
29 return false;
30 }
31 
32 public function release() {
33 $script = '
34 if redis.call("get", KEYS[1]) == ARGV[1] then
35 return redis.call("del", KEYS[1])
36 else
37 return 0
38 end
39 ';
40 
41 return $this->redis->eval($script, [$this->lockKey, $this->identifier], 1);
42 }
43 
44 public function __destruct() {
45 $this->release();
46 }
47}
48
49// 使用示例
50$lock = new RedisLock($redis, 'lock:order:123');
51if ($lock->acquire()) {
52 try {
53 // 执行需要加锁的操作
54 echo "Lock acquired, doing critical section...\n";
55 sleep(2);
56 } finally {
57 $lock->release();
58 }
59} else {
60 echo "Failed to acquire lock\n";
61}

2. 可重入锁实现

 1class ReentrantRedisLock extends RedisLock {
 2 private $heldCount = 0;
 3 
 4 public function acquire($waitTimeout = 5) {
 5 // 检查是否已经持有锁
 6 if ($this->heldCount > 0) {
 7 $this->heldCount++;
 8 return true;
 9 }
10 
11 $acquired = parent::acquire($waitTimeout);
12 if ($acquired) {
13 $this->heldCount = 1;
14 }
15 return $acquired;
16 }
17 
18 public function release() {
19 if ($this->heldCount > 1) {
20 $this->heldCount--;
21 return true;
22 }
23 
24 $released = parent::release();
25 if ($released) {
26 $this->heldCount = 0;
27 }
28 return $released;
29 }
30}

三、队列实现

1. 简单队列

 1// 生产者
 2function enqueue($queueName, $data) {
 3 global $redis;
 4 return $redis->lPush($queueName, json_encode($data));
 5}
 6
 7// 消费者
 8function dequeue($queueName, $timeout = 30) {
 9 global $redis;
10 $result = $redis->brPop($queueName, $timeout);
11 return $result ? json_decode($result[1], true) : null;
12}
13
14// 示例
15enqueue('email_queue', [
16 'to' => 'user@example.com',
17 'subject' => 'Welcome',
18 'body' => 'Thank you for registering'
19]);
20
21$task = dequeue('email_queue');
22if ($task) {
23 // 处理任务
24 echo "Sending email to: {$task['to']}\n";
25}

2. 延迟队列

 1function enqueueDelayed($queueName, $data, $delaySeconds) {
 2 global $redis;
 3 $score = time() + $delaySeconds;
 4 return $redis->zAdd($queueName, $score, json_encode($data));
 5}
 6
 7function processDelayedQueue($queueName) {
 8 global $redis;
 9 $now = time();
10 $items = $redis->zRangeByScore($queueName, 0, $now);
11 
12 if (!empty($items)) {
13 // 使用事务移除已处理项
14 $redis->multi();
15 foreach ($items as $item) {
16 $redis->zRem($queueName, $item);
17 }
18 $redis->exec();
19 
20 return array_map(function($item) {
21 return json_decode($item, true);
22 }, $items);
23 }
24 
25 return [];
26}
27
28// 示例
29enqueueDelayed('reminder_queue', ['user_id' => 123, 'message' => 'Pay your bill'], 60);
30
31$tasks = processDelayedQueue('reminder_queue');
32foreach ($tasks as $task) {
33 echo "Sending reminder to user {$task['user_id']}: {$task['message']}\n";
34}

3. Pub/Sub 模式

 1// 发布者
 2function publishMessage($channel, $message) {
 3 global $redis;
 4 return $redis->publish($channel, json_encode($message));
 5}
 6
 7// 订阅者
 8function subscribe($channels, $callback) {
 9 global $redis;
10 $pubsub = $redis->pSubscribe($channels);
11 
12 try {
13 foreach ($pubsub as $message) {
14 if ($message->kind === 'message') {
15 $data = json_decode($message->payload, true);
16 call_user_func($callback, $message->channel, $data);
17 }
18 }
19 } catch (Exception $e) {
20 $redis->pUnsubscribe();
21 throw $e;
22 }
23}
24
25// 示例使用
26// 在一个进程中
27publishMessage('notifications', ['user_id' => 123, 'text' => 'New message']);
28
29// 在另一个进程中
30subscribe(['notifications'], function($channel, $message) {
31 echo "Received on {$channel}: ";
32 print_r($message);
33});

四、综合应用示例 - 秒杀系统

 1class SeckillService {
 2 private $redis;
 3 private $productKey;
 4 
 5 public function __construct($redis, $productId) {
 6 $this->redis = $redis;
 7 $this->productKey = "seckill:product:{$productId}";
 8 }
 9 
10 public function initInventory($inventory) {
11 // 设置商品库存
12 $this->redis->set($this->productKey, $inventory);
13 }
14 
15 public function seckill($userId) {
16 // 使用分布式锁
17 $lock = new RedisLock($this->redis, "lock:{$this->productKey}");
18 
19 if (!$lock->acquire(1)) {
20 return ['success' => false, 'message' => '系统繁忙'];
21 }
22 
23 try {
24 // 检查库存
25 $inventory = $this->redis->get($this->productKey);
26 if ($inventory <= 0) {
27 return ['success' => false, 'message' => '已售罄'];
28 }
29 
30 // 扣减库存
31 $this->redis->decr($this->productKey);
32 
33 // 记录订单 (实际应用中应该入队列异步处理)
34 $orderId = uniqid();
35 $this->redis->hSet("seckill:orders", $orderId, json_encode([
36 'user_id' => $userId,
37 'product_key' => $this->productKey,
38 'created_at' => time()
39 ]));
40 
41 return ['success' => true, 'order_id' => $orderId];
42 } finally {
43 $lock->release();
44 }
45 }
46}
47
48// 使用示例
49$redis = new Redis();
50$redis->connect('127.0.0.1', 6379);
51
52$seckill = new SeckillService($redis, 1001);
53$seckill->initInventory(100); // 初始化100件库存
54
55// 模拟并发请求
56for ($i = 0; $i < 5; $i++) {
57 $result = $seckill->seckill(rand(1000, 9999));
58 print_r($result);
59}

五、最佳实践建议

1. 连接管理：使用连接池或持久连接

1$redis = new Redis();
2$redis->pconnect('127.0.0.1', 6379);

2. 错误处理：添加重试机制

 1function redisRetry($callback, $maxRetries = 3) {
 2 $retries = 0;
 3 while ($retries < $maxRetries) {
 4 try {
 5 return $callback();
 6 } catch (RedisException $e) {
 7 $retries++;
 8 if ($retries >= $maxRetries) {
 9 throw $e;
10 }
11 usleep(100000 * $retries); // 指数退避
12 }
13 }
14}

3. 性能优化：使用管道(pipeline)

1$pipe = $redis->pipeline();
2$pipe->set('key1', 'value1');
3$pipe->set('key2', 'value2');
4$pipe->incr('counter');
5$pipe->expire('key1', 60);
6$results = $pipe->exec();

4. Lua脚本：保证原子性

1$script = '
2 local current = redis.call("GET", KEYS[1])
3 if current == ARGV[1] then
4 return redis.call("INCRBY", KEYS[1], ARGV[2])
5 else
6 return nil
7 end
8';
9$result = $redis->eval($script, ['counter', 'expected_value', 'increment'], 1);

PHP + Redis秒杀场景

Fri, 28 Mar 2025 22:30:45 +0800

PHP + Redis秒杀场景

在电商秒杀等高并发场景中，Redis 凭借其内存操作和原子性特性，成为库存扣减的核心组件。

下面以 PHP + Redis 为例，给出一个企业级秒杀库存设计方案示例，重点解决超卖、热点 Key、重复下单和流量冲击等问题。

一、核心思路

预加载库存：秒杀活动开始前，将商品库存从 MySQL 同步到 Redis（使用 SET 或 HMSET）。
原子扣减：使用 Redis Lua 脚本（或 DECR + 校验）保证扣减与校验的原子性，杜绝超卖。
异步落库：扣减成功后，将用户 ID、商品 ID 推入消息队列（如 Redis Stream / List），后台进程消费并创建订单、扣减数据库库存。
限流 + 防重：通过令牌桶或滑动窗口限制用户访问频率，通过 Redis 记录用户抢购状态防止同一用户重复下单。

二、详细步骤与代码实现

1. 活动开始前：初始化库存

1// 假设商品ID=1001，秒杀库存=100
2$redis->set('seckill:stock:1001', 100);
3$redis->set('seckill:closed:1001', 0); // 0-未结束，1-已结束

2. 抢购接口核心：Lua 脚本原子扣减

 1$lua = <<<LUA
 2local stock_key = KEYS[1]
 3local user_key = KEYS[2] -- 用于记录已抢购用户
 4local user_id = ARGV[1]
 5local closed_key = KEYS[3]
 6
 7-- 检查活动是否已结束
 8if redis.call('get', closed_key) == '1' then
 9 return -2 -- 活动结束
10end
11
12-- 检查用户是否已抢购过（防重复）
13if redis.call('sismember', user_key, user_id) == 1 then
14 return -1 -- 重复抢购
15end
16
17-- 扣减库存
18local stock = redis.call('decr', stock_key)
19if stock < 0 then
20 -- 库存不足，回滚
21 redis.call('incr', stock_key)
22 return 0 -- 无库存
23end
24
25-- 记录用户
26redis.call('sadd', user_key, user_id)
27-- 返回当前剩余库存（正数代表成功，0代表刚好扣完）
28return stock
29LUA;
30
31$result = $redis->eval($lua, [
32 'seckill:stock:1001',
33 'seckill:users:1001',
34 'seckill:closed:1001',
35 $userId
36], 3); // 3个KEYS
37
38if ($result === -2) {
39 // 活动已结束
40} elseif ($result === -1) {
41 // 用户已抢过
42} elseif ($result === 0) {
43 // 库存不足
44} else {
45 // 扣减成功，剩余库存 $result
46 // 将成功信息推入消息队列（异步创建订单）
47 $redis->lpush('seckill:orders', json_encode([
48 'user_id' => $userId,
49 'goods_id' => 1001,
50 'stock' => $result
51 ]));
52}

3. 异步消费队列（如使用 Redis List + PHP 常驻进程）

 1// consumer.php 常驻进程（可用 Swoole / Supervisor 管理）
 2while (true) {
 3 $data = $redis->brpop('seckill:orders', 2); // 超时2秒
 4 if ($data) {
 5 $order = json_decode($data[1], true);
 6 // 开启MySQL事务
 7 $db->begin();
 8 try {
 9 // 再次检查数据库库存（防止Redis数据不一致）
10 $stock = $db->query("SELECT stock FROM goods WHERE id={$order['goods_id']} FOR UPDATE");
11 if ($stock > 0) {
12 $db->query("UPDATE goods SET stock = stock - 1 WHERE id={$order['goods_id']} AND stock>0");
13 // 创建订单...
14 $db->commit();
15 } else {
16 $db->rollback();
17 // 库存不足，需回滚Redis中的用户记录（补偿）
18 $redis->srem('seckill:users:1001', $order['user_id']);
19 $redis->incr('seckill:stock:1001');
20 }
21 } catch (Exception $e) {
22 $db->rollback();
23 // 记录异常，重试或人工介入
24 }
25 }
26}

4. 限流（防止刷单）

使用 Redis 的滑动窗口或令牌桶。示例：基于用户 IP 的 QPS 限制（每秒最多5次请求）

Redis分布式锁

Tue, 23 Apr 2024 20:46:01 +0800

Redis分布式锁

一、 Redis锁基础概念

1. 为什么需要Redis锁

Redis锁是一种基于内存数据库Redis实现的分布式锁机制，主要解决分布式系统中的资源竞争问题。相比数据库锁，Redis锁具有以下优势

高性能：基于内存操作，响应速度快
原子性保证：Redis单线程模型天然支持原子操作
分布式支持：可跨多台服务器使用
丰富的数据结构：支持多种锁实现方式

2. 基本实现原理

最简单的Redis锁实现方式：

SET resource_name my_random_value NX PX 30000

NX：仅当key不存在时设置
PX：设置过期时间(毫秒)
my_random_value：唯一标识，用于安全释放锁

二、Redis锁的实现方式

1. SETNX实现（基本方式）

实现步骤：

尝试获取锁：SETNX lock_key 1
获取成功则设置过期时间：EXPIRE lock_key 30
执行业务逻辑
释放锁：DEL lock_key

问题： 非原子操作，SETNX和EXPIRE之间可能崩溃导致死锁

2. SET扩展参数实现（推荐）

Redis 2.6.12+版本支持扩展参数，可原子性完成设置

SET lock_key unique_value NX PX 30000

PHP实现示例：

 1$redis = new Redis();
 2$redis->connect('127.0.0.1', 6379);
 3
 4$lockKey = 'order_lock_123';
 5$uniqueId = uniqid();
 6$expire = 30000; // 30秒
 7
 8// 尝试获取锁
 9$acquired = $redis->set($lockKey, $uniqueId, ['NX', 'PX' => $expire]);
10
11if ($acquired) {
12 try {
13 // 执行业务逻辑
14 processOrder();
15 } finally {
16 // 使用Lua脚本保证原子性释放
17 $script = "
18 if redis.call('get', KEYS[1]) == ARGV[1] then
19 return redis.call('del', KEYS[1])
20 else
21 return 0
22 end
23 ";
24 $redis->eval($script, [$lockKey, $uniqueId], 1);
25 }
26} else {
27 // 获取锁失败
28 handleLockFailure();
29}

3. RedLock算法（分布式环境）

Redis官方推荐的分布式锁算法，适用于多Redis节点场景：

Redis高可用

Tue, 23 Apr 2024 20:46:01 +0800

Redis高可用

1. 事务机制和IO多路复用

1.1 事务

1.1.1 事务特点

事务提交前，先检查命令语法是否正确
提交后的命令一定会执行
有命令报错，也会执行完
不能回滚

1.1.2 命令

multi，告诉Redis服务器开启一个事务。只是开启而不是执行。
exec, 告诉Redis开始执行事务
discard，告诉Redis取消事务
watch，监视某一个键值对，它的作用是在事务执行之前如果监视的键值被修改，事务会被取消

1.2 IO多路复用

redis 是单线程，单线程只能在一个CPU内核上执行，假如是4核的，只会占用一个，其它三个不参与。 worker线程串行 read读->计算->write返回

在Redis6.0加入了io-threads，主线程worker只进行计算，并行读取

io-threads 4

io-threads-do-reads yes

2. 持久化和过期淘汰策略

2.1 持久化

Redis是存储在内存中的，服务器重启数据会丢失。持久化方案可以保存数据到磁盘文件，可以恢复到内存中。Redis提供的持久化方案有：

rdb：生成某一时刻的快照，保存到二进制文件中
- 优点：
  - 容灾性好，方便备份
  - 性能最大化，fork出一个子进程来操作，对主进程没有影响
  - 数据较多时，相对于aof启动效率更高
- 缺点：
  - 会造成数据丢失
aof：实时记录每一条写命令，追加到文件中，打开可以看到具体的操作记录
- 同步策略：appendfsync
  - everysec(默认),每秒同步一次
  - always，每次操作后都要同步一次
  - no,由操作系统调度进行同步
- 重写策略：
  - 手动触发，执行bgrewiteaof命令
  - 自动触发：auto-rewrite-percentage 100, auto-rewrite-min-size 64mb
- 优点
  - 数据安全，不会造成数据的丢失
- 缺点
  - 比rdb重启效率低；运行效率比rdb低
混合模式：上面两种方式的结合

触发方式有两种：

手动触发：
- save命令，会让Redis处于阻塞的状态，直到rdb持久化完成，线上环境谨慎使用
- bgsave命令,它会fork出一个子进程（有短暂阻塞），用来执行持久化，主进程继续响应客户端请求
自动触发：
- 配置文件修改（save n m），在n秒内,有m个key发生变化就会触发，执行命令最总执行的是bgsave

2.2 过期键删除策略

Redis设置key时，都会设置一个过期时间，Redis同时使用了两种过期删除策略，惰性过期和定时过期

Redis主从复制

Wed, 20 Mar 2024 20:46:01 +0800

Redis主从复制

一、什么是Redis主从复制

1. 从复制的架构：

Redis Replication是一种 master-slave 模式的复制机制，这种机制使得 slave 节点可以成为与 master 节点完全相同的副本，可以采用一主多从或者级联结构。

主从复制的配置要点：

配从库不配主，从库配置：slaveof 主库IP 主库端口
查看redis的配置信息：info replication

2. Redis为什么需要主从复制？

使用Redis主从复制的原因主要是单台Redis节点存在以下的局限性：

Redis虽然读写的速度都很快，单节点的Redis能够支撑QPS大概在5w左右，如果上千万的用户访问，Redis就承载不了，成为了高并发的瓶颈。
单节点的Redis不能保证高可用，当Redis因为某些原因意外宕机时，会导致缓存不可用
CPU的利用率上，单台Redis实例只能利用单个核心，这单个核心在面临海量数据的存取和管理工作时压力会非常大。

3. 主从复制的好处：

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
故障恢复：如果master宕掉了，使用哨兵模式，可以提升一个 slave 作为新的 master，进而实现故障转移，实现高可用
负载均衡：可以轻易地实现横向扩展，实现读写分离，一个 master 用于写，多个 slave 用于分摊读的压力，从而实现高并发；

4. 主从复制的缺点：

由于所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave服务器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重

二、主从复制的原理

从总体上来说，Redis主从复制的策略就是：当主从服务器刚建立连接的时候，进行全量同步；全量复制结束后，进行增量复制。当然，如果有需要，slave 在任何时候都可以发起全量同步。

1、主从全量复制的流程：

Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份，具体步骤如下：

slave服务器连接到master服务器，便开始进行数据同步，发送psync命令（Redis2.8之前是sync命令）
master服务器收到psync命令之后，开始执行bgsave命令生成RDB快照文件并使用缓存区记录此后执行的所有写命令
- 如果master收到了多个slave并发连接请求，它只会进行一次持久化，而不是每个连接都执行一次，然后再把这一份持久化的数据发送给多个并发连接的slave。
- 如果RDB复制时间超过60秒（repl-timeout），那么slave服务器就会认为复制失败，可以适当调节大这个参数
master服务器bgsave执行完之后，就会向所有Slava服务器发送快照文件，并在发送期间继续在缓冲区内记录被执行的写命令 client-output-buffer-limit slave 256MB 64MB 60，如果在复制期间，内存缓冲区持续消耗超过64MB，或者一次性超过256MB，那么停止复制，复制失败
slave服务器收到RDB快照文件后，会将接收到的数据写入磁盘，然后清空所有旧数据，在从本地磁盘载入收到的快照到内存中，同时基于旧的数据版本对外提供服务。
master服务器发送完RDB快照文件之后，便开始向slave服务器发送缓冲区中的写命令
slave服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；
如果slave node开启了AOF，那么会立即执行BGREWRITEAOF，重写AOF

2、增量复制：

Redis的增量复制是指在初始化的全量复制并开始正常工作之后，master服务器将发生的写操作同步到slave服务器的过程，增量复制的过程主要是master服务器每执行一个写命令就会向slave服务器发送相同的写命令，slave服务器接收并执行收到的写命令。

3、断点续传：

什么是断点续传：

当master-slave网络连接断掉后，slave重新连接master时，会触发全量复制，但是从2.8版本开始，slave与master能够在网络连接断开重连后，只从中断处继续进行复制，而不必重新同步，这就是所谓的断点续传。

 断电续传这个新特性使用psync命令，旧的实现中使用sync命令。Redis2.8版本可以检测出它所连接的服务器是否支持PSYNC命令，不支持的话使用SYNC命令。master服务器收到slave发送的psync命令后，会根据自身的情况做出对应的处理，可能是FULLRESYNC runid offset触发全量复制，也可能是CONTINUE触发增量复制
 命令格式：psync runid offset

工作原理：

Redis持久化及过期删除策略

Wed, 13 Mar 2024 13:46:01 +0800

Redis持久化及过期删除策略

Redis 持久化之RDB和AOF

RDB 详解

快照（snapshotting，RDB） RDB 是 Redis 默认的持久化方案。在指定的时间间隔内，执行指定次数的写操作，则会将内存中的数据写入到磁盘中。即在指定目录下生成一个dump.rdb文件。Redis 重启会通过加载dump.rdb文件恢复数据

从配置文件了解RDB 打开 redis.conf 文件，找到 SNAPSHOTTING 对应内容

RDB核心规则配置（重点）
```
 save <seconds> <changes>
 #save ""
 save 900 1
 save 300 10
 save 60 10000
```
说明：save <指定时间间隔> <执行指定次数更新操作>，满足条件就将内存中的数据同步到硬盘中。官方出厂配置默认是 900秒内有1个更改，300秒内有10个更改以及60秒内有10000个更改，则将内存中的数据快照写入磁盘。若不想用RDB方案，可以把 save “” 的注释打开，下面三个注释。
指定本地数据库文件名，一般采用默认的 dump.rdb dbfilename dump.rdb
指定本地数据库存放目录，一般也用默认配置 dir ./
默认开启数据压缩 rdbcompression yes

解说：配置存储至本地数据库时是否压缩数据，默认为yes。Redis采用LZF压缩方式，但占用了一点CPU的时间。若关闭该选项，但会导致数据库文件变的巨大。建议开启。

触发RDB快照

在指定的时间间隔内，执行指定次数的写操作
执行save（阻塞，只管保存快照，其他的等待）或者是bgsave （异步）命令
执行flushall 命令，清空数据库所有数据，意义不大。
执行shutdown 命令，保证服务器正常关闭且不丢失任何数据，意义…也不大。注意：

save备份过程：save备份是同步的，如果备份的数据量过大的话，服务器会暂停几百毫秒甚至是1秒

bgsave备份过程：bgsave备份会单独创建一个子进程，将备份的数据写入一个临时文件

RDB数据还原 找到备份临时文件的指令是 config get dir 指令执行成功以后将备份临时文件的目录拷贝到Redis的安装目录下然后重新启动Redis服务就成功还原数据了

Redis分布式

Tue, 12 Mar 2024 20:46:01 +0800

Redis分布式

一、 Redis分布式概述

1. 什么是Redis分布式

Redis分布式是指将Redis数据分布到多个Redis节点上，通过集群方式提供更高性能、更大容量和更好可用性的解决方案。

1.2 为什么需要Redis分布式

数据量增长：单机内存容量有限
高并发需求：单机性能瓶颈
高可用性：避免单点故障
可扩展性：支持业务动态扩容

1.3 Redis分布式方案对比

方案	优点	缺点	使用场景
主从复制	部署简单，读写分离	写操作单点，故障需手动切换	读多写少，数据备份
Redis Sentinel	自动故障转移，高可用	配置复杂，扩容不便	生产环境高可用
Redis Cluster	数据分片，自动故障转移	客户端兼容性要求，迁移复杂	大数据量，高并发

二、 Redis分布式方案搭建

2.1 主从复制搭建

配置文件示例

主节点 (master.conf):

1port 6379
2daemonize yes
3pidfile /var/run/redis_6379.pid
4logfile "/var/log/redis_6379.log"

从节点 (slave.conf):

port 6380
daemonize yes
pidfile /var/run/redis_6380.pid
logfile "/var/log/redis_6380.log"
slaveof 127.0.0.1 6379

启动命令

1# 启动主节点
2redis-server master.conf
3
4# 启动从节点
5redis-server slave.conf

2.2 Redis Sentinel搭建

Sentinel配置文件

Redis中的Lua

Tue, 12 Mar 2024 20:46:01 +0800

Redis中的Lua

一. Redis中的Lua脚本的作用

Redis中的Lua脚本主要解决复杂操作的原子性和性能优化两大核心问题。它允许你在Redis服务器端直接执行自定义的逻辑，而不是把数据拉到客户端处理后再写回去。

核心作用

1. 保证原子性操作

Redis执行Lua脚本时，脚本中的所有命令会作为一个整体被执行，中间不会被其他命令插入。这完美解决了多命令组合操作时的并发安全问题。

经典场景：实现分布式锁、库存扣减、限流计数器等。比如秒杀场景下，检查库存、扣减库存、记录订单这三个操作必须原子执行，用Lua脚本就能确保数据一致性。

2. 减少网络开销

将多个Redis命令合并到一个Lua脚本中，原本需要多次网络请求的操作变成一次请求完成。数据在Redis服务器本地处理，避免了大量数据在客户端和服务器之间来回传输。

3.扩展Redis指令集

你可以用Lua实现Redis原生不支持的复杂业务逻辑。比如自定义数据结构操作、复杂条件判断、循环处理等，让Redis变成一个具备计算能力的"小数据库"。

4. 提高代码复用率

脚本可以被缓存到Redis服务器，客户端通过SHA1摘要重复调用，无需每次都发送完整的脚本代码。多个应用可以共享同一套脚本逻辑

总结

Redis Lua脚本让你能把多个操作打包成一个原子性的、在服务器本地执行的任务，既保证了数据一致性，又提升了性能。特别适合秒杀、分布式锁、计数器、复杂条件更新等需要"读-改-写"原子操作的场景。

二、Lua安装

windows下载地址：https://luabinaries.sourceforge.net/

三、 Lua在Redis中最常用、最经典的几个应用场景

1. 在Redis中操作Lua脚本的常用命令

命令	作用	一句话解释
EVAL	执行给定的Lua脚本	直接把脚本和参数传给Redis运行一次。
SCRIPT LOAD	将脚本缓存到Redis	把脚本存到Redis里，会返回一个SHA1值作为“脚本ID”。
EVALSHA	根据SHA1值执行缓存的脚本	拿着“脚本ID”去执行之前存好的脚本，省流量，效率更高。
SCRIPT EXISTS	检查脚本是否已缓存	看看某个“脚本ID”对应的脚本还在不在Redis里。
SCRIPT KILL	终止正在运行的脚本	如果脚本执行太久卡住了，可以用这个命令尝试杀掉它。
SCRIPT FLUSH	清空所有缓存的脚本	一键清除Redis里缓存的所有脚本，操作要小心\-1。

2. 五大经典应用场景

分布式锁这是Lua脚本在Redis中最经典的应用。获取锁和释放锁的多个步骤必须是一个原子操作，否则会出现并发问题。

获取锁：使用 SET NX PX 命令，一步到位地尝试设置一个带过期时间的键，保证只有一个客户端能拿到锁-8。
释放锁：释放锁时，需要先检查当前持有锁的客户端是否就是自己（通过一个唯一值比如UUID判断），然后再删除锁。这两个动作必须通过Lua脚本一起执行，才能避免误删别人的锁-2 -8。

1-- 安全的释放锁脚本
2-- KEYS[1]: 锁的名称
3-- ARGV[1]: 客户端的唯一标识
4if redis.call("get", KEYS[1]) == ARGV[1] then
5 return redis.call("del", KEYS[1])
6else
7 return 0
8end

原子性计数器单纯的INCR命令是原子的，但如果计数逻辑稍微复杂一点，比如要限制计数上限，就需要Lua了-2。

场景：限制某个用户每分钟只能调用某个接口100次。
实现：在Lua脚本里，你可以先GET当前的计数，判断是否超过阈值，没超过再用INCR增加。这整个“读-判断-写”的过程由Lua保证原子性，避免了在高并发下计数超限的风险。

-- 带阈值的原子计数器
-- KEYS[1]: 计数器键名
-- ARGV[1]: 递增步长
-- ARGV[2]: 最大阈值
local current = tonumber(redis.call('GET', KEYS[1]) or '0')
local new_value = current + tonumber(ARGV[1])

if new_value > tonumber(ARGV[2]) then
 return 0 -- 超过阈值，返回失败
else
 redis.call('SET', KEYS[1], new_value)
 return new_value
end

限流器

在“原子计数器”的基础上，可以轻松实现一个简单的时间窗口限流器。

Redis的一些常见题

Tue, 20 Feb 2024 20:46:01 +0800

Redis的一些常见题

redis数据类型及应用场景 见 Redis的五种数据类型及使用场景
redis持久化及过期策略 见 Redis持久化及过期删除策略
redis 常见问题及解决方案
1. 缓存雪崩：同一时间大量缓存失效，导致请求直接查询数据库，数据库内存和CPU压力增加甚至宕机
  解决：
  热点数据永不过期或者分布到不同实例，降低单机故障问题
  缓存时间添加随机数，防止大量缓存同时失效
  做二级缓存或者双缓存，A为原始缓存短时效，B为备份缓存，长期有效。更新时候双写缓存
2. 缓存穿透：缓存和数据库都没有数据，大量请求下，所有请求直接击穿到数据库，导致宕机。
  解决：
  布隆过滤器:长度为m的位向量或者位列表组成（仅包含0或1位值的列表）
  使用多个不用的hash函数，产生多个索引值，填充对应多个位置的值为1
  布隆过滤器可以检查值是 “可能在集合中” 还是 “绝对不在集合中”
  可能误判但是基础过滤效率高
  极端情况，当布隆过滤器没有空闲位置的时候每次查询返回true
  空缓存（短时效）
  业务层参数过滤
3. 缓存击穿：数据库中有数据，但是缓存突然失效之后发生大量请求导致数据库压力增加甚至打垮宕机
  
  解决：热点数据永不过期
  互斥锁：获取锁之后不管成功还是失败都要释放锁
Redis主从复制原理 Redis 在复制时底层采用的是 psync 命令完成的数据主从同步，同步主要分为：全量复制和增量复制两种
- 全量复制：顾名思义也就是一次性把主节点数据全部发送给从节点，所以这种情况下，当数据量比较大时，会对主节点和网络造成很大的开销。
- 部分复制：用于处理主从复制时因网络中断等原因造成数据丢失的场景。当从节点再次和主节点连接时，主节点会补发丢失的数据。因为是补发，所以在发送的数据量一定是小于全量的数据。
  详细见 Redis的一些常见题
Redis缓存和数据库数据一致性问题：
1. 读数据
  1. 尝试查询缓存，存在缓存则直接返回数据
  2. 缓存不存在时则查询数据库，并保存到缓存（合适设置过期时间），返回数据
2. 写数据
  1. 先更新缓存再更新数据库或者先删除缓存再更新数据库
  2. 先更新数据库再更新缓存或者先更新数据库再删除缓存
  3. 使用删除还是更新？
    1. 这里无非是删除还是更新Redis，直接删除的方式比较简单，在下一次查询时会生成缓存（更推荐）；更新缓存则相较复杂
  4. 先操作Redis还是先操作数据库？
    1. 先操作数据库（推荐）
      - 流程:先更新数据库，再删除缓存
      - 问题：比如线程1执行写操作（修改数据库->删除缓存），线程2执行读操作（查询缓存->旧数据），就会出现旧数据返回，或者删除缓存失败也会返回旧数据
    2. 先操作缓存
      - 流程：修改操作先删除缓存再修改数据库
      - 问题：比如线程1去执行写操作：（删除缓存->更新数据库）同时有线程2执行读操作（查询缓存（未查到缓存）->查数据库->保存到缓存）因为数据库更新有可能网络延迟等问题，这里保存到缓存的数据就是旧的数据，只有再过期之后才会读到新数据
      - 解决方案：（延迟双删）在数据库更新之后再进行一次缓存删除（加适当延迟，比如延迟500ms），这时再有查询过来也会查询到数据库并保存到缓存。但是线程2在这个删除缓存500ms内请求仍然可能会出现一次获取到旧数据（推荐方式）

Redis的数据类型及使用场景

Fri, 01 Sep 2023 20:46:01 +0800

Redis的数据类型及使用场景

一、基本数据类型

1.字符串（String）

string 是 redis 最基本的类型，你可以理解成与 Memcached 一模一样的类型，一个 key 对应一个 value。
string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如 jpg 图片或者序列化的对象。
string 类型是 Redis 最基本的数据类型，string 类型的值最大能存储 512MB。

常用命令：

SET key value 设置指定 key 的值。
GET key 获取指定 key 的值。

应用场景：

String 是最常用的一种数据类型，普通的 key/value 存储都可以归为此类，即可以完全实现目前 Memcached 的功能，并且效率更高。还可以享受 Redis 的定时持久化，操作日志及 Replication 等功能。除了提供与 Memcached 一样的 get、set、incr、decr 等操作外，Redis 还提供了下面一些操作：

获取字符串长度
往字符串 append 内容
设置和获取字符串的某一段内容
设置及获取字符串的某一位（bit）
批量设置一系列字符串的内容

使用场景：

常规 key-value 缓存应用。常规计数：微博数，粉丝数。

实现方式：

String 在 redis 内部存储默认就是一个字符串，被 redisObject 所引用，当遇到 incr,decr 等操作时会转成数值型进行计算，此时 redisObject 的 encoding 字段为 int

Redis事务和锁

Sun, 28 May 2023 22:33:45 +0800

Redis事务

事务是指一个完整的动作，要么全部执行，要么什么也没有做。Redis 事务不是严格意义上的事务，只是用于帮助用户在一个步骤中执行多个命令。单个 Redis 命令的执行是原子性的，但 Redis 没有在事务上增加任何维持原子性的机制，所以 Redis 事务的执行并不是原子性的。

Redis 事务可以理解为一个打包的批量执行脚本，但批量指令并非原子化的操作，中间某条指令的失败不会导致前面已做指令的回滚，也不会造成后续的指令不做。

Redis 的事务不是原子性，但是Redi执行每一个命令都是原子性的

举例：INCR在redis中是自增，即使多个客户端对同一个密钥发出INCR，也永远不会进入竞争状态。例如，客户机1读取“10”，客户机2同时读取“10”，两者都增加到11，并将新值设置为11，这样的情况永远不会发生。最终的值将始终是12。

这个案例是官网提出来的：https://redis.io/docs/data-types/tutorial/

事务一般都是为原子性而生，既然Redis事务没有原子性，那他存在的意义是什么？

redis事务的主要作用就是串联多个命令防止别的命令插队。

官网介绍：https://redis.com.cn/redis-transaction.html

Redis事务 - 基本使用

Redis 在形式上看起来也差不多，MULTI、EXEC、DISCARD这三个指令构成了 redis 事务处理的基础：

MULTI：用来组装一个事务，从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，redis会将之前的命令依次执行。

EXEC：用来执行一个事务

DISCARD：用来取消一个事务

所有的指令在 exec 之前不执行，而是缓存在服务器的一个事务队列中，服务器一旦收到 exec 指令，才开执行整个事务队列，执行完毕后一次性返回所有指令的运行结果。因为 Redis 的单线程特性，不用担心自己在执行队列的时候被其它指令打搅，可以保证他们能得到的有顺序的执行。

取消事务，放弃执行事务块内的所有命令。

组队中某个命令出现了错误报告，执行时整个队列中所有的命令都会被取消。

命令组队的过程中没有问题，执行中出现了错误会导致部分成功部分失败。

悲观锁&乐观锁

悲观锁（Pessimistic Lock），顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人拿到这个数据就会block直到它拿到锁。传统的关系型数据库里面就用到了很多这种锁机制，比如行锁、表锁、读锁、写锁等，都是在做操作之前先上锁。

乐观锁（Optimistic Lock），顾名思义，就是很乐观，每次去那数据的时候都认为别人不会修改，所以不会上锁，但是在修改的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。redis就是使用这种check-and-set机制实现事务的。

watch监听

WATCH：在执行multi之前，先执行watch key1 [key2 …]，可以监视一个或者多个key，若在事务的exec命令之前这些key对应的值被其他命令所改动了，那么事务中所有命令都将被打断，即事务所有操作将被取消执行。

unwatch：取消 WATCH 命令对所有 key 的监视。如果在执行 WATCH 命令之后， EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。

简单示例秒杀场景

 1<?php
 2// 连接Redis
 3$redis = new Redis();
 4$redis->connect('127.0.0.1',6379);
 5
 6$redis->watch('sales');
 7$sales = $redis->get('sales');
 8$store = 10;
 9if($sales >= $store){
10 exit('结束');
11}
12// 事务
13$redis->multi();
14$redis->incr('sales');
15$res = $redis->exec();
16
17if($res){
18 // 库存更新...
19}
20?>

Redis on Leanku 的博客

PHP + Redis实现订单超时

PHP + Redis实现订单超时

一、核心思路

二、详细设计

1. 订单表增加字段

2. 创建订单时：加入超时监控

PHP 实现 Redis 高并发解决方案

PHP 实现 Redis 高并发解决方案

一、缓存加速实现

1. 基本缓存操作

2. 防止缓存穿透

二、 分布式锁实现

1. 基本分布式锁

2. 可重入锁实现

三、队列实现

1. 简单队列

2. 延迟队列

3. Pub/Sub 模式

四、综合应用示例 - 秒杀系统

五、最佳实践建议

1. 连接管理：使用连接池或持久连接

2. 错误处理：添加重试机制

3. 性能优化：使用管道(pipeline)

4. Lua脚本：保证原子性

PHP + Redis秒杀场景

PHP + Redis秒杀场景

一、核心思路

二、详细步骤与代码实现

1. 活动开始前：初始化库存

2. 抢购接口核心：Lua 脚本原子扣减

3. 异步消费队列（如使用 Redis List + PHP 常驻进程）

4. 限流（防止刷单）

Redis分布式锁

Redis分布式锁

一、 Redis锁基础概念

1. 为什么需要Redis锁

2. 基本实现原理

二、Redis锁的实现方式

1. SETNX实现（基本方式）

2. SET扩展参数实现（推荐）

3. RedLock算法（分布式环境）

Redis高可用

Redis高可用

1. 事务机制和IO多路复用

1.1 事务

1.1.1 事务特点

1.1.2 命令

1.2 IO多路复用

2. 持久化和过期淘汰策略

2.1 持久化

2.2 过期键删除策略

Redis主从复制

Redis主从复制

一、什么是Redis主从复制

1. 从复制的架构：

2. Redis为什么需要主从复制？

3. 主从复制的好处：

4. 主从复制的缺点：

二、主从复制的原理

1、主从全量复制的流程：

2、增量复制：

3、断点续传：

Redis持久化及过期删除策略

Redis持久化及过期删除策略

Redis 持久化之RDB和AOF

RDB 详解

Redis分布式

Redis分布式

一、 Redis分布式概述

1. 什么是Redis分布式

1.2 为什么需要Redis分布式

1.3 Redis分布式方案对比

二、 Redis分布式方案搭建

2.1 主从复制搭建

2.2 Redis Sentinel搭建

Redis中的Lua

Redis中的Lua

一. Redis中的Lua脚本的作用

核心作用

二、分布式锁实现

三、 Lua在Redis中最常用、最经典的几个应用场景