吃糖牙疼别硬扛,面试必问的异步回调坑
看了一堆教程还是不会写项目？别急，先看看这个。
很多后端工程师在面试时，被问到“如何处理高并发下的异步任务回调”时，往往卡壳。这道题是面试必问的经典场景，它不像 LeetCode 刷题那样有标准答案，而是考察你对系统稳定性、数据一致性的真实理解。
为什么说是“吃糖牙疼”？因为这个问题就像吃糖，当下爽（代码能跑通），但后劲大（线上出 Bug 难排查）。很多开发者习惯用 setTimeout 或简单的 Promise 链来处理异步，在开发环境没毛病，一到生产环境，网络抖动、服务重启，数据就丢了，或者重复执行。
今天咱们不聊虚的，直接拆解这个高频坑。从现象、根源到修复方案，全程代码实战，帮你把这个“糖衣炮弹”彻底拆穿。
坑的现象：看似正常，实则暗藏雷区
想象这样一个场景：你开发了一个支付回调接口。用户支付成功后，第三方支付平台（如支付宝、微信支付）会异步通知你的服务器。你的逻辑是：收到通知 - 验签 - 更新订单状态 - 发送短信通知用户。
在本地测试时，一切正常。请求进来，状态更新，短信发出，完美。
但上线后，运维大哥打来电话：“老板，用户投诉说支付成功了，但订单还是待支付状态，而且没收到短信。”
你查日志，发现回调请求确实收到了，验签也通过了，但数据库里的订单状态没变。更诡异的是，再查一遍，发现同一个订单号收到了两次相同的回调请求，第二次处理时，因为订单状态已经是“已支付”（可能是第一次处理慢，或者并发导致的脏读），逻辑判断出错，直接返回了成功，但后续的短信发送逻辑因为某种异常（比如短信服务商限流）被静默吞掉了。
这就是典型的“吃糖牙疼”。表面看，代码逻辑没问题，try-catch 也加了，Promise 也 await 了。但问题出在幂等性和可靠性上。
更常见的现象是：数据不一致：回调处理了一半，服务器宕机或 OOM 重启，导致部分状态更新，部分未更新。
重复执行：由于网络超时，第三方平台重试发送回调，你的代码没有去重，导致库存扣减两次、积分发两次。
静默失败：异步任务中的某个环节（如发邮件）失败，但因为没有抛出异常或错误处理不完善，导致主流程认为成功，用户无感知。根本原因：同步思维处理异步问题
很多开发者踩坑，是因为潜意识里还在用同步思维处理异步流程。
在同步代码中，A - B - C 是顺序执行的，A 做完才做 B，B 做完才做 C。如果 A 失败了，后面的都不会执行。逻辑清晰，易于调试。
但在异步场景中，A 发起后，可能立即返回，B 和 C 在后台异步执行。这里最大的陷阱是：你无法确定 B 和 C 是否真的完成了，以及它们完成的顺序和状态。
具体到“吃糖牙疼”这个比喻，核心原因有三点：缺乏幂等性设计：
异步回调最大的敌人是“重复”。网络是不可靠的，重试是必然的。如果你的接口不支持幂等（即同一个请求执行一次和执行多次效果相同），那么重复请求就会造成数据错乱。很多初学者会忽略这一点，认为“只要加个唯一索引就行了”，但业务逻辑上的重复（如积分累加）无法靠数据库索引解决。异步任务未持久化状态：
在内存中维护一个 Map 来记录哪些任务已处理，是极其危险的做法。一旦服务重启，内存清空，所有状态丢失。再次收到回调时，系统会认为这是新请求，重新处理，导致重复。错误处理粒度太粗：
很多代码写成这样：
try {await updateOrder();await sendSMS();
} catch (e) {console.log(e);
}这种写法的问题是：如果 updateOrder 成功了，但 sendSMS 失败了，异常被捕获，日志打印了，但订单状态已经是“已支付”，而短信没发。下次重试时，因为订单状态已变，可能跳过 updateOrder，但 sendSMS 还是会失败。整个流程卡在中间，无法自愈。正确写法对比：从“裸奔”到“装甲车”
我们来看两段代码。第一段是典型的“错误写法”，第二段是“正确写法”。
错误写法：简单直接，后患无穷
// ❌ 错误写法：缺乏幂等性，状态易丢失
app.post('/api/payment/callback', async (req, res) = {try {const { orderId, amount, status } = req.body;// 1. 验签 (假设通过)// 2. 查询订单const order = await db.query('SELECT * FROM orders WHERE id = ?', [orderId]);if (!order) {return res.status(404).send('Order not found');}// 3. 更新状态 (问题1: 如果这里成功，但下一步失败，状态就变了)// 问题2: 没有检查订单是否已经处理过，导致重复更新await db.query('UPDATE orders SET status = ? WHERE id = ?', [status, orderId]);// 4. 发送短信 (问题3: 如果这里失败，整个事务回滚吗？不是，因为上面已经commit了)await sendSMS(order.userPhone, '支付成功');res.send('Success');} catch (error) {console.error('Callback error:', error);res.status(500).send('Internal Server Error');}
});问题分析：无幂等判断：如果同一个 orderId 的回调来了两次，第二次依然会执行 UPDATE。虽然 SQL 更新相同值没影响，但如果逻辑是 UPDATE orders SET balance = balance + amount，那就出大事了。
状态不一致：UPDATE 成功后，sendSMS 失败。此时数据库已提交，但业务未完成。重试时，如果业务逻辑依赖“状态变更”来触发后续动作，可能会因为状态已变而跳过某些步骤。
无持久化标记：没有记录“该订单的回调已处理”，依赖数据库状态反推，脆弱且低效。正确写法：幂等 + 持久化 + 事务
// ✅ 正确写法：幂等性 + 状态持久化 + 精细错误处理
const RedisClient = require('redis').createClient();app.post('/api/payment/callback', async (req, res) = {const { orderId, amount, status, transactionId } = req.body;try {// 1. 幂等性检查：使用 Redis 或数据库唯一索引// 假设使用 Redis 做快速去重，TTL 设置为 24 小时const key = `pay:callback:${orderId}:${transactionId}`;const isProcessed = await RedisClient.exists(key);if (isProcessed) {console.log(`Duplicate callback ignored for order: ${orderId}`);return res.send('Success'); // 直接返回成功，避免第三方平台无限重试}// 2. 开启数据库事务const conn = await db.getConnection();await conn.beginTransaction();try {// 3. 查询订单并加锁 (防止并发)const order = await conn.query('SELECT * FROM orders WHERE id = ? FOR UPDATE', [orderId]);if (!order || order.length === 0) {throw new Error('Order not found');}// 4. 业务状态校验if (order[0].status === 'PAID') {// 已经是支付状态，说明之前处理过，或者并发中await conn.commit();await RedisClient.set(key, '1', 'EX', 86400); // 标记已处理return res.send('Success');}// 5. 更新订单状态await conn.query('UPDATE orders SET status = ?, pay_time = NOW() WHERE id = ?', [status, orderId]);// 6. 记录回调日志 (持久化，用于审计和重试)await conn.query('INSERT INTO payment_logs (order_id, transaction_id, status, raw_data) VALUES (?, ?, ?, ?)',[orderId, transactionId, status, JSON.stringify(req.body)]);// 7. 提交事务await conn.commit();// 8. 标记 Redis 幂等键 (放在事务外，防止事务回滚但 Redis 已设置)await RedisClient.set(key, '1', 'EX', 86400);} catch (innerError) {await conn.rollback();throw innerError;} finally {conn.release();}// 9. 异步执行非关键任务 (短信、积分等)，失败不影响主流程// 使用消息队列或独立线程，确保主回调快速返回sendSMSAsync(order.userPhone, '支付成功');res.send('Success');} catch (error) {console.error('Critical callback error:', error);// 关键错误，返回 500，让第三方平台知道处理失败，稍后重试res.status(500).send('Processing failed, will retry');}
});核心改进点：幂等性控制：通过 orderId + transactionId 组合键，在 Redis 中快速去重。即使数据库层面有唯一索引，Redis 能更快拦截重复请求，减少数据库压力。
行级锁 FOR UPDATE：防止并发情况下，两个请求同时读取到“未支付”状态，然后同时更新，导致数据竞争。
事务一致性：将“更新订单”和“插入日志”放在同一个事务中。要么都成功，要么都失败。保证了数据的一致性。
非关键任务解耦：发送短信等辅助操作，不再阻塞主流程。即使短信服务挂了，也不会影响支付状态的确认。这些任务可以通过消息队列（如 RabbitMQ, Kafka）异步处理，失败后自动重试。
明确的错误响应：区分“业务错误”（如订单不存在，返回 404 或 400，不重试）和“系统错误”（如数据库连接超时，返回 500，触发重试）。复现与修复代码：如何在本地模拟“牙疼”
光看代码没用，你得亲手复现这个坑，才知道痛在哪里。
步骤 1：搭建模拟环境
使用 Node.js + Express + MySQL + Redis。数据库初始化：
CREATE TABLE orders (id INT PRIMARY KEY AUTO_INCREMENT,user_phone VARCHAR(20),status VARCHAR(20),balance DECIMAL(10, 2),pay_time DATETIME
);CREATE TABLE payment_logs (id INT PRIMARY KEY AUTO_INCREMENT,order_id INT,transaction_id VARCHAR(50),status VARCHAR(20),raw_data JSON,created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);模拟第三方平台：
写一个脚本，模拟第三方平台发送回调。重点在于并发发送和重复发送。
// simulator.js
const axios = require('axios');async function sendCallback(orderId, txId, count = 3) {for (let i = 0; i count; i++) {// 并发发送 3 个相同的回调await axios.post('http://localhost:3000/api/payment/callback', {orderId: orderId,transactionId: txId,amount: 100.00,status: 'PAID'});}
}// 启动模拟
sendCallback(1, 'TX123456', 5);步骤 2：运行错误代码
运行之前的“错误写法”代码。启动服务后，执行 simulator.js。
观察结果：查看 orders 表，balance 字段可能增加了 5 次（如果逻辑是累加），或者状态被反复更新。
查看日志，发现有 5 次 sendSMS 调用记录。
如果人为制造 sendSMS 失败（如修改手机号为非法格式），你会发现订单状态已经是 PAID，但短信没发。再次手动触发回调，由于状态已变，可能无法重新触发短信逻辑（取决于你的业务代码是否检查状态）。步骤 3：切换为正确代码
将路由处理逻辑替换为“正确写法”。重新运行 simulator.js。
观察结果：Redis 检查：第一个请求进入，Redis 中无键，执行事务，更新订单，插入日志，设置 Redis 键。
后续请求：第 2-5 个请求进入，Redis 中已有键，直接返回 Success，不执行数据库操作。
数据库检查：orders 表中 balance 只增加了一次（或状态只更新了一次）。payment_logs 表中只有一条记录。
短信检查：只发送了一次短信。修复验证：
即使你手动删除 Redis 中的键，模拟 Redis 故障。第一个请求：Redis 无键，执行事务。
第二个请求（并发）：Redis 无键，尝试执行事务。由于 FOR UPDATE 锁，它会等待第一个事务提交。第一个提交后，第二个读取到状态为 PAID，直接提交（无实际更新），返回成功。
结果：依然只处理一次业务逻辑，数据一致。规避建议：建立你的“防糖衣”机制
为了避免在未来项目中再次“吃糖牙疼”，建议遵循以下最佳实践：所有异步回调接口必须实现幂等性：不要依赖客户端去重，服务端必须自己去重。
使用 业务唯一ID + 外部交易号 作为幂等键。
优先使用 Redis 做快速拦截，数据库唯一索引做最终兜底。事务边界要明确：核心状态变更（如订单状态、库存扣减）必须在数据库事务中完成。
非核心操作（如发短信、发积分、记录操作日志）建议移出事务，通过消息队列异步处理。合理使用锁机制：对于并发写操作，使用 SELECT ... FOR UPDATE 或乐观锁（版本号）。
注意锁的粒度，尽量缩小锁的范围，避免长时间持锁导致死锁或性能下降。完善的日志与监控：记录每一次回调的原始数据、处理结果、耗时。
设置告警：如果回调处理失败率超过阈值，或出现大量重复请求，立即通知开发团队。
利用 payment_logs 表进行对账。定期运行脚本，对比本地订单状态与第三方支付平台的状态，发现不一致立即报警。区分“可重试”与“不可重试”错误：可重试：网络超时、数据库连接池满、第三方服务暂时不可用。返回 500 或 503。
不可重试：验签失败、订单不存在、余额不足。返回 400 或 404，并记录详细原因，避免无限重试浪费资源。代码审查重点关注点：是否处理了重复请求？
是否在事务中提交了非核心操作？
是否有并发控制？
错误处理是否细致，是否区分了业务错误和系统错误？你在项目里踩过这个坑吗？
“吃糖牙疼”这个坑，看似简单，实则涉及分布式系统设计的多个核心概念：幂等性、一致性、可用性、并发控制。
很多团队在初期为了赶进度，简化了回调处理逻辑，埋下了隐患。直到用户投诉、财务对账不平，才发现问题，此时修复成本极高，甚至需要数据修补。
你在项目里踩过这个坑吗？ 你是如何设计幂等性的？有没有遇到过 Redis 失效导致重复处理的案例？或者你在处理异步回调时，有没有更巧妙的方案？
评论区聊聊，把你的实战经验分享出来，帮更多人避坑。如果这篇文章对你有启发，记得点赞收藏，面试前再看一遍，保你不慌。 吃糖牙疼别硬扛,面试必问的异步回调坑
吃糖牙疼别硬扛,面试必问的异步回调坑
看了一堆教程还是不会写项目？别急，先看看这个。
很多后端工程师在面试时，被问到“如何处理高并发下的异步任务回调”时，往往卡壳。这道题是面试必问的经典场景，它不像 LeetCode 刷题那样有标准答案，而是考察你对系统稳定性、数据一致性的真实理解。
为什么说是“吃糖牙疼”？因为这个问题就像吃糖，当下爽（代码能跑通），但后劲大（线上出 Bug 难排查）。很多开发者习惯用 setTimeout 或简单的 Promise 链来处理异步，在开发环境没毛病，一到生产环境，网络抖动、服务重启，数据就丢了，或者重复执行。
今天咱们不聊虚的，直接拆解这个高频坑。从现象、根源到修复方案，全程代码实战，帮你把这个“糖衣炮弹”彻底拆穿。
坑的现象：看似正常，实则暗藏雷区
想象这样一个场景：你开发了一个支付回调接口。用户支付成功后，第三方支付平台（如支付宝、微信支付）会异步通知你的服务器。你的逻辑是：收到通知 - 验签 - 更新订单状态 - 发送短信通知用户。
在本地测试时，一切正常。请求进来，状态更新，短信发出，完美。
但上线后，运维大哥打来电话：“老板，用户投诉说支付成功了，但订单还是待支付状态，而且没收到短信。”
你查日志，发现回调请求确实收到了，验签也通过了，但数据库里的订单状态没变。更诡异的是，再查一遍，发现同一个订单号收到了两次相同的回调请求，第二次处理时，因为订单状态已经是“已支付”（可能是第一次处理慢，或者并发导致的脏读），逻辑判断出错，直接返回了成功，但后续的短信发送逻辑因为某种异常（比如短信服务商限流）被静默吞掉了。
这就是典型的“吃糖牙疼”。表面看，代码逻辑没问题，try-catch 也加了，Promise 也 await 了。但问题出在幂等性和可靠性上。
更常见的现象是：数据不一致：回调处理了一半，服务器宕机或 OOM 重启，导致部分状态更新，部分未更新。
重复执行：由于网络超时，第三方平台重试发送回调，你的代码没有去重，导致库存扣减两次、积分发两次。
静默失败：异步任务中的某个环节（如发邮件）失败，但因为没有抛出异常或错误处理不完善，导致主流程认为成功，用户无感知。根本原因：同步思维处理异步问题
很多开发者踩坑，是因为潜意识里还在用同步思维处理异步流程。
在同步代码中，A - B - C 是顺序执行的，A 做完才做 B，B 做完才做 C。如果 A 失败了，后面的都不会执行。逻辑清晰，易于调试。
但在异步场景中，A 发起后，可能立即返回，B 和 C 在后台异步执行。这里最大的陷阱是：你无法确定 B 和 C 是否真的完成了，以及它们完成的顺序和状态。
具体到“吃糖牙疼”这个比喻，核心原因有三点：缺乏幂等性设计：
异步回调最大的敌人是“重复”。网络是不可靠的，重试是必然的。如果你的接口不支持幂等（即同一个请求执行一次和执行多次效果相同），那么重复请求就会造成数据错乱。很多初学者会忽略这一点，认为“只要加个唯一索引就行了”，但业务逻辑上的重复（如积分累加）无法靠数据库索引解决。异步任务未持久化状态：
在内存中维护一个 Map 来记录哪些任务已处理，是极其危险的做法。一旦服务重启，内存清空，所有状态丢失。再次收到回调时，系统会认为这是新请求，重新处理，导致重复。错误处理粒度太粗：
很多代码写成这样：
try {await updateOrder();await sendSMS();
} catch (e) {console.log(e);
}这种写法的问题是：如果 updateOrder 成功了，但 sendSMS 失败了，异常被捕获，日志打印了，但订单状态已经是“已支付”，而短信没发。下次重试时，因为订单状态已变，可能跳过 updateOrder，但 sendSMS 还是会失败。整个流程卡在中间，无法自愈。正确写法对比：从“裸奔”到“装甲车”
我们来看两段代码。第一段是典型的“错误写法”，第二段是“正确写法”。
错误写法：简单直接，后患无穷
// ❌ 错误写法：缺乏幂等性，状态易丢失
app.post('/api/payment/callback', async (req, res) = {try {const { orderId, amount, status } = req.body;// 1. 验签 (假设通过)// 2. 查询订单const order = await db.query('SELECT * FROM orders WHERE id = ?', [orderId]);if (!order) {return res.status(404).send('Order not found');}// 3. 更新状态 (问题1: 如果这里成功，但下一步失败，状态就变了)// 问题2: 没有检查订单是否已经处理过，导致重复更新await db.query('UPDATE orders SET status = ? WHERE id = ?', [status, orderId]);// 4. 发送短信 (问题3: 如果这里失败，整个事务回滚吗？不是，因为上面已经commit了)await sendSMS(order.userPhone, '支付成功');res.send('Success');} catch (error) {console.error('Callback error:', error);res.status(500).send('Internal Server Error');}
});问题分析：无幂等判断：如果同一个 orderId 的回调来了两次，第二次依然会执行 UPDATE。虽然 SQL 更新相同值没影响，但如果逻辑是 UPDATE orders SET balance = balance + amount，那就出大事了。
状态不一致：UPDATE 成功后，sendSMS 失败。此时数据库已提交，但业务未完成。重试时，如果业务逻辑依赖“状态变更”来触发后续动作，可能会因为状态已变而跳过某些步骤。
无持久化标记：没有记录“该订单的回调已处理”，依赖数据库状态反推，脆弱且低效。正确写法：幂等 + 持久化 + 事务
// ✅ 正确写法：幂等性 + 状态持久化 + 精细错误处理
const RedisClient = require('redis').createClient();app.post('/api/payment/callback', async (req, res) = {const { orderId, amount, status, transactionId } = req.body;try {// 1. 幂等性检查：使用 Redis 或数据库唯一索引// 假设使用 Redis 做快速去重，TTL 设置为 24 小时const key = `pay:callback:${orderId}:${transactionId}`;const isProcessed = await RedisClient.exists(key);if (isProcessed) {console.log(`Duplicate callback ignored for order: ${orderId}`);return res.send('Success'); // 直接返回成功，避免第三方平台无限重试}// 2. 开启数据库事务const conn = await db.getConnection();await conn.beginTransaction();try {// 3. 查询订单并加锁 (防止并发)const order = await conn.query('SELECT * FROM orders WHERE id = ? FOR UPDATE', [orderId]);if (!order || order.length === 0) {throw new Error('Order not found');}// 4. 业务状态校验if (order[0].status === 'PAID') {// 已经是支付状态，说明之前处理过，或者并发中await conn.commit();await RedisClient.set(key, '1', 'EX', 86400); // 标记已处理return res.send('Success');}// 5. 更新订单状态await conn.query('UPDATE orders SET status = ?, pay_time = NOW() WHERE id = ?', [status, orderId]);// 6. 记录回调日志 (持久化，用于审计和重试)await conn.query('INSERT INTO payment_logs (order_id, transaction_id, status, raw_data) VALUES (?, ?, ?, ?)',[orderId, transactionId, status, JSON.stringify(req.body)]);// 7. 提交事务await conn.commit();// 8. 标记 Redis 幂等键 (放在事务外，防止事务回滚但 Redis 已设置)await RedisClient.set(key, '1', 'EX', 86400);} catch (innerError) {await conn.rollback();throw innerError;} finally {conn.release();}// 9. 异步执行非关键任务 (短信、积分等)，失败不影响主流程// 使用消息队列或独立线程，确保主回调快速返回sendSMSAsync(order.userPhone, '支付成功');res.send('Success');} catch (error) {console.error('Critical callback error:', error);// 关键错误，返回 500，让第三方平台知道处理失败，稍后重试res.status(500).send('Processing failed, will retry');}
});核心改进点：幂等性控制：通过 orderId + transactionId 组合键，在 Redis 中快速去重。即使数据库层面有唯一索引，Redis 能更快拦截重复请求，减少数据库压力。
行级锁 FOR UPDATE：防止并发情况下，两个请求同时读取到“未支付”状态，然后同时更新，导致数据竞争。
事务一致性：将“更新订单”和“插入日志”放在同一个事务中。要么都成功，要么都失败。保证了数据的一致性。
非关键任务解耦：发送短信等辅助操作，不再阻塞主流程。即使短信服务挂了，也不会影响支付状态的确认。这些任务可以通过消息队列（如 RabbitMQ, Kafka）异步处理，失败后自动重试。
明确的错误响应：区分“业务错误”（如订单不存在，返回 404 或 400，不重试）和“系统错误”（如数据库连接超时，返回 500，触发重试）。复现与修复代码：如何在本地模拟“牙疼”
光看代码没用，你得亲手复现这个坑，才知道痛在哪里。
步骤 1：搭建模拟环境
使用 Node.js + Express + MySQL + Redis。数据库初始化：
CREATE TABLE orders (id INT PRIMARY KEY AUTO_INCREMENT,user_phone VARCHAR(20),status VARCHAR(20),balance DECIMAL(10, 2),pay_time DATETIME
);CREATE TABLE payment_logs (id INT PRIMARY KEY AUTO_INCREMENT,order_id INT,transaction_id VARCHAR(50),status VARCHAR(20),raw_data JSON,created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);模拟第三方平台：
写一个脚本，模拟第三方平台发送回调。重点在于并发发送和重复发送。
// simulator.js
const axios = require('axios');async function sendCallback(orderId, txId, count = 3) {for (let i = 0; i count; i++) {// 并发发送 3 个相同的回调await axios.post('http://localhost:3000/api/payment/callback', {orderId: orderId,transactionId: txId,amount: 100.00,status: 'PAID'});}
}// 启动模拟
sendCallback(1, 'TX123456', 5);步骤 2：运行错误代码
运行之前的“错误写法”代码。启动服务后，执行 simulator.js。
观察结果：查看 orders 表，balance 字段可能增加了 5 次（如果逻辑是累加），或者状态被反复更新。
查看日志，发现有 5 次 sendSMS 调用记录。
如果人为制造 sendSMS 失败（如修改手机号为非法格式），你会发现订单状态已经是 PAID，但短信没发。再次手动触发回调，由于状态已变，可能无法重新触发短信逻辑（取决于你的业务代码是否检查状态）。步骤 3：切换为正确代码
将路由处理逻辑替换为“正确写法”。重新运行 simulator.js。
观察结果：Redis 检查：第一个请求进入，Redis 中无键，执行事务，更新订单，插入日志，设置 Redis 键。
后续请求：第 2-5 个请求进入，Redis 中已有键，直接返回 Success，不执行数据库操作。
数据库检查：orders 表中 balance 只增加了一次（或状态只更新了一次）。payment_logs 表中只有一条记录。
短信检查：只发送了一次短信。修复验证：
即使你手动删除 Redis 中的键，模拟 Redis 故障。第一个请求：Redis 无键，执行事务。
第二个请求（并发）：Redis 无键，尝试执行事务。由于 FOR UPDATE 锁，它会等待第一个事务提交。第一个提交后，第二个读取到状态为 PAID，直接提交（无实际更新），返回成功。
结果：依然只处理一次业务逻辑，数据一致。规避建议：建立你的“防糖衣”机制
为了避免在未来项目中再次“吃糖牙疼”，建议遵循以下最佳实践：所有异步回调接口必须实现幂等性：不要依赖客户端去重，服务端必须自己去重。
使用 业务唯一ID + 外部交易号 作为幂等键。
优先使用 Redis 做快速拦截，数据库唯一索引做最终兜底。事务边界要明确：核心状态变更（如订单状态、库存扣减）必须在数据库事务中完成。
非核心操作（如发短信、发积分、记录操作日志）建议移出事务，通过消息队列异步处理。合理使用锁机制：对于并发写操作，使用 SELECT ... FOR UPDATE 或乐观锁（版本号）。
注意锁的粒度，尽量缩小锁的范围，避免长时间持锁导致死锁或性能下降。完善的日志与监控：记录每一次回调的原始数据、处理结果、耗时。
设置告警：如果回调处理失败率超过阈值，或出现大量重复请求，立即通知开发团队。
利用 payment_logs 表进行对账。定期运行脚本，对比本地订单状态与第三方支付平台的状态，发现不一致立即报警。区分“可重试”与“不可重试”错误：可重试：网络超时、数据库连接池满、第三方服务暂时不可用。返回 500 或 503。
不可重试：验签失败、订单不存在、余额不足。返回 400 或 404，并记录详细原因，避免无限重试浪费资源。代码审查重点关注点：是否处理了重复请求？
是否在事务中提交了非核心操作？
是否有并发控制？
错误处理是否细致，是否区分了业务错误和系统错误？你在项目里踩过这个坑吗？
“吃糖牙疼”这个坑，看似简单，实则涉及分布式系统设计的多个核心概念：幂等性、一致性、可用性、并发控制。
很多团队在初期为了赶进度，简化了回调处理逻辑，埋下了隐患。直到用户投诉、财务对账不平，才发现问题，此时修复成本极高，甚至需要数据修补。
你在项目里踩过这个坑吗？ 你是如何设计幂等性的？有没有遇到过 Redis 失效导致重复处理的案例？或者你在处理异步回调时，有没有更巧妙的方案？
评论区聊聊，把你的实战经验分享出来，帮更多人避坑。如果这篇文章对你有启发，记得点赞收藏，面试前再看一遍，保你不慌。