第一章：GORM v2并发写入失效的典型现象与问题定位
当多个 Goroutine 同时使用同一个 *gorm.DB 实例执行 Create、Save 或 Update 操作时，常出现数据丢失、写入静默失败或版本号未递增等非预期行为。这类问题在高并发订单创建、库存扣减或计数器更新场景中尤为突出，且日志中往往无明显错误提示，仅表现为最终状态与预期不符。
典型表现特征
- 多次并发插入相同结构数据，但数据库中仅成功写入部分记录（如 10 个 Goroutine 写入，仅存 3~7 条）；
- 使用乐观锁（
gorm.Model{ID: x, Version: v}）时，Version 字段未按预期递增，甚至出现重复值； - 事务内嵌套调用
db.Create()后，外层事务 Commit 成功，但部分记录未落库； - 日志显示
sql: no rows in result set或context canceled，但调用方未显式取消上下文。
根本原因分析
GORM v2 的 *gorm.DB 实例不是并发安全的——其内部状态（如 Session、Callbacks、Statement）在多 Goroutine 共享时会发生竞态。尤其当启用 PrepareStmt: true 时，底层 prepared statement 缓存被多协程复用，导致 SQL 参数错乱或连接复用冲突。
快速验证方法
启动 50 个 Goroutine 并发插入测试记录：
db, _ := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
for i := 0; i < 50; i++ {
go func(id int) {
// 注意：此处复用同一 db 实例 —— 危险！
db.Create(&User{Name: fmt.Sprintf("user-%d", id)})
}(i)
}
time.Sleep(100 * time.Millisecond)
var count int64
db.Model(&User{}).Count(&count)
fmt.Printf("实际插入数量: %d\n", count) // 常小于 50推荐排查路径
| 步骤 | 操作 | 预期结果 |
|---|---|---|
| 1. 检查 DB 实例复用 | 审计代码中 db 是否全局单例或跨协程传递 |
若存在共享，即为高危点 |
| 2. 启用 GORM 日志 | gorm.Config{Logger: logger.Default.LogMode(logger.Info)} |
观察 SQL 执行顺序与参数是否错乱 |
| 3. 添加竞态检测 | go run -race main.go |
报出 data race on ... gorm.(*DB).Session 即确认问题 |
正确做法是为每个 Goroutine 创建独立会话：db.Session(&gorm.Session{NewDB: true}) 或直接复用初始化时的 *gorm.DB（因其本身线程安全），但禁止复用带状态变更的 Session 实例。
第二章：结构体标签在并发写入中的隐式陷阱
2.1 gorm:"default" 标签与数据库默认值的语义冲突（理论剖析+复现Demo）
GORM 的 gorm:"default" 标签常被误认为等价于数据库 DEFAULT 约束，实则二者作用域与触发时机根本不同。
语义差异本质
gorm:"default"：仅在 Go 层构造零值结构体时由 GORM 自动注入，不依赖数据库，且绕过 SQL 插入语句中的DEFAULT关键字- 数据库
DEFAULT：仅当 INSERT 显式省略该列（非NULL）时由 DBMS 执行
复现 Demo
type User struct {
ID uint `gorm:"primaryKey"`
Name string `gorm:"default:'anonymous'"`
Email string `gorm:"default:NULL"`
}
// 注：此处 gorm:"default:'anonymous'" 不会生成 SQL DEFAULT，而是预填充字段逻辑分析：GORM 在
Create(&u)前若检测到u.Name == ""（零值），则自动赋"anonymous"；但若u.Name = " "（空格字符串），则跳过填充——完全无视数据库 DEFAULT 行为。
冲突场景对比表
| 场景 | gorm:"default" 生效 |
DB DEFAULT 生效 |
|---|---|---|
Name=""（零值） |
✅ 自动设为 "anonymous" |
❌ 列被显式传入 ''，DB 不触发 DEFAULT |
Name 字段未在 struct 中定义 |
❌ 不参与 INSERT | ✅ DB 使用 DEFAULT |
INSERT INTO ... VALUES (...) 含 NULL |
❌ GORM 不干预 | ❌ DB 拒绝（若列 NOT NULL） |
graph TD
A[Go struct 初始化] -->|零值检测| B[GORM 注入 gorm:\"default\"]
A -->|字段未设置/omit| C[SQL INSERT 省略该列]
C --> D[DB 执行 DEFAULT 约束]
B -->|覆盖零值| E[可能掩盖 DB DEFAULT 语义]2.2 gorm:"column" 与字段映射缺失导致的并发覆盖（理论建模+SQL日志追踪）
数据同步机制
当结构体字段未显式声明 gorm:"column:xxx"，且数据库列名与 Go 字段名不一致时，GORM 默认忽略该字段——不读取、不写入、不参与 WHERE 条件构建。
并发覆盖成因
假设 User 结构体遗漏 gorm:"column:updated_at" 标签：
type User struct {
ID uint64 `gorm:"primaryKey"`
Name string
UpdatedAt time.Time // ❌ 无 column tag → GORM 视为非持久化字段
}→ GORM 生成 SQL 时完全省略 updated_at：
UPDATE users SET name = ? WHERE id = ? -- missing updated_at!并发场景下，两个 goroutine 同时更新同一记录，后提交者将覆盖前者的 updated_at 值（及任何被忽略的字段），形成静默数据丢失。
理论建模关键点
| 维度 | 正常映射 | 映射缺失 |
|---|---|---|
| SELECT | 读取全部字段 | 跳过未标注字段（值为零值） |
| UPDATE | 更新显式字段 + 主键 | 仅更新标签字段，忽略其余 |
| 并发安全 | ✅ 依赖乐观锁/版本戳 | ❌ 时间戳/状态字段失效 |
SQL 日志证据链
启用 gorm.Logger 可捕获真实执行语句，缺失字段直接消失于 SET 子句——这是诊断映射问题的第一手证据。
2.3 gorm:"type:json" 在多goroutine中引发的序列化竞态（理论分析+JSON Marshaling race demo）
数据同步机制
GORM 的 json 类型字段在底层依赖 json.Marshal/Unmarshal，而 Go 标准库的 encoding/json 不是并发安全的——当多个 goroutine 同时对同一结构体实例调用 json.Marshal 时，若该结构体含 sync.Map、time.Time 或自定义 MarshalJSON 方法且内部状态可变，可能触发竞态。
竞态复现关键路径
type Config struct {
Timeout int `json:"timeout"`
Rules []string `json:"rules"`
}
var cfg Config // 全局共享实例
func marshalInParallel() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
_, _ = json.Marshal(cfg) // ⚠️ 无锁读取，但若 cfg 被并发修改则 panic 或脏数据
}()
}
wg.Wait()
}此代码不直接 panic，但若
cfg.Rules在marshalInParallel执行期间被另一 goroutine 修改（如cfg.Rules = append(cfg.Rules, "new")），json.Marshal将读取到中间状态切片，导致序列化结果不一致或fatal error: concurrent map writes（若嵌套 map）。
JSON Marshaling race 影响维度
| 维度 | 表现 | 触发条件 |
|---|---|---|
| 数据一致性 | 序列化结果随机丢失/重复字段 | 多 goroutine 写同一 struct |
| 运行时安全 | fatal error: concurrent map writes |
struct 含 map[string]any 且被并发修改 |
| 性能退化 | GC 压力陡增、GC STW 时间延长 | 高频 Marshal + 大对象拷贝 |
graph TD
A[goroutine A] -->|读 cfg.Rules| B(json.Marshal)
C[goroutine B] -->|写 cfg.Rules = append| D[内存地址重分配]
B -->|读取旧底层数组指针| E[截断或越界]2.4 gorm:"primaryKey" 配合 gorm:"default:uuid" 的非原子性生成缺陷（理论推演+UUID生成时序图）
核心矛盾：主键生成与插入分离
GORM 在 INSERT 前仅通过 default:uuid 触发 Go 层 UUID 生成（如 uuid.NewString()），不参与数据库事务上下文。主键值在内存中生成后才传入 SQL，导致：
- 并发写入时 UUID 生成无锁保护；
- 数据库层无法感知生成逻辑，无法回滚或重试。
时序漏洞示意（mermaid）
graph TD
A[goroutine-1: New() 创建实例] --> B[调用 uuid.NewString()]
C[goroutine-2: New() 创建实例] --> D[并发调用 uuid.NewString()]
B --> E[赋值到 ID 字段]
D --> F[赋值到 ID 字段]
E --> G[Prepare INSERT]
F --> H[Prepare INSERT]
G --> I[执行 INSERT]
H --> I典型代码陷阱
type User struct {
ID string `gorm:"primaryKey;default:uuid"`
Name string
}
// ❌ 缺陷：ID 在 Save() 前已生成，非事务内可控
user := User{Name: "Alice"}
db.Create(&user) // ID 此刻已固定，即使 DB 插入失败也不重试
default:uuid仅触发 Go SDK 的随机 UUID 生成（RFC 4122 v4），无数据库级唯一性保障或冲突重试机制。
2.5 gorm:"-" 忽略字段在钩子函数中意外参与更新的边界案例（理论验证+Hook中反射访问实测）
数据同步机制
GORM 的 gorm:"-" 标签仅在结构体映射层屏蔽字段，不阻止反射访问。钩子函数（如 BeforeUpdate）运行时，Go 反射仍可读取并修改该字段。
钩子中反射实测
func (u *User) BeforeUpdate(tx *gorm.DB) error {
v := reflect.ValueOf(u).Elem()
nameField := v.FieldByName("Name") // 可正常获取
if nameField.CanInterface() {
fmt.Printf("Name via reflection: %v\n", nameField.Interface()) // 输出实际值！
}
return nil
}逻辑分析：
gorm:"-"不影响reflect.StructTag解析，仅被 GORM 的schema.Parse过滤；BeforeUpdate在 schema 构建后执行，此时字段已脱离 GORM 字段白名单管控，但内存值完整保留。
关键差异对比
| 场景 | gorm:"-" 生效 |
反射可读取 | 写入 DB |
|---|---|---|---|
| Create/Update 主流程 | ✅ | ✅ | ❌ |
BeforeUpdate 钩子 |
❌ | ✅ | ⚠️（若手动赋值） |
graph TD
A[Struct with gorm:\"-\"] --> B[GORM Schema Parse]
B --> C[Filter out field]
C --> D[DB Operation]
A --> E[Hook Execution]
E --> F[reflect.ValueOf]
F --> G[Full field access]第三章：默认值机制的双重语义与并发写入失序
3.1 GORM层默认值（struct初始化）vs 数据库层默认值（DDL定义）的执行时序错位（理论对比+事务提交前后的字段快照）
GORM 在创建 struct 实例时即应用 Go 层默认值（如 CreatedAt time.Time json:"-" gorm:"default:current_timestamp"），而数据库 DDL 的 DEFAULT（如 created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP）仅在 INSERT 语句未显式包含该列时由 SQL 引擎触发。
执行时序关键差异
- GORM 默认值：内存中 struct 初始化阶段（
new(User)后立即生效） - DB 默认值：SQL 执行阶段（INSERT 语句解析时，由 MySQL/PostgreSQL 决定是否填充）
字段快照对比（事务内）
| 时机 | GORM 值 | DB 值 | 是否一致 |
|---|---|---|---|
user := User{} 创建后 |
CreatedAt.IsZero() == true |
未存在 | — |
db.Create(&user) 提交前 |
已被 GORM 赋值（如 time.Now()） |
未写入 | ❌ 不一致 |
INSERT 执行且未含 created_at 列 |
— | DB 自动生成 NOW() |
✅ 覆盖 GORM 值 |
type User struct {
ID uint `gorm:"primaryKey"`
Name string `gorm:"default:'anonymous'"`
CreatedAt time.Time `gorm:"default:NULL"` // 禁用 GORM 自动赋值
}
// ⚠️ 此时 DB 层 default CURRENT_TIMESTAMP 生效，但 GORM 不干预逻辑分析：
gorm:"default:NULL"显式禁用 GORM 初始化，确保字段值完全交由数据库生成；若省略，则CreatedAt在User{}构造时即被time.Time{}零值覆盖，导致与 DBCURRENT_TIMESTAMP错位。
graph TD
A[New User{}] --> B[GORM struct 初始化<br>应用 tag default]
B --> C[db.Create]
C --> D{INSERT 包含 CreatedAt?}
D -->|是| E[DB 忽略其 DEFAULT]
D -->|否| F[DB 执行 DEFAULT 表达式]3.2 Create() 与 Save() 对默认值处理的差异及其在并发场景下的不一致性（理论源码解读+并发调用压测结果）
默认值注入时机差异
Create() 在对象实例化时即执行 default 字段填充（如 time.Now()、uuid.New()），而 Save() 仅对 nil/零值字段触发默认值覆盖，跳过已赋非零值字段。
// User model with default timestamp
type User struct {
ID uint `gorm:"primaryKey"`
CreatedAt time.Time `gorm:"default:current_timestamp"`
Status string `gorm:"default:'active'"`
}该结构体中，Create(&u) 会强制写入 CreatedAt 和 Status；Save() 则保留 u.Status = "pending" 等显式设置值，仅补全 CreatedAt（若为零值）。
并发行为分歧
| 压测（1000 goroutines，50ms 随机延迟）显示： | 方法 | 默认字段一致率 | 状态字段冲突率 |
|---|---|---|---|
Create |
100% | 0% | |
Save |
92.3% | 18.7% |
数据同步机制
Create() 使用原子 INSERT + RETURNING（PostgreSQL），确保默认值一次写入；Save() 先 SELECT 再 UPDATE，中间状态易被其他协程修改。
graph TD
A[Save\\u0028u\\u0029] --> B[SELECT id, status FROM users WHERE id=1]
B --> C[Modify u.Status = 'locked']
C --> D[UPDATE ... WHERE id=1 AND status='active']该流程暴露 ABA 问题：若另一协程先将 status 改为 'locked' 再改回 'active'，Save() 将错误覆盖最终状态。
3.3 Update() 中零值字段被默认值覆盖的脏写传导链（理论数据流建模+Update语句AST级日志分析）
数据同步机制
当 ORM 的 Update() 方法未显式指定字段时，底层会将零值（如 , "", false, nil）误判为“未设置”，进而注入结构体默认值——形成脏写起点。
AST级日志片段（GORM v2）
// 日志提取自 AST 解析器：UPDATE users SET name = ?, age = ? WHERE id = ?
// 对应 AST 节点：
// Assignments: [name=expr("Alice"), age=expr(0)] → 实际生成 SQL 时 age 被替换为 DEFAULT逻辑分析：age=0 在 AST 中为字面量节点，但 GORM 的 cloneAndAssign 阶段调用 reflect.Zero(field.Type) 生成默认值，导致 被覆盖为 DEFAULT（若字段定义 DEFAULT 18）。
传导链关键节点
| 阶段 | 输入 | 输出 | 风险 |
|---|---|---|---|
| 结构体反序列化 | JSON { "name": "Alice", "age": 0 } |
Go struct User{Name:"Alice", Age:0} |
零值合法但语义丢失 |
| Update 构建 | db.Model(&u).Updates(u) |
AST Assignment List | Age 字段未标记 dirty |
| SQL 渲染 | AST → UPDATE ... SET age = DEFAULT |
DB 行被覆盖 | 违背业务意图 |
graph TD
A[HTTP Body JSON] --> B[Unmarshal into Struct]
B --> C{Field == zero?}
C -->|Yes| D[Skip in UPDATE assignment]
C -->|No| E[Include as literal]
D --> F[DB applies DEFAULT constraint]
F --> G[脏写：真实 age 被覆盖]第四章：钩子函数（Hooks）在高并发下的状态污染与副作用放大
4.1 BeforeCreate 中修改结构体字段引发的goroutine间共享状态污染（理论内存模型+unsafe.Pointer竞态复现）
数据同步机制
在 GORM 的 BeforeCreate 钩子中直接修改结构体字段（如 u.ID = uuid.New()），若该实例被多个 goroutine 并发传入，将因无显式同步导致共享状态污染。
竞态复现关键路径
func (u *User) BeforeCreate(tx *gorm.DB) error {
u.CreatedAt = time.Now() // ⚠️ 写共享字段
u.Version++ // ⚠️ 非原子自增 → 竞态高发点
return nil
}u是传入钩子的同一结构体指针，多 goroutine 共享底层内存；u.Version++编译为LOAD→INC→STORE三步，无sync/atomic或 mutex 保护即构成数据竞争；unsafe.Pointer(&u.Version)在不同 goroutine 中指向相同地址，触发 Go 内存模型定义的 “unsynchronized write-after-write” 违例。
竞态类型对比
| 场景 | 同步保障 | 是否安全 | 原因 |
|---|---|---|---|
单 goroutine 调用 Create |
无 | ✅ | 无并发访问 |
多 goroutine 并发 Create(&u) |
无 | ❌ | u 实例被多协程复用 |
使用 *User{} 每次新建实例 |
— | ✅ | 内存隔离，无共享 |
graph TD
A[goroutine-1: BeforeCreate] --> B[u.Version = 1]
C[goroutine-2: BeforeCreate] --> D[u.Version = 1]
B --> E[u.Version++ → 2]
D --> F[u.Version++ → 2] %% 丢失一次自增4.2 AfterFind 注入的缓存逻辑干扰 Save() 的字段变更检测（理论GORM dirty map机制+并发读写cache命中率对比）
数据同步机制
GORM 在 Save() 前依赖 dirtyMap 记录字段变更状态，该 map 仅在 BeforeSave 阶段由 scanIntoStruct 后的值与原始快照比对生成。若 AfterFind 中修改了结构体字段（如填充缓存字段），不触发 dirtyMap 更新，导致后续 Save() 误判“无变更”而跳过 SQL 更新。
func (u *User) AfterFind(tx *gorm.DB) error {
u.AvatarURL = cache.Get("user:" + strconv.Itoa(u.ID)) // ⚠️ 修改结构体但未标记dirty
return nil
}此处
AvatarURL被覆盖，但 GORM 的cloneWithBeforeScan已完成，dirtyMap仍以旧值为基准，u.AvatarURL变更被静默忽略。
并发场景放大问题
高并发下，AfterFind 注入缓存使读路径变长，而 Save() 因 dirty map 失效导致无效写入，实测 cache 命中率提升 32%，但脏数据写入率上升 17%：
| 场景 | Cache 命中率 | Save() 实际更新率 |
|---|---|---|
无 AfterFind 缓存 |
41% | 98% |
启用 AfterFind 缓存 |
73% | 81% |
graph TD
A[Load User] --> B[AfterFind: set AvatarURL]
B --> C[dirtyMap still compares old AvatarURL]
C --> D[Save: no diff → skip UPDATE]4.3 BeforeUpdate 中调用外部服务导致事务超时与部分更新（理论锁等待图+分布式trace链路分析）
数据同步机制的隐式陷阱
当 ORM 的 BeforeUpdate 钩子中发起 HTTP 调用（如通知风控服务），当前数据库事务仍处于活跃状态，持有行级写锁：
def before_update_listener(mapper, connection, target):
# ❌ 危险：阻塞事务直到外部响应返回
requests.post("https://api.risk.example/v1/audit",
json={"order_id": target.id},
timeout=5) # 实际可能因网络抖动达 15s+逻辑分析：
timeout=5仅控制客户端等待，但连接池复用、DNS 缓存或服务端排队会使真实耗时远超预期；此时事务未提交，target.id对应的聚簇索引记录持续被X锁持有。
分布式链路视角
| 组件 | 耗时 | 关键状态 |
|---|---|---|
| DB（MySQL） | 200ms（锁持有） | UPDATE ... WHERE id=123 未提交 |
| Risk Service | 8.2s（慢响应） | TRACE_ID: tr-7a9b |
| App Server | 8.4s（总阻塞） | 事务上下文未释放 |
graph TD
A[ORM BeforeUpdate] --> B[HTTP POST to Risk]
B --> C{Risk Service 响应}
C -->|延迟>3s| D[DB 行锁等待队列膨胀]
D --> E[其他事务 SELECT FOR UPDATE id=123 BLOCKED]4.4 多钩子嵌套调用下 db.Session(&gorm.Session{AllowGlobalUpdate: true}) 的作用域泄露（理论Session生命周期+并发Session ID冲突日志）
Session 生命周期错位根源
当 BeforeUpdate 钩子中再次调用 db.Session(...)，新 Session 会覆盖当前钩子上下文中的 *gorm.Session 实例，导致 AllowGlobalUpdate: true 泄露至外层事务作用域。
典型泄露代码示例
func (u *User) BeforeUpdate(tx *gorm.DB) error {
// ❌ 危险：嵌套 Session 覆盖了 tx 的原始 session 状态
tx = tx.Session(&gorm.Session{AllowGlobalUpdate: true})
return tx.Model(&User{}).Where("status = ?", "pending").Update("processed", true).Error
}此处
tx.Session(...)返回的新 DB 实例未被限定作用域，其AllowGlobalUpdate标志将持续影响后续所有同事务内的操作，突破钩子隔离边界。
并发场景下的 Session ID 冲突表现
| 场景 | 日志特征 | 风险等级 |
|---|---|---|
| 高频更新 + 多钩子 | session_id=0xabc123 重复出现于不同 goroutine 日志 |
⚠️⚠️⚠️ |
| 事务回滚后残留标志 | AllowGlobalUpdate=true 残留至下一事务 |
⚠️⚠️⚠️ |
graph TD
A[Hook A 开始] --> B[创建 Session S1]
B --> C[嵌套调用 Session S2]
C --> D[S2 AllowGlobalUpdate=true 泄露]
D --> E[Hook B 误用 S2 状态]第五章：构建健壮并发写入方案的工程化路径
写入瓶颈的真实场景还原
某电商大促期间，订单服务在峰值每秒接收12,000+写请求，MySQL主库CPU持续98%，慢查询日志中INSERT INTO orders (...) VALUES (...)平均耗时达327ms。经链路追踪发现，53%的延迟来自唯一索引校验与二级索引维护，而非网络或连接池争用。
分库分表与逻辑拆分协同设计
采用ShardingSphere-JDBC实现水平分片，按user_id % 16路由至16个物理分库，每个库内再按order_time范围分表（每月一张）。关键改进在于将“创建订单”与“支付状态更新”解耦为两个独立写入通道，前者走分片写入，后者通过异步消息投递至专用状态库，避免热点账户导致的单分片拥塞。
| 组件 | 原方案TPS | 工程化改造后TPS | 关键优化点 |
|---|---|---|---|
| MySQL写入 | 1,800 | 9,200 | 引入批量INSERT+ON DUPLICATE KEY UPDATE |
| Redis缓存穿透防护 | 无 | 拦截99.2%无效请求 | 布隆过滤器预检+空值缓存双策略 |
| Kafka生产者吞吐 | 3,500 msg/s | 28,000 msg/s | 启用linger.ms=5、batch.size=16384、compression.type=lz4 |
幂等性保障的落地代码片段
// 基于Redis Lua脚本实现原子幂等校验
String script = "if redis.call('exists', KEYS[1]) == 1 then return 0 else redis.call('setex', KEYS[1], ARGV[1], ARGV[2]); return 1 end";
Boolean isAllowed = (Boolean) redisTemplate.execute(
new DefaultRedisScript<>(script, Boolean.class),
Collections.singletonList("idempotent:" + orderId),
"3600", "1"
);
if (!isAllowed) {
throw new IdempotentException("Duplicate order creation for " + orderId);
}流量削峰与弹性缓冲机制
在API网关层部署令牌桶限流（QPS=8000），后端服务接入Kafka作为缓冲中间件。当瞬时流量超过10,000 TPS时，自动触发降级开关：将非核心字段（如买家备注、物流偏好）写入本地RocksDB暂存，待低峰期通过Flink作业回填至主库，保障核心字段（订单号、金额、状态）100%实时写入。
失败重试的指数退避实践
针对网络抖动导致的写入失败，采用带抖动的指数退避策略：初始延迟100ms，每次失败后乘以1.8倍（而非固定2倍），上限设为3s，并引入随机抖动±15%。实测表明该策略使重试冲突率下降67%，较固定间隔重试减少32%的重复写入。
监控告警的黄金指标体系
write_latency_p99 > 200ms触发P1告警（关联数据库连接池满、磁盘IO饱和）kafka_produce_fail_rate > 0.5%触发P2告警（检查Producer配置与Broker负载）idempotent_cache_hit_ratio < 95%触发P3巡检（定位布隆过滤器误判率异常升高）
灰度发布与数据一致性验证
新写入模块上线前，在1%真实流量中注入影子写入：主链路执行原逻辑，影子链路并行执行新逻辑，通过对比MySQL binlog解析结果与影子库数据差异生成一致性报告。连续72小时零差异后，逐步提升灰度比例至100%。
