第一章：Go错误处理链断裂事故（errors.Is/As失效、包装丢失、堆栈截断深度溯源）
Go 的错误处理本应以 errors.Is 和 errors.As 为核心构建可追溯的错误链，但实践中常因不当包装导致链路断裂——上游调用 fmt.Errorf("failed: %w", err) 时若 err 本身已为 *fmt.wrapError 类型，而下游又使用 errors.Unwrap 或非标准包装方式，将导致 errors.Is 匹配失败。
典型断裂场景包括：
- 使用
fmt.Errorf("%v", err)替代%w，彻底丢弃原始错误引用； - 在中间层对错误进行
fmt.Sprintf或 JSON 序列化后再重建错误，切断Unwrap()链； - 第三方库返回未实现
Unwrap() error方法的自定义错误类型，使errors.Is无法递归遍历。
以下代码复现链断裂问题：
package main
import (
"errors"
"fmt"
)
func main() {
original := errors.New("io timeout")
// ❌ 错误：丢失包装语义
wrappedBad := fmt.Errorf("service failed: %v", original) // 无 %w，不可被 Is/As 检测
// ✅ 正确：保留错误链
wrappedGood := fmt.Errorf("service failed: %w", original)
fmt.Println(errors.Is(wrappedBad, original)) // false —— 链已断裂
fmt.Println(errors.Is(wrappedGood, original)) // true
}errors.As 失效往往源于类型断言层级错位：当包装多层后，errors.As(err, &target) 要求 target 类型必须与某一层 Unwrap() 返回值精确匹配。若中间层错误类型未导出或字段私有，断言将失败。
堆栈截断则常见于 runtime.Caller 调用位置不当。标准 fmt.Errorf("%w") 仅保留最内层错误的堆栈；若需全链堆栈，应使用支持 StackTrace() 接口的错误包（如 github.com/pkg/errors 或 Go 1.20+ 的 errors.Join + 自定义 StackTrace() 实现），或在关键节点显式捕获：
func wrapWithStack(err error) error {
pc, file, line, _ := runtime.Caller(1)
return fmt.Errorf("%s:%d %s: %w", file, line, runtime.FuncForPC(pc).Name(), err)
}| 现象 | 根本原因 | 修复建议 |
|---|---|---|
errors.Is 返回 false |
错误链中任一环节缺失 %w |
全链统一使用 %w 包装 |
errors.As 失败 |
目标类型未出现在 Unwrap() 路径 |
检查包装层级，确保目标类型可被逐层解包 |
| 堆栈信息不完整 | 仅依赖默认 fmt.Errorf 行为 |
在入口/边界处注入 runtime.Caller |
第二章：errors.Is与errors.As失效的五大典型场景
2.1 错误类型未实现Unwrap方法导致Is/As匹配失败
Go 1.13 引入的 errors.Is 和 errors.As 依赖错误链的显式展开能力。若自定义错误未实现 Unwrap() error，则无法参与链式匹配。
核心问题表现
errors.Is(err, target)返回false，即使底层错误相等errors.As(err, &target)返回false，无法提取包装的底层错误
正确实现示例
type MyError struct {
msg string
cause error
}
func (e *MyError) Error() string { return e.msg }
func (e *MyError) Unwrap() error { return e.cause } // ✅ 关键：必须返回 cause
Unwrap()必须返回直接包装的错误（或nil），errors.Is才会递归调用它遍历错误链；缺失该方法时，匹配止步于当前错误实例。
匹配行为对比表
| 错误类型 | 实现 Unwrap() |
errors.Is(err, io.EOF) 结果 |
|---|---|---|
fmt.Errorf("x: %w", io.EOF) |
✅ | true |
&MyError{cause: io.EOF} |
❌（未实现） | false |
错误链解析流程
graph TD
A[errors.Is(err, target)] --> B{err implements Unwrap?}
B -->|Yes| C[call err.Unwrap()]
B -->|No| D[compare err == target]
C --> E{Unwrap() returns nil?}
E -->|Yes| D
E -->|No| A2.2 多层包装中非标准错误构造引发As类型断链
当错误被多层包装（如 fmt.Errorf("wrap: %w", err) → errors.Wrap(err, "service") → 自定义 WrappedError{Base: err}），原始错误类型的 As() 断言会因中间层未实现 Unwrap() 或未透传底层错误而失败。
错误链断裂的典型场景
- 包装器未嵌入
error字段或未实现Unwrap() - 使用
fmt.Errorf("%v", err)替代%w，导致错误链截断 - 自定义错误结构体未导出
Unwrap()方法
正确实现示例
type ServiceError struct {
Code int
Err error // 必须导出且实现 Unwrap()
}
func (e *ServiceError) Unwrap() error { return e.Err } // ✅ 支持 As()
func (e *ServiceError) Error() string { return fmt.Sprintf("code=%d: %v", e.Code, e.Err) }逻辑分析：
errors.As()依赖逐层调用Unwrap()向下穿透。若ServiceError.Unwrap()返回nil或未实现，则断链；参数e.Err必须为非 nil 且为可As类型（如*os.PathError）。
| 包装方式 | 是否保留 As 能力 | 原因 |
|---|---|---|
fmt.Errorf("%w", err) |
✅ | 标准语义，自动实现 Unwrap |
fmt.Errorf("%v", err) |
❌ | 字符串化，丢失类型信息 |
errors.Wrap(err, msg) |
✅ | github.com/pkg/errors 实现 Unwrap |
graph TD
A[original *os.PathError] -->|Wrap with %w| B[fmt.wrapError]
B -->|Unwrap| C[ServiceError]
C -->|Unwrap| D[original error]
D -->|As\*os.PathError| E[success]2.3 使用fmt.Errorf(“%w”, err)时未保留原始错误语义
错误包装的常见陷阱
当使用 fmt.Errorf("%w", err) 包装错误时，若原始 err 不实现 Unwrap() 或为 nil，将导致语义丢失：
// ❌ 错误示例：原始错误被静默吞没
func fetchUser(id int) error {
if id <= 0 {
return fmt.Errorf("invalid id: %d", id) // 原始错误无包装
}
if err := db.QueryRow("SELECT ...").Scan(&u); err != nil {
return fmt.Errorf("fetch user failed: %w", err) // ✅ 正确包装
}
return nil
}逻辑分析：
%w要求err非 nil 且实现了error接口；若传入nil，fmt.Errorf返回nil，上层errors.Is()判断失效。
错误链诊断对比
| 场景 | errors.Is(err, sql.ErrNoRows) |
errors.As(err, &e) |
|---|---|---|
直接返回 sql.ErrNoRows |
✅ true | ✅ 成功赋值 |
fmt.Errorf("failed: %w", sql.ErrNoRows) |
✅ true | ✅ 成功赋值 |
fmt.Errorf("failed: %v", sql.ErrNoRows) |
❌ false | ❌ 失败 |
安全包装模式
务必校验非空并优先使用 fmt.Errorf("%w", err)：
- ✅
if err != nil { return fmt.Errorf("context: %w", err) } - ❌
return fmt.Errorf("context: %w", someFunc())（someFunc()可能返回nil）
2.4 自定义错误结构体遗漏Unwrap或Is方法导致链式中断
Go 1.13 引入的错误链（error wrapping）依赖 Unwrap() 和 Is() 方法实现透明遍历与语义匹配。若自定义错误类型未实现二者，errors.Is()、errors.As() 和 fmt.Printf("%+v") 将无法穿透包装层。
常见遗漏场景
- 仅实现
Error() string，忽略Unwrap() - 实现
Unwrap()返回nil而非底层错误 - 忘记为多层嵌套错误提供
Is()的递归判定逻辑
正确实现示例
type ValidationError struct {
Err error
Code string
}
func (e *ValidationError) Error() string { return "validation failed" }
func (e *ValidationError) Unwrap() error { return e.Err } // ✅ 允许链式展开
func (e *ValidationError) Is(target error) bool {
return errors.Is(e.Err, target) // ✅ 递归委托判断
}Unwrap() 返回 e.Err 使 errors.Is(err, io.EOF) 可跨层匹配；Is() 委托调用确保语义一致性。
错误链断裂对比表
| 场景 | errors.Is(err, io.EOF) |
errors.Unwrap(err) |
链式调试可见性 |
|---|---|---|---|
缺 Unwrap |
❌ false | nil | 仅显示顶层错误 |
缺 Is |
❌ false | ✅ 非nil | 匹配失败，但可展开 |
graph TD
A[ValidationError] -->|Unwrap| B[io.EOF]
B -->|Is| C{target == io.EOF?}
C -->|true| D[匹配成功]2.5 context.Cancelled等预定义错误被意外覆盖或重包装
Go 标准库中 context.Canceled 和 context.DeadlineExceeded 是不可导出的变量，但常被误用为值比较目标。当开发者调用 errors.Wrap(err, "...") 或 fmt.Errorf("wrap: %w", err) 包装这些错误时，原始错误类型丢失，导致 errors.Is(err, context.Canceled) 判断失效。
常见误用模式
- ❌
return fmt.Errorf("timeout: %w", ctx.Err()) - ❌
return errors.WithMessage(ctx.Err(), "service timeout") - ✅ 正确：
return ctx.Err()或return errors.Join(ctx.Err(), otherErr)（Go 1.20+）
错误包装对比表
| 包装方式 | 保留 Is(context.Canceled) |
保留 As(*url.Error) |
备注 |
|---|---|---|---|
fmt.Errorf("%w", ctx.Err()) |
✅ | — | Go 1.13+ 支持 %w，语义正确 |
fmt.Errorf("err: %v", ctx.Err()) |
❌ | ❌ | 完全丢失错误链 |
errors.Wrap(ctx.Err(), "...") |
❌ | ❌ | github.com/pkg/errors 不兼容标准 errors.Is |
// 错误示例：破坏错误类型识别
func badHandler(ctx context.Context) error {
select {
case <-time.After(100 * time.Millisecond):
return nil
case <-ctx.Done():
// ❌ 错误：用 fmt.Errorf(%v) 消毁 context.Canceled 的可识别性
return fmt.Errorf("handler cancelled: %v", ctx.Err()) // → string, not *errors.errorString
}
}该写法将 context.Canceled 转为普通字符串错误，errors.Is(err, context.Canceled) 返回 false，破坏上游取消信号处理逻辑。应始终优先使用 %w 或直接返回 ctx.Err()。
graph TD
A[ctx.Done()] --> B{ctx.Err() == context.Canceled?}
B -->|Yes| C[直接返回 ctx.Err()]
B -->|No| D[包装时用 %w]
C --> E[errors.Is OK]
D --> E第三章：错误包装丢失的深层根源
3.1 fmt.Errorf无格式化动词时 silently 丢弃%w导致链断裂
fmt.Errorf 在缺失格式化动词（如 %s, %d, %w）时，会静默忽略 %w 动词，导致错误链意外中断。
错误链断裂示例
err := errors.New("original")
wrapped := fmt.Errorf("context: %w", err) // ✅ 正确：保留链
broken := fmt.Errorf("context", err) // ❌ 错误：%w 被丢弃，err 丢失
fmt.Errorf("context", err)中无%w动词，err参数被完全忽略，返回的 error 不包含Unwrap()方法，链断裂。
关键行为对比
| 调用形式 | 是否保留 Unwrap() |
errors.Is/As 是否生效 |
|---|---|---|
fmt.Errorf("msg: %w", err) |
✅ 是 | ✅ 是 |
fmt.Errorf("msg", err) |
❌ 否 | ❌ 否 |
静默丢弃流程图
graph TD
A[fmt.Errorf(\"msg\", err)] --> B{格式动词中含%w？}
B -->|否| C[忽略所有额外参数]
B -->|是| D[调用 errors.Join 或 wrap]
C --> E[返回 *fmt.wrapError，无 Unwrap]3.2 errors.Join合并错误时未保留各子错误的包装上下文
errors.Join 在 Go 1.20+ 中用于合并多个错误，但其默认行为会扁平化所有子错误，丢失原始 fmt.Errorf("msg: %w", err) 中的包装链。
包装上下文丢失示例
err1 := fmt.Errorf("db timeout: %w", io.ErrUnexpectedEOF)
err2 := fmt.Errorf("cache failure: %w", errors.New("nil response"))
joined := errors.Join(err1, err2)
// joined.Error() → "db timeout: unexpected EOF; cache failure: nil response"
// ❌ err1 的 %w 包装关系（io.ErrUnexpectedEOF 被包装）已不可追溯逻辑分析：errors.Join 内部调用 errors.unwrapAll() 获取底层错误值，再拼接字符串，跳过所有 Unwrap() 链，导致 Is()/As() 判定失效。
对比：手动包装 vs Join
| 方式 | 保留 %w 链 |
支持 errors.Is(e, io.ErrUnexpectedEOF) |
可 As[*os.PathError] |
|---|---|---|---|
fmt.Errorf("combined: %w", err1) |
✅ | ✅ | ✅ |
errors.Join(err1, err2) |
❌ | ❌ | ❌ |
替代方案流程
graph TD
A[多个错误] --> B{需保留包装？}
B -->|是| C[用 fmt.Errorf 包裹 + %w]
B -->|否| D[直接 errors.Join]
C --> E[支持 Is/As/Unwrap]3.3 defer中recover捕获panic后未正确重建错误链
当 recover() 在 defer 中捕获 panic 后，若直接 return err 而未保留原始 panic 的调用栈与因果关系，错误链即断裂。
错误链断裂的典型模式
func riskyOp() error {
defer func() {
if r := recover(); r != nil {
// ❌ 丢失 panic 类型、栈帧及嵌套上下文
err := fmt.Errorf("operation failed: %v", r)
log.Printf("Recovered: %v", err)
// 未 wrap 或 with stack → 链断裂
}
}()
panic("timeout")
return nil
}逻辑分析：fmt.Errorf 仅格式化 panic 值（如字符串 "timeout"），丢弃 runtime.Stack()、panic 类型（*errors.errorString）及原始 panic 发生位置，导致上游无法区分是 timeout 还是 nil pointer。
正确重建错误链的方式
- 使用
errors.WithStack()（github.com/pkg/errors）或 Go 1.20+fmt.Errorf("%w", err)+runtime/debug.Stack() - 必须显式保留 panic 值的类型与栈快照
| 方案 | 是否保留栈 | 是否保留类型 | 是否支持 %w |
|---|---|---|---|
fmt.Errorf("err: %v", r) |
❌ | ❌ | ❌ |
fmt.Errorf("err: %w", r)（r 是 error） |
✅（若 r 实现 Unwrap） | ✅ | ✅ |
errors.WithStack(fmt.Errorf("%v", r)) |
✅ | ❌（转为 string） | ❌ |
graph TD
A[panic “timeout”] --> B[recover() 获取 interface{}]
B --> C{r 是否 error?}
C -->|否| D[强制转 error → 丢失类型/栈]
C -->|是| E[errors.Unwrap + WithStack]
E --> F[完整错误链可追溯]第四章：堆栈追踪截断的四大隐性陷阱
4.1 runtime.Caller在中间层错误包装中未更新PC导致深度丢失
当错误被多层包装（如 fmt.Errorf("wrap: %w", err) 或 errors.Wrap）时，runtime.Caller 仍返回原始调用点的 PC，而非当前包装位置。这导致 errors.Frame 的文件/行号指向错误源头，而非包装语句。
错误包装的典型陷阱
func wrapWithError(err error) error {
// 此处 Caller 返回的是调用 wrapWithError 的位置，而非本行！
pc, _, _, _ := runtime.Caller(1)
frame, _ := runtime.CallersFrames([]uintptr{pc}).Next()
return fmt.Errorf("service failed: %w", err) // frame.File/Line 不反映此行
}
runtime.Caller(1)获取的是调用栈第 1 层（即wrapWithError的调用者），而非当前函数内fmt.Errorf所在行——PC 未随包装动作更新。
关键差异对比
| 场景 | PC 指向位置 | 是否反映包装点 |
|---|---|---|
| 原始 panic | panic() 调用处 |
✅ |
fmt.Errorf("%w") |
外部调用 wrapWithError 处 |
❌ |
errors.WithStack() |
显式捕获 Caller(0) |
✅（需手动） |
修复路径示意
graph TD
A[原始 error] --> B[中间层包装]
B --> C{是否重采 PC？}
C -->|否| D[Frame 深度丢失]
C -->|是| E[Caller\0 → 当前帧]4.2 第三方库使用errors.New或fmt.Errorf硬编码掩盖原始堆栈
当第三方库用 errors.New("failed") 或 fmt.Errorf("failed: %v", err) 包装错误时，原始调用栈信息被彻底丢弃。
错误包装的典型陷阱
// ❌ 隐藏原始堆栈
func parseConfig() error {
if _, err := os.Open("config.yaml"); err != nil {
return errors.New("config load failed") // 堆栈在此截断
}
return nil
}errors.New 创建全新错误，无底层 err 的 StackTrace() 或 Unwrap() 能力，调试时无法追溯到 os.Open 失败位置。
推荐替代方案对比
| 方式 | 保留原始堆栈 | 支持 errors.Is/As |
可读性 |
|---|---|---|---|
errors.New |
❌ | ❌ | ⚠️ 简单但失真 |
fmt.Errorf("%w", err) |
✅ | ✅ | ✅ 结构化 |
fmt.Errorf("msg: %w", err) |
✅ | ✅ | ✅ 上下文丰富 |
正确做法：使用 %w 动词
// ✅ 透传原始错误链
func parseConfig() error {
if _, err := os.Open("config.yaml"); err != nil {
return fmt.Errorf("failed to load config: %w", err) // 保留err完整堆栈
}
return nil
}%w 触发 fmt 包对 error 接口的 Unwrap() 调用，使 errors.Unwrap() 和 errors.Is() 可逐层回溯至原始 os.PathError。
4.3 Go 1.20+ stacktrace包与旧版pkg/errors混用引发帧截断
Go 1.20 引入 runtime/debug.Stack() 与 errors.StackTrace 接口标准化，但 pkg/errors（v0.9.1 及更早）仍依赖私有 stack.Callers 字段直接截取调用栈。
帧截断根源
pkg/errors.WithStack() 默认捕获 32 帧，而 Go 1.20+errors.Unwrap()链中*errors.frame仅保留PC，丢失File:Line上下文- 混用时
fmt.Printf("%+v", err)触发双重格式化，导致runtime.Caller(0)偏移错位
典型复现代码
import (
"errors"
"fmt"
"github.com/pkg/errors" // v0.9.1
)
func risky() error {
return errors.WithStack(errors.New("db timeout"))
}此处
WithStack()内部调用runtime.Callers(2, ...)，但 Go 1.20+errors.Is()处理链时再次调用runtime.Caller()，造成起始帧偏移 +1，最终第 0 帧被跳过。
| 工具链版本 | 帧数保留 | Line info 可见性 |
|---|---|---|
| Go 1.19 + pkg/errors | ✅ 完整 | ✅ |
| Go 1.20 + pkg/errors | ❌ 截断首帧 | ⚠️ 仅 PC |
graph TD
A[risky()] --> B[errors.WithStack]
B --> C[runtime.Callers 2]
C --> D[Go 1.20 errors.Unwrap]
D --> E[runtime.Caller 0]
E --> F[帧偏移+1 → 首帧丢失]4.4 日志中间件拦截错误并调用Error()方法导致stack trace提前销毁
当 HTTP 中间件在 recover() 后直接对 err.(error) 调用 .Error()，会触发 Go 运行时对 *errors.errorString 的字符串化——此时原始 stack trace（含 runtime.Caller 链）尚未被 fmt 或 debug.PrintStack 捕获，即被丢弃。
错误写法示例
func LogMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("panic: %v", err) // ❌ 触发 Error()，trace 丢失
}
}()
next.ServeHTTP(w, r)
})
}
err是*runtime.Func包装的 panic 值，%v格式化强制调用Error()方法，而 Go 1.20+ 默认 panic error 不携带完整 stack（除非显式errors.WithStack或debug.Stack()）。
正确捕获方式
- ✅ 使用
debug.Stack()获取原始 trace - ✅ 用
fmt.Sprintf("%+v", err)（需github.com/pkg/errors） - ✅ 或
log.Printf("panic: %+v\n%s", err, debug.Stack())
| 方案 | 是否保留 trace | 依赖 |
|---|---|---|
log.Printf("%v", err) |
❌ | 无 |
log.Printf("%+v", err) |
✅（需 pkg/errors） | github.com/pkg/errors |
debug.Stack() |
✅ | runtime/debug |
graph TD
A[panic] --> B[recover()]
B --> C{err.Error() called?}
C -->|是| D[stack trace GC'd]
C -->|否| E[debug.Stack() capture]
E --> F[完整 trace 保留]第五章：构建健壮错误处理链的工程实践指南
错误分类与标准化编码体系
在微服务架构中，我们为某金融支付平台定义了三级错误分类：客户端错误（4xx）、服务端错误（5xx）和业务异常（自定义2xx失败码）。所有错误响应强制遵循统一JSON Schema：
{
"code": "PAYMENT_INSUFFICIENT_BALANCE",
"httpStatus": 400,
"message": "账户余额不足",
"traceId": "a1b2c3d4e5f67890",
"details": {"availableBalance": "12.50", "requiredAmount": "150.00"}
}该规范被集成进Swagger OpenAPI 3.0契约，并通过CI流水线中的openapi-validator校验。
分布式追踪驱动的错误根因定位
当订单履约服务连续出现ORDER_TIMEOUT错误时，通过Jaeger追踪发现92%的请求在调用库存服务时超时。进一步分析链路日志发现：库存服务在MySQL主从延迟>5s时未触发熔断，而是持续重试导致雪崩。解决方案是引入Resilience4j配置：
resilience4j.circuitbreaker:
instances:
inventory:
failureRateThreshold: 50
waitDurationInOpenState: 30s
permittedNumberOfCallsInHalfOpenState: 10异步任务的幂等性错误恢复机制
| 电商秒杀场景中，消息队列消费失败需保证补偿操作可重入。我们采用“状态机+唯一业务ID+数据库乐观锁”三重保障： | 步骤 | 操作 | 并发安全机制 |
|---|---|---|---|
| 1 | 查询订单当前状态 | SELECT status, version FROM orders WHERE id = ? FOR UPDATE |
|
| 2 | 校验状态合法性 | 状态流转图约束（如CREATED→PAID→SHIPPED） |
|
| 3 | 更新状态并递增version | UPDATE orders SET status='PAID', version=version+1 WHERE id=? AND version=? |
生产环境错误分级告警策略
基于错误码前缀实现动态告警：
CRITICAL_*（如CRITICAL_DB_CONNECTION_LOST）：立即电话告警+自动触发故障预案脚本BUSINESS_*（如BUSINESS_INVALID_COUPON）：聚合至Grafana面板，每5分钟邮件汇总INFRA_*（如INFRA_KAFKA_OFFSET_LAG_10000）：触发自动扩缩容检查
错误上下文注入最佳实践
在Spring Boot应用中，通过MDC注入关键业务上下文：
MDC.put("userId", currentUser.getId());
MDC.put("orderId", order.getId());
MDC.put("requestId", ServletRequestAttributes.getRequest().getHeader("X-Request-ID"));
// 所有日志自动携带这些字段，便于ELK关联分析全链路错误注入验证流程
每月执行混沌工程演练：
- 使用Chaos Mesh向支付网关Pod注入500ms网络延迟
- 触发1000笔模拟支付请求
- 验证前端展示友好错误提示（非堆栈信息）
- 核查Sentry错误分组是否正确归类为
PAYMENT_GATEWAY_TIMEOUT - 确认补偿任务在30秒内启动并完成状态回滚
客户端错误处理契约化
移动端SDK强制实现错误码映射表，将服务端AUTH_TOKEN_EXPIRED转换为本地LoginRequiredError，并自动触发静默刷新令牌流程，避免用户感知到认证中断。该映射关系通过ProtoBuf定义并版本化管理，确保前后端语义一致。
错误日志结构化采集规范
所有服务日志必须包含level、timestamp、service、spanId、error_code、duration_ms字段，使用Logback的JSONLayout输出：
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="net.logstash.logback.encoder.LogstashEncoder"/>
</appender>ELK集群通过error_code字段建立索引，支持按错误类型聚合统计MTTR（平均修复时间）。
失败事务的Saga模式补偿设计
跨服务转账场景采用Saga协调器：
graph LR
A[转账开始] --> B[扣减转出账户]
B --> C{扣减成功?}
C -->|Yes| D[发起转入请求]
C -->|No| E[触发本地补偿：释放冻结金额]
D --> F{转入成功?}
F -->|Yes| G[事务完成]
F -->|No| H[触发远程补偿：退回转出账户]每个补偿动作具备幂等性标识，且补偿失败时进入人工干预队列。
