composedChain.AddNextChain(behaviors.NormalPreserveChain, 30)        // 30% - 普通预订
composedChain.AddNextChain(behaviors.NormalOrderPayChain, 20)        // 20% - 订单支付
composedChain.AddNextChain(behaviors.OrderConsignChain, 10)          // 10% - 订单托运
composedChain.AddNextChain(behaviors.TicketCollectAndEnterStationChain, 10) // 10% - 取票进站
composedChain.AddNextChain(behaviors.AdvancedSearchChain, 20)        // 20% - 高级搜索
composedChain.AddNextChain(behaviors.ConsignListChain, 8)            // 8%  - 托运列表查询
composedChain.AddNextChain(behaviors.OrderChangeChain, 3)            // 3%  - 改签
composedChain.AddNextChain(behaviors.OrderCancelChain, 2)            // 2%  - 取消订单

func (c *Chain) Execute(ctx *Context) (*NodeResult, error) {
    // ... 执行当前链的节点 ...

    if len(c.nextChains) > 0 {
        randValue := rand.Float64() * c.probabilitySum  // 生成随机值
        cumulative := 0.0
        for _, cp := range c.nextChains {
            cumulative += cp.probability
            if randValue <= cumulative {
                return cp.chain.Execute(ctx)  // 基于概率选择下一个链
            }
        }
    }
    return nil, nil
}

func ChooseRoute(ctx *Context) (*NodeResult, error) {
    allRoutes, _ := routeSvc.QueryAllRoutes()
    randomIndex := rand.Intn(len(allRoutes.Data))  // 随机选择一条路线
    ctx.Set(RouteID, allRoutes.Data[randomIndex].Id)
    ctx.Set(StartStation, allRoutes.Data[randomIndex].StartStation)
    ctx.Set(EndStation, allRoutes.Data[randomIndex].EndStation)
    // ...
}

func QueryContacts(ctx *Context) (*NodeResult, error) {
    GetAllContacts, _ := contactsSvc.GetContactByAccountId(TheAccountId)
    randomIndex := rand.Intn(len(GetAllContacts.Data))  // 随机选择联系人
    ctx.Set(ContactsID, GetAllContacts.Data[randomIndex].Id)
    // ...
}

func QueryAssurance(ctx *Context) (*NodeResult, error) {
    Assurances, _ := cli.GetAllAssuranceTypes()
    randomIndex := rand.Intn(len(Assurances.Data))  // 随机选择保险类型
    ctx.Set(AssuranceTypeIndex, selectedAssurance.Index)
    // ...
}

func QueryTripInfo(ctx *Context) (*NodeResult, error) {
    queryInfoResp, _ := travelSvc.QueryInfo(tripInfo)
    randomIndex := rand.Intn(len(queryInfoResp.Data))  // 随机选择车次
    ctx.Set(TripID, queryInfoResp.Data[randomIndex].TripId)
    // ...
}

func QueryFood(ctx *Context) (*NodeResult, error) {
    foodType := rand.Int()%2 + 1  // 1: 火车餐 或 2: 车站商店
    switch foodType {
    case 1:  // 火车餐食
        idx := rand.Intn(len(allFood.Data.TrainFoodList))
        ctx.Set(FoodName, allFood.Data.TrainFoodList[idx].FoodName)
    case 2:  // 车站商店食品
        for _, v := range allFood.Data.FoodStoreListMap {
            idx := rand.Intn(len(v))
            ctx.Set(FoodName, v[idx].FoodList[rand.Intn(len(v[idx].FoodList))].FoodName)
        }
    }
    ctx.Set(FoodType, foodType)
}

func GetTrainTicketClass() int {
    probability := rand.Intn(100)
    switch {
    case probability < 5:   return 0  // 5%  商务座
    case probability < 20:  return 1  // 15% 一等座
    default:                return 2  // 80% 二等座
    }
}

func GenerateTripId() string {
    letters := []rune{'Z', 'T', 'K', 'G', 'D'}  // 直达/特快/快速/高铁/动车
    startLetter := letters[rand.Intn(len(letters))]
    randomNumber := rand.Intn(1000)
    return fmt.Sprintf("%c%03d", startLetter, randomNumber)
}

func GenerateTrainTypeName() string {
    trainTypes := []string{"GaoTieOne", "GaoTieTwo", "DongCheOne", "ZhiDa", "TeKuai", "KuaiSu"}
    return trainTypes[rand.Intn(len(trainTypes))]
}

func TravelPlanAdvancedSearch(ctx *Context) (*NodeResult, error) {
    switch rand.Intn(3) {
    case 0:  // 最便宜策略
        Resp, _ = travelplanSvc.ReqGetByCheapest(&travelPlanInput)
    case 1:  // 最少经停站策略
        Resp, _ = travelplanSvc.ReqGetByMinStation(&travelPlanInput)
    case 2:  // 最快策略
        Resp, _ = travelplanSvc.ReqGetByQuickest(&travelPlanInput)
    }
}

func init() {
    LoginChain.AddNextChain(NewChain(NewFuncNode(LoginAdmin, "LoginAdmin")), 0.2)      // 20% 管理员
    LoginChain.AddNextChain(NewChain(NewFuncNode(CreateUser, "CreateUser"),
                                     NewFuncNode(LoginNormal, "LoginNormal")), 0.8)  // 80% 普通用户
}

type Context struct {
    ctx context.Context
}

func (c *Context) Set(key string, value interface{}) { ... }
func (c *Context) Get(key string) interface{} { ... }

type LoadGenerator struct {
    config       *Config
    wg           sync.WaitGroup
    ctx          context.Context
    cancel       context.CancelFunc
    sharedClient *service.SvcImpl  // 共享客户端
}

func (l *LoadGenerator) Start() {
    l.wg.Add(l.config.Thread)
    for i := 0; i < l.config.Thread; i++ {
        go l.worker(i)  // 启动多个工作协程
    }
}

func (l *LoadGenerator) worker(index int) {
    defer l.wg.Done()
    for {
        select {
        case <-l.ctx.Done():
            return  // 优雅退出
        default:
            chainCtx := NewContext(context.Background())
            chainCtx.Set(Client, l.sharedClient)
            l.config.Chain.Execute(chainCtx)  // 执行行为链
            time.Sleep(time.Millisecond * time.Duration(l.config.SleepTime))
        }
    }
}