行深膳食-高并发机制

// GetAllWeekReport 周报表聚合接口,并发查询3个报表
// 并发测试:报表3=7.86ms,报表2=7.88ms,报表1=8.39ms(最慢),整体耗时8.39ms,并发生效。
// 原理:goroutine并行执行,总耗时取决于最慢的查询,大幅减少单次请求耗时。
func (s *ReportService) GetAllWeekReport(c *gin.Context) *utils.Response {
	userIDVal, ok := c.Get("user_id")
	if !ok {
		utils.Logger.Warn("聚合报表:未获取user_id")
		return &utils.Response{Code: 401, Msg: "用户未登录(user_id为空)", Data: nil}
	}
	uid, ok := userIDVal.(int)
	if !ok || uid == 0 {
		utils.Logger.Warn("聚合报表:user_id类型错误或为空")
		return &utils.Response{Code: 401, Msg: "用户未登录", Data: nil}
	}

	// 整体接口耗时
	// startAll := time.Now()
	// defer func() {
	// 	costAll := time.Since(startAll)
	// 	utils.Logger.Info("聚合报表【整体耗时】", zap.Int("uid", uid), zap.Duration("total_cost", costAll))
	// }()

	selectedDate := c.Query("selected_date")
	if selectedDate == "" {
		utils.Logger.Warn("聚合报表:selected_date参数为空", zap.Int("uid", uid))
		return &utils.Response{Code: 400, Msg: "selected_date不能为空", Data: nil}
	}
	_, err := time.Parse("2006-01-02", selectedDate)
	if err != nil {
		utils.Logger.Warn("聚合报表:selected_date格式错误", zap.String("selectedDate", selectedDate))
		return &utils.Response{Code: 400, Msg: "selected_date格式错误(需:YYYY-MM-DD)", Data: nil}
	}

	var (
		weeklyRate   []model.FoodReportWeeklyTargetItem
		dailyDetail  []model.FoodReportDailyIntakeItem
		weekDietDays []model.FoodReportWeeklyDietDaysItem
		reqErr       error
		mu           sync.Mutex
		wg           sync.WaitGroup
	)
	wg.Add(3)

	// 协程1 报表1
	go func() {
		defer wg.Done()
		//start := time.Now()
		param := model.FoodReportWeeklyTargetParam{UserID: uid, SelectedDate: selectedDate}
		res, err := s.reportRepo.GetWeeklyTargetCompletionRate(param)
		//cost := time.Since(start)
		//utils.Logger.Info("聚合报表【报表1-周目标达成率】", zap.Int("uid", uid), zap.Duration("cost", cost))

		if err != nil {
			mu.Lock()
			if reqErr == nil {
				reqErr = err
			}
			mu.Unlock()
			return
		}
		weeklyRate = res
	}()

	// 协程2 报表2
	go func() {
		defer wg.Done()
		//start := time.Now()
		param := model.FoodReportDailyIntakeParam{UserID: uid, SelectedDate: selectedDate}
		res, err := s.reportRepo.GetDailyIntakeDetail(param)
		//cost := time.Since(start)
		//utils.Logger.Info("聚合报表【报表2-日摄入明细】", zap.Int("uid", uid), zap.Duration("cost", cost))

		if err != nil {
			mu.Lock()
			if reqErr == nil {
				reqErr = err
			}
			mu.Unlock()
			return
		}
		dailyDetail = res
	}()

	// 协程3 报表3
	go func() {
		defer wg.Done()
		//start := time.Now()
		param := model.FoodReportWeeklyDietDaysParam{UserID: uid, SelectedDate: selectedDate}
		res, err := s.reportRepo.GetWeeklyDietDays(param)
		//cost := time.Since(start)
		//utils.Logger.Info("聚合报表【报表3-本周饮食天数】", zap.Int("uid", uid), zap.Duration("cost", cost))

		if err != nil {
			mu.Lock()
			if reqErr == nil {
				reqErr = err
			}
			mu.Unlock()
			return
		}
		weekDietDays = res
	}()

	wg.Wait()

	if reqErr != nil {
		if errors.Is(reqErr, utils.ErrRecordNotFound) {
			return &utils.Response{
				Code: 404,
				Msg:  "No data found for the given user and date",
				Data: nil,
			}
		}
		utils.Logger.Error("聚合报表查询失败", zap.Int("uid", uid), zap.String("selectedDate", selectedDate), zap.Error(reqErr))
		return &utils.Response{
			Code: 500,
			Msg:  "查询报表数据失败",
			Data: nil,
		}
	}

	result := &model.WeekReportAggResp{
		Report1WeeklyTarget: weeklyRate,
		Report2DailyIntake:  dailyDetail,
		Report3WeekDietDays: weekDietDays,
	}
	return &utils.Response{
		Code: 200,
		Msg:  "查询全部周报表成功",
		Data: result,
	}
}

三个独立子查询拆到三个 goroutine,错误用 mu.Lock() 只保留第一个,最后 wg.Wait() 汇聚。

代价:每个请求的连接占用变成三倍,20 个连接池只能撑 6 个并发聚合请求——所以更早一步我先把推荐量做了缓存,把回源量压下来,并行才不会挤压其他接口的连接。

// ========== 2核2G服务器专属连接池优化(关键) ==========
// 最大打开连接数:2核2G建议20,避免数据库连接耗尽
db.SetMaxOpenConns(20)
// 最大空闲连接数:建议5,保留少量空闲连接复用,减少重建连接开销
db.SetMaxIdleConns(5)
// 空闲连接超时时间:30秒,超时自动关闭,避免占用资源
db.SetConnMaxIdleTime(30 * time.Second)