实现意外获取Task后重新放回去

internal/infra/task/task.go

@@ -26,6 +26,7 @@ type ProgressTracker struct {
 	runningPlans   map[uint]bool // key: planExecutionLogID, value: true (用作内存锁)
 }
 
+// NewProgressTracker 创建一个新的进度跟踪器
 func NewProgressTracker() *ProgressTracker {
 	t := &ProgressTracker{
 		totalTasks:     make(map[uint]int),
@@ -149,11 +150,11 @@ func (s *Scheduler) run() {
 	}
 }
 
-// claimAndSubmit 实现了“认领-锁定-执行 或 等待-放回”的健壮逻辑
+// claimAndSubmit 实现了最终的“认领-锁定-执行 或 等待-放回”的健壮逻辑
 func (s *Scheduler) claimAndSubmit() {
 	runningPlanIDs := s.progressTracker.GetRunningPlanIDs()
 
-	claimedLog, err := s.pendingTaskRepo.ClaimNextAvailableTask(runningPlanIDs)
+	claimedLog, pendingTask, err := s.pendingTaskRepo.ClaimNextAvailableTask(runningPlanIDs)
 	if err != nil {
 		if !errors.Is(err, gorm.ErrRecordNotFound) {
 			s.logger.Printf("认领任务时发生错误: %v", err)
@@ -171,32 +172,36 @@ func (s *Scheduler) claimAndSubmit() {
 		})
 		if err != nil {
 			s.logger.Printf("向协程池提交任务失败: %v", err)
-			s.progressTracker.Unlock(claimedLog.PlanExecutionLogID) // 提交失败，必须释放刚刚获取的锁
+			// 提交失败，必须释放刚刚获取的锁
+			s.progressTracker.Unlock(claimedLog.PlanExecutionLogID)
 			// 同样需要将任务安全放回
-			s.handleRequeue(claimedLog)
+			s.handleRequeue(pendingTask)
 		}
 	} else {
 		// 获取锁失败，说明有“兄弟”任务正在执行。执行“锁定并安全放回”逻辑。
-		s.handleRequeue(claimedLog)
+		s.handleRequeue(pendingTask)
 	}
 }
 
-// handleRequeue 处理需要被安全放回队列的任务
-func (s *Scheduler) handleRequeue(log *models.TaskExecutionLog) {
-	s.logger.Printf("计划 %d 正在执行，任务 %d 将等待并重新入队...", log.PlanExecutionLogID, log.ID)
+// handleRequeue 同步地、安全地将一个无法立即执行的任务放回队列。
+func (s *Scheduler) handleRequeue(taskToRequeue *models.PendingTask) {
+	planLogID := taskToRequeue.PlanExecutionLogID
+	s.logger.Printf("计划 %d 正在执行，任务 %d (TaskID: %d) 将等待并重新入队...", planLogID, taskToRequeue.ID, taskToRequeue.TaskID)
 
-	// 1. 阻塞式地等待，直到可以获取到该计划的锁
-	s.progressTracker.Lock(log.PlanExecutionLogID)
-	// 2. 在持有锁的情况下，将任务安全地放回队列
-	//    增加一个小的延迟（例如1秒），以避免与主循环发生过于频繁的竞争
-	if err := s.pendingTaskRepo.RequeueTask(log); err != nil {
-		s.logger.Printf("任务重新入队失败, 日志ID: %d, 错误: %v", log.ID, err)
+	// 1. 阻塞式地等待，直到可以获取到该计划的锁。
+	s.progressTracker.Lock(planLogID)
+	defer s.progressTracker.Unlock(planLogID)
+
+	// 2. 在持有锁的情况下，将任务安全地放回队列。
+	if err := s.pendingTaskRepo.RequeueTask(taskToRequeue); err != nil {
+		s.logger.Printf("[严重] 任务重新入队失败, 原始PendingTaskID: %d, 错误: %v", taskToRequeue.ID, err)
+		return
 	}
-	// 3. 释放锁，让其他等待的任务（或主循环）可以继续
-	s.progressTracker.Unlock(log.PlanExecutionLogID)
+
+	s.logger.Printf("任务 (原始ID: %d) 已成功重新入队，并已释放计划 %d 的锁。", taskToRequeue.ID, planLogID)
 }
 
-// processTask 处理单个任务的逻辑 (保持不变)
+// processTask 处理单个任务的逻辑 (当前为占位符)
 func (s *Scheduler) processTask(claimedLog *models.TaskExecutionLog) {
 	s.logger.Printf("开始处理任务, 日志ID: %d, 任务ID: %d, 任务名称: %s",
 		claimedLog.ID, claimedLog.TaskID, claimedLog.Task.Name)