feat: 添加过载保护、背压和熔断机制

internal/scheduler/backpressure.go

@@ -0,0 +1,92 @@
+package scheduler
+
+import (
+	"sync/atomic"
+)
+
+// BackpressureManager tracks system load and provides admission control.
+// Level 1 (70%): accept but log warning
+// Level 2 (85%): accept only high priority (P0-P1)
+// Level 3 (95%): reject all new requests
+type BackpressureManager struct {
+	maxRunning  int64
+	maxQueued   int64
+	level1Threshold float64
+	level2Threshold float64
+	level3Threshold float64
+
+	runningCount int64 // atomic
+	queuedCount  int64 // atomic
+}
+
+// NewBackpressureManager creates a new backpressure manager.
+func NewBackpressureManager(maxRunning, maxQueued int, l1, l2, l3 float64) *BackpressureManager {
+	return &BackpressureManager{
+		maxRunning:      int64(maxRunning),
+		maxQueued:       int64(maxQueued),
+		level1Threshold: l1,
+		level2Threshold: l2,
+		level3Threshold: l3,
+	}
+}
+
+// Update sets the current running and queued counts.
+func (bp *BackpressureManager) Update(running, queued int) {
+	atomic.StoreInt64(&bp.runningCount, int64(running))
+	atomic.StoreInt64(&bp.queuedCount, int64(queued))
+}
+
+// LoadRatio returns the current system load ratio (0.0 to 1.0).
+func (bp *BackpressureManager) LoadRatio() float64 {
+	running := atomic.LoadInt64(&bp.runningCount)
+	queued := atomic.LoadInt64(&bp.queuedCount)
+	total := running + queued
+	capacity := bp.maxRunning + bp.maxQueued
+	if capacity == 0 {
+		return 0
+	}
+	return float64(total) / float64(capacity)
+}
+
+// Level returns the current backpressure level (0=normal, 1=warning, 2=restricted, 3=reject).
+func (bp *BackpressureManager) Level() int {
+	load := bp.LoadRatio()
+	if load >= bp.level3Threshold {
+		return 3
+	}
+	if load >= bp.level2Threshold {
+		return 2
+	}
+	if load >= bp.level1Threshold {
+		return 1
+	}
+	return 0
+}
+
+// ShouldAccept decides whether to accept a request based on priority and load.
+// priority: 0=P0(highest) to 4=P4(lowest)
+func (bp *BackpressureManager) ShouldAccept(priority int) bool {
+	level := bp.Level()
+	switch level {
+	case 0, 1:
+		return true
+	case 2:
+		// Only accept P0 and P1
+		return priority <= 1
+	case 3:
+		return false
+	}
+	return true
+}
+
+// RejectReason returns a human-readable reason if the request should be rejected.
+func (bp *BackpressureManager) RejectReason(priority int) string {
+	level := bp.Level()
+	if level == 3 {
+		return "system overloaded, please retry later"
+	}
+	if level == 2 && priority > 1 {
+		return "backpressure active, only high-priority requests accepted"
+	}
+	return ""
+}