diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index 43e97dfa2b0..75f26cfed33 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -371,23 +371,23 @@ func TestPriorityQueue(t *testing.T) {
 	pq.Remove(uint64(1))
 	re.Nil(pq.Get(1))
 	re.Equal(2, pq.Len())
-	entry := pq.Peek()
+	entry := pq.peek()
 	re.Equal(2, entry.Priority)
 	re.Equal(testData[2], entry.Value)
 
 	// case3 update 3's priority to highest
 	pq.Put(-1, testData[3])
-	entry = pq.Peek()
+	entry = pq.peek()
 	re.Equal(-1, entry.Priority)
 	re.Equal(testData[3], entry.Value)
 	pq.Remove(entry.Value.ID())
-	re.Equal(testData[2], pq.Peek().Value)
+	re.Equal(testData[2], pq.peek().Value)
 	re.Equal(1, pq.Len())
 
 	// case4 remove all element
 	pq.Remove(uint64(2))
 	re.Equal(0, pq.Len())
 	re.Empty(pq.items)
-	re.Nil(pq.Peek())
-	re.Nil(pq.Tail())
+	re.Nil(pq.peek())
+	re.Nil(pq.tail())
 }
diff --git a/pkg/cache/priority_queue.go b/pkg/cache/priority_queue.go
index a7ac79090b0..00ccf42c927 100644
--- a/pkg/cache/priority_queue.go
+++ b/pkg/cache/priority_queue.go
@@ -18,17 +18,17 @@ import (
 	"github.com/tikv/pd/pkg/btree"
 )
 
-// defaultDegree default btree degree, the depth is h<log(degree)(capacity+1)/2
+// defaultDegree is default btree degree, the depth is h<log(degree)(capacity+1)/2.
 const defaultDegree = 4
 
-// PriorityQueue queue has priority  and preempt
+// PriorityQueue queue has priority and preempt.
 type PriorityQueue struct {
 	items    map[uint64]*Entry
 	btree    *btree.BTreeG[*Entry]
 	capacity int
 }
 
-// NewPriorityQueue construct of priority queue
+// NewPriorityQueue constructs of priority queue.
 func NewPriorityQueue(capacity int) *PriorityQueue {
 	return &PriorityQueue{
 		items:    make(map[uint64]*Entry),
@@ -37,12 +37,12 @@ func NewPriorityQueue(capacity int) *PriorityQueue {
 	}
 }
 
-// PriorityQueueItem avoid convert cost
+// PriorityQueueItem avoids convert cost.
 type PriorityQueueItem interface {
 	ID() uint64
 }
 
-// Put put value with priority into queue
+// Put puts value with priority into queue.
 func (pq *PriorityQueue) Put(priority int, value PriorityQueueItem) bool {
 	id := value.ID()
 	entry, ok := pq.items[id]
@@ -66,28 +66,30 @@ func (pq *PriorityQueue) Put(priority int, value PriorityQueueItem) bool {
 	return true
 }
 
-// Get find entry by id from queue
+// Get finds entry by id from queue.
 func (pq *PriorityQueue) Get(id uint64) *Entry {
 	return pq.items[id]
 }
 
-// Peek return the highest priority entry
-func (pq *PriorityQueue) Peek() *Entry {
+// peek returns the highest priority entry.
+// It only is used for test.
+func (pq *PriorityQueue) peek() *Entry {
 	if max, ok := pq.btree.Max(); ok {
 		return max
 	}
 	return nil
 }
 
-// Tail return the lowest priority entry
-func (pq *PriorityQueue) Tail() *Entry {
+// tail returns the lowest priority entry.
+// It only is used for test.
+func (pq *PriorityQueue) tail() *Entry {
 	if min, ok := pq.btree.Min(); ok {
 		return min
 	}
 	return nil
 }
 
-// Elems return all elements in queue
+// Elems returns all elements in queue.
 func (pq *PriorityQueue) Elems() []*Entry {
 	rs := make([]*Entry, pq.Len())
 	count := 0
@@ -99,7 +101,7 @@ func (pq *PriorityQueue) Elems() []*Entry {
 	return rs
 }
 
-// Remove remove value from queue
+// Remove removes value from queue.
 func (pq *PriorityQueue) Remove(id uint64) {
 	if v, ok := pq.items[id]; ok {
 		pq.btree.Delete(v)
@@ -107,18 +109,18 @@ func (pq *PriorityQueue) Remove(id uint64) {
 	}
 }
 
-// Len return queue size
+// Len returns queue size.
 func (pq *PriorityQueue) Len() int {
 	return pq.btree.Len()
 }
 
-// Entry a pair of region and it's priority
+// Entry is a pair of region and its priority.
 type Entry struct {
 	Priority int
 	Value    PriorityQueueItem
 }
 
-// Less return true if the entry has smaller priority
+// Less returns true if the entry has smaller priority.
 func (r *Entry) Less(other *Entry) bool {
 	left := r.Priority
 	right := other.Priority
diff --git a/pkg/schedule/checker/checker_controller.go b/pkg/schedule/checker/checker_controller.go
index feea19cca39..f772219558b 100644
--- a/pkg/schedule/checker/checker_controller.go
+++ b/pkg/schedule/checker/checker_controller.go
@@ -15,10 +15,12 @@
 package checker
 
 import (
+	"bytes"
 	"context"
 	"time"
 
 	"github.com/pingcap/failpoint"
+	"github.com/pingcap/log"
 	"github.com/tikv/pd/pkg/cache"
 	"github.com/tikv/pd/pkg/core"
 	"github.com/tikv/pd/pkg/errs"
@@ -28,15 +30,29 @@ import (
 	"github.com/tikv/pd/pkg/schedule/operator"
 	"github.com/tikv/pd/pkg/schedule/placement"
 	"github.com/tikv/pd/pkg/utils/keyutil"
+	"github.com/tikv/pd/pkg/utils/syncutil"
+	"go.uber.org/zap"
 )
 
-// DefaultCacheSize is the default length of waiting list.
-const DefaultCacheSize = 100000
+const (
+	checkSuspectRangesInterval = 100 * time.Millisecond
+	// DefaultPendingRegionCacheSize is the default length of waiting list.
+	DefaultPendingRegionCacheSize = 100000
+	// It takes about 1.3 minutes(1000000/128*10/60/1000) to iterate 1 million regions(with DefaultPatrolRegionInterval=10ms).
+	patrolScanRegionLimit = 128
+	suspectRegionLimit    = 1024
+)
 
-var denyCheckersByLabelerCounter = labeler.LabelerEventCounter.WithLabelValues("checkers", "deny")
+var (
+	// WithLabelValues is a heavy operation, define variable to avoid call it every time.
+	pendingProcessedRegionsGauge = regionListGauge.WithLabelValues("pending_processed_regions")
+	priorityListGauge            = regionListGauge.WithLabelValues("priority_list")
+	denyCheckersByLabelerCounter = labeler.LabelerEventCounter.WithLabelValues("checkers", "deny")
+)
 
 // Controller is used to manage all checkers.
 type Controller struct {
+	ctx                     context.Context
 	cluster                 sche.CheckerCluster
 	conf                    config.CheckerConfigProvider
 	opController            *operator.Controller
@@ -49,12 +65,24 @@ type Controller struct {
 	priorityInspector       *PriorityInspector
 	pendingProcessedRegions cache.Cache
 	suspectKeyRanges        *cache.TTLString // suspect key-range regions that may need fix
+
+	// duration is the duration of the last patrol round.
+	// It's exported, so it should be protected by a mutex.
+	mu struct {
+		syncutil.RWMutex
+		duration time.Duration
+	}
+	// interval is the config interval of patrol regions.
+	// It's used to update the ticker, so we need to
+	// record it to avoid updating the ticker frequently.
+	interval time.Duration
 }
 
 // NewController create a new Controller.
 func NewController(ctx context.Context, cluster sche.CheckerCluster, conf config.CheckerConfigProvider, ruleManager *placement.RuleManager, labeler *labeler.RegionLabeler, opController *operator.Controller) *Controller {
-	pendingProcessedRegions := cache.NewDefaultCache(DefaultCacheSize)
+	pendingProcessedRegions := cache.NewDefaultCache(DefaultPendingRegionCacheSize)
 	return &Controller{
+		ctx:                     ctx,
 		cluster:                 cluster,
 		conf:                    conf,
 		opController:            opController,
@@ -67,10 +95,121 @@ func NewController(ctx context.Context, cluster sche.CheckerCluster, conf config
 		priorityInspector:       NewPriorityInspector(cluster, conf),
 		pendingProcessedRegions: pendingProcessedRegions,
 		suspectKeyRanges:        cache.NewStringTTL(ctx, time.Minute, 3*time.Minute),
+		interval:                cluster.GetCheckerConfig().GetPatrolRegionInterval(),
+	}
+}
+
+// PatrolRegions is used to scan regions.
+// The checkers will check these regions to decide if they need to do some operations.
+func (c *Controller) PatrolRegions() {
+	ticker := time.NewTicker(c.interval)
+	defer ticker.Stop()
+	start := time.Now()
+	var (
+		key     []byte
+		regions []*core.RegionInfo
+	)
+	for {
+		select {
+		case <-ticker.C:
+			c.updateTickerIfNeeded(ticker)
+		case <-c.ctx.Done():
+			patrolCheckRegionsGauge.Set(0)
+			c.setPatrolRegionsDuration(0)
+			return
+		}
+		if c.cluster.IsSchedulingHalted() {
+			continue
+		}
+
+		// Check priority regions first.
+		c.checkPriorityRegions()
+		// Check pending processed regions first.
+		c.checkPendingProcessedRegions()
+
+		key, regions = c.checkRegions(key)
+		if len(regions) == 0 {
+			continue
+		}
+		// Updates the label level isolation statistics.
+		c.cluster.UpdateRegionsLabelLevelStats(regions)
+		// When the key is nil, it means that the scan is finished.
+		if len(key) == 0 {
+			dur := time.Since(start)
+			patrolCheckRegionsGauge.Set(dur.Seconds())
+			c.setPatrolRegionsDuration(dur)
+			start = time.Now()
+		}
+		failpoint.Inject("breakPatrol", func() {
+			failpoint.Break()
+		})
+	}
+}
+
+// GetPatrolRegionsDuration returns the duration of the last patrol region round.
+func (c *Controller) GetPatrolRegionsDuration() time.Duration {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.mu.duration
+}
+
+func (c *Controller) setPatrolRegionsDuration(dur time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.mu.duration = dur
+}
+
+func (c *Controller) checkRegions(startKey []byte) (key []byte, regions []*core.RegionInfo) {
+	regions = c.cluster.ScanRegions(startKey, nil, patrolScanRegionLimit)
+	if len(regions) == 0 {
+		// Resets the scan key.
+		key = nil
+		return
+	}
+
+	for _, region := range regions {
+		c.tryAddOperators(region)
+		key = region.GetEndKey()
+	}
+	return
+}
+
+func (c *Controller) checkPendingProcessedRegions() {
+	ids := c.GetPendingProcessedRegions()
+	pendingProcessedRegionsGauge.Set(float64(len(ids)))
+	for _, id := range ids {
+		region := c.cluster.GetRegion(id)
+		c.tryAddOperators(region)
+	}
+}
+
+// checkPriorityRegions checks priority regions
+func (c *Controller) checkPriorityRegions() {
+	items := c.GetPriorityRegions()
+	removes := make([]uint64, 0)
+	priorityListGauge.Set(float64(len(items)))
+	for _, id := range items {
+		region := c.cluster.GetRegion(id)
+		if region == nil {
+			removes = append(removes, id)
+			continue
+		}
+		ops := c.CheckRegion(region)
+		// it should skip if region needs to merge
+		if len(ops) == 0 || ops[0].Kind()&operator.OpMerge != 0 {
+			continue
+		}
+		if !c.opController.ExceedStoreLimit(ops...) {
+			c.opController.AddWaitingOperator(ops...)
+		}
+	}
+	for _, v := range removes {
+		c.RemovePriorityRegions(v)
 	}
 }
 
 // CheckRegion will check the region and add a new operator if needed.
+// The function is exposed for test purpose.
 func (c *Controller) CheckRegion(region *core.RegionInfo) []*operator.Operator {
 	// If PD has restarted, it needs to check learners added before and promote them.
 	// Don't check isRaftLearnerEnabled cause it maybe disable learner feature but there are still some learners to promote.
@@ -140,6 +279,29 @@ func (c *Controller) CheckRegion(region *core.RegionInfo) []*operator.Operator {
 	return nil
 }
 
+func (c *Controller) tryAddOperators(region *core.RegionInfo) {
+	if region == nil {
+		// the region could be recent split, continue to wait.
+		return
+	}
+	id := region.GetID()
+	if c.opController.GetOperator(id) != nil {
+		c.RemovePendingProcessedRegion(id)
+		return
+	}
+	ops := c.CheckRegion(region)
+	if len(ops) == 0 {
+		return
+	}
+
+	if !c.opController.ExceedStoreLimit(ops...) {
+		c.opController.AddWaitingOperator(ops...)
+		c.RemovePendingProcessedRegion(id)
+	} else {
+		c.AddPendingProcessedRegions(id)
+	}
+}
+
 // GetMergeChecker returns the merge checker.
 func (c *Controller) GetMergeChecker() *MergeChecker {
 	return c.mergeChecker
@@ -181,6 +343,40 @@ func (c *Controller) RemovePriorityRegions(id uint64) {
 	c.priorityInspector.RemovePriorityRegion(id)
 }
 
+// CheckSuspectRanges would pop one suspect key range group
+// The regions of new version key range and old version key range would be placed into
+// the suspect regions map
+func (c *Controller) CheckSuspectRanges() {
+	ticker := time.NewTicker(checkSuspectRangesInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-ticker.C:
+			keyRange, success := c.PopOneSuspectKeyRange()
+			if !success {
+				continue
+			}
+			regions := c.cluster.ScanRegions(keyRange[0], keyRange[1], suspectRegionLimit)
+			if len(regions) == 0 {
+				continue
+			}
+			regionIDList := make([]uint64, 0, len(regions))
+			for _, region := range regions {
+				regionIDList = append(regionIDList, region.GetID())
+			}
+			// if the last region's end key is smaller the keyRange[1] which means there existed the remaining regions between
+			// keyRange[0] and keyRange[1] after scan regions, so we put the end key and keyRange[1] into Suspect KeyRanges
+			lastRegion := regions[len(regions)-1]
+			if lastRegion.GetEndKey() != nil && bytes.Compare(lastRegion.GetEndKey(), keyRange[1]) < 0 {
+				c.AddSuspectKeyRange(lastRegion.GetEndKey(), keyRange[1])
+			}
+			c.AddPendingProcessedRegions(regionIDList...)
+		}
+	}
+}
+
 // AddSuspectKeyRange adds the key range with the its ruleID as the key
 // The instance of each keyRange is like following format:
 // [2][]byte: start key/end key
@@ -233,3 +429,13 @@ func (c *Controller) GetPauseController(name string) (*PauseController, error) {
 		return nil, errs.ErrCheckerNotFound.FastGenByArgs()
 	}
 }
+
+func (c *Controller) updateTickerIfNeeded(ticker *time.Ticker) {
+	// Note: we reset the ticker here to support updating configuration dynamically.
+	newInterval := c.cluster.GetCheckerConfig().GetPatrolRegionInterval()
+	if c.interval != newInterval {
+		c.interval = newInterval
+		ticker.Reset(newInterval)
+		log.Info("checkers starts patrol regions with new interval", zap.Duration("interval", newInterval))
+	}
+}
diff --git a/pkg/schedule/checker/metrics.go b/pkg/schedule/checker/metrics.go
index 85a0ca570a5..1b9c910b968 100644
--- a/pkg/schedule/checker/metrics.go
+++ b/pkg/schedule/checker/metrics.go
@@ -24,10 +24,27 @@ var (
 			Name:      "event_count",
 			Help:      "Counter of checker events.",
 		}, []string{"type", "name"})
+	regionListGauge = prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Namespace: "pd",
+			Subsystem: "checker",
+			Name:      "region_list",
+			Help:      "Number of region about different type.",
+		}, []string{"type"})
+
+	patrolCheckRegionsGauge = prometheus.NewGauge(
+		prometheus.GaugeOpts{
+			Namespace: "pd",
+			Subsystem: "checker",
+			Name:      "patrol_regions_time",
+			Help:      "Time spent of patrol checks region.",
+		})
 )
 
 func init() {
 	prometheus.MustRegister(checkerCounter)
+	prometheus.MustRegister(regionListGauge)
+	prometheus.MustRegister(patrolCheckRegionsGauge)
 }
 
 const (
diff --git a/pkg/schedule/checker/priority_inspector.go b/pkg/schedule/checker/priority_inspector.go
index 0bcbcc810d0..65f9fb5f3dc 100644
--- a/pkg/schedule/checker/priority_inspector.go
+++ b/pkg/schedule/checker/priority_inspector.go
@@ -24,10 +24,10 @@ import (
 	"github.com/tikv/pd/pkg/schedule/placement"
 )
 
-// the default value of priority queue size
+// defaultPriorityQueueSize is the default value of priority queue size.
 const defaultPriorityQueueSize = 1280
 
-// PriorityInspector ensures high priority region should run first
+// PriorityInspector ensures high priority region should run first.
 type PriorityInspector struct {
 	cluster sche.CheckerCluster
 	conf    config.CheckerConfigProvider
@@ -43,19 +43,19 @@ func NewPriorityInspector(cluster sche.CheckerCluster, conf config.CheckerConfig
 	}
 }
 
-// RegionPriorityEntry records region priority info
+// RegionPriorityEntry records region priority info.
 type RegionPriorityEntry struct {
 	Attempt  int
 	Last     time.Time
 	regionID uint64
 }
 
-// ID implement PriorityQueueItem interface
+// ID implements PriorityQueueItem interface.
 func (r RegionPriorityEntry) ID() uint64 {
 	return r.regionID
 }
 
-// NewRegionEntry construct of region priority entry
+// NewRegionEntry constructs a region priority entry.
 func NewRegionEntry(regionID uint64) *RegionPriorityEntry {
 	return &RegionPriorityEntry{regionID: regionID, Last: time.Now(), Attempt: 1}
 }
@@ -73,7 +73,7 @@ func (p *PriorityInspector) Inspect(region *core.RegionInfo) (fit *placement.Reg
 	return
 }
 
-// inspectRegionInPlacementRule inspects region in placement rule mode
+// inspectRegionInPlacementRule inspects region in placement rule mode.
 func (p *PriorityInspector) inspectRegionInPlacementRule(region *core.RegionInfo) (makeupCount int, fit *placement.RegionFit) {
 	fit = p.cluster.GetRuleManager().FitRegion(p.cluster, region)
 	if len(fit.RuleFits) == 0 {
@@ -90,14 +90,14 @@ func (p *PriorityInspector) inspectRegionInPlacementRule(region *core.RegionInfo
 	return
 }
 
-// inspectReplicas inspects region in replica mode
+// inspectReplicas inspects region in replica mode.
 func (p *PriorityInspector) inspectRegionInReplica(region *core.RegionInfo) (makeupCount int) {
 	return p.conf.GetMaxReplicas() - len(region.GetPeers())
 }
 
-// addOrRemoveRegion add or remove region from queue
-// it will remove if region's priority equal 0
-// it's Attempt will increase if region's priority equal last
+// addOrRemoveRegion add or remove region from queue.
+// It will remove if region's priority equal 0.
+// It's Attempt will increase if region's priority equal last.
 func (p *PriorityInspector) addOrRemoveRegion(priority int, regionID uint64) {
 	if priority < 0 {
 		if entry := p.queue.Get(regionID); entry != nil && entry.Priority == priority {
@@ -114,7 +114,7 @@ func (p *PriorityInspector) addOrRemoveRegion(priority int, regionID uint64) {
 	}
 }
 
-// GetPriorityRegions returns all regions in priority queue that needs rerun
+// GetPriorityRegions returns all regions in priority queue that needs rerun.
 func (p *PriorityInspector) GetPriorityRegions() (ids []uint64) {
 	entries := p.queue.Elems()
 	for _, e := range entries {
@@ -128,7 +128,13 @@ func (p *PriorityInspector) GetPriorityRegions() (ids []uint64) {
 	return
 }
 
-// RemovePriorityRegion removes priority region from priority queue
+// RemovePriorityRegion removes priority region from priority queue.
 func (p *PriorityInspector) RemovePriorityRegion(regionID uint64) {
 	p.queue.Remove(regionID)
 }
+
+// getQueueLen returns the length of priority queue.
+// it's only used for test.
+func (p *PriorityInspector) getQueueLen() int {
+	return p.queue.Len()
+}
diff --git a/pkg/schedule/checker/priority_inspector_test.go b/pkg/schedule/checker/priority_inspector_test.go
index 5aef4c01158..5a5d8079d93 100644
--- a/pkg/schedule/checker/priority_inspector_test.go
+++ b/pkg/schedule/checker/priority_inspector_test.go
@@ -49,19 +49,19 @@ func checkPriorityRegionTest(re *require.Assertions, pc *PriorityInspector, tc *
 	region := tc.GetRegion(1)
 	opt := tc.GetCheckerConfig()
 	pc.Inspect(region)
-	re.Equal(0, pc.queue.Len())
+	re.Equal(0, pc.getQueueLen())
 
 	// case2: inspect region 2, it lacks one replica
 	region = tc.GetRegion(2)
 	pc.Inspect(region)
-	re.Equal(1, pc.queue.Len())
+	re.Equal(1, pc.getQueueLen())
 	// the region will not rerun after it checks
 	re.Empty(pc.GetPriorityRegions())
 
 	// case3: inspect region 3, it will has high priority
 	region = tc.GetRegion(3)
 	pc.Inspect(region)
-	re.Equal(2, pc.queue.Len())
+	re.Equal(2, pc.getQueueLen())
 	time.Sleep(opt.GetPatrolRegionInterval() * 10)
 	// region 3 has higher priority
 	ids := pc.GetPriorityRegions()
@@ -73,7 +73,7 @@ func checkPriorityRegionTest(re *require.Assertions, pc *PriorityInspector, tc *
 	tc.AddLeaderRegion(2, 2, 3, 1)
 	region = tc.GetRegion(2)
 	pc.Inspect(region)
-	re.Equal(1, pc.queue.Len())
+	re.Equal(1, pc.getQueueLen())
 
 	// case5: inspect region 3 again
 	region = tc.GetRegion(3)
diff --git a/pkg/schedule/checker/rule_checker.go b/pkg/schedule/checker/rule_checker.go
index bb4a60ead7c..a90de0a58d4 100644
--- a/pkg/schedule/checker/rule_checker.go
+++ b/pkg/schedule/checker/rule_checker.go
@@ -50,23 +50,23 @@ var (
 // RuleChecker fix/improve region by placement rules.
 type RuleChecker struct {
 	PauseController
-	cluster            sche.CheckerCluster
-	ruleManager        *placement.RuleManager
-	regionWaitingList  cache.Cache
-	pendingList        cache.Cache
-	switchWitnessCache *cache.TTLUint64
-	record             *recorder
+	cluster                 sche.CheckerCluster
+	ruleManager             *placement.RuleManager
+	pendingProcessedRegions cache.Cache
+	pendingList             cache.Cache
+	switchWitnessCache      *cache.TTLUint64
+	record                  *recorder
 }
 
 // NewRuleChecker creates a checker instance.
-func NewRuleChecker(ctx context.Context, cluster sche.CheckerCluster, ruleManager *placement.RuleManager, regionWaitingList cache.Cache) *RuleChecker {
+func NewRuleChecker(ctx context.Context, cluster sche.CheckerCluster, ruleManager *placement.RuleManager, pendingProcessedRegions cache.Cache) *RuleChecker {
 	return &RuleChecker{
-		cluster:            cluster,
-		ruleManager:        ruleManager,
-		regionWaitingList:  regionWaitingList,
-		pendingList:        cache.NewDefaultCache(maxPendingListLen),
-		switchWitnessCache: cache.NewIDTTL(ctx, time.Minute, cluster.GetCheckerConfig().GetSwitchWitnessInterval()),
-		record:             newRecord(),
+		cluster:                 cluster,
+		ruleManager:             ruleManager,
+		pendingProcessedRegions: pendingProcessedRegions,
+		pendingList:             cache.NewDefaultCache(maxPendingListLen),
+		switchWitnessCache:      cache.NewIDTTL(ctx, time.Minute, cluster.GetCheckerConfig().GetSwitchWitnessInterval()),
+		record:                  newRecord(),
 	}
 }
 
@@ -637,7 +637,7 @@ func (c *RuleChecker) getRuleFitStores(rf *placement.RuleFit) []*core.StoreInfo
 
 func (c *RuleChecker) handleFilterState(region *core.RegionInfo, filterByTempState bool) {
 	if filterByTempState {
-		c.regionWaitingList.Put(region.GetID(), nil)
+		c.pendingProcessedRegions.Put(region.GetID(), nil)
 		c.pendingList.Remove(region.GetID())
 	} else {
 		c.pendingList.Put(region.GetID(), nil)
diff --git a/pkg/schedule/coordinator.go b/pkg/schedule/coordinator.go
index 1a8a8eb377b..cb935801ce2 100644
--- a/pkg/schedule/coordinator.go
+++ b/pkg/schedule/coordinator.go
@@ -15,7 +15,6 @@
 package schedule
 
 import (
-	"bytes"
 	"context"
 	"strconv"
 	"sync"
@@ -43,27 +42,18 @@ import (
 )
 
 const (
-	runSchedulerCheckInterval  = 3 * time.Second
-	checkSuspectRangesInterval = 100 * time.Millisecond
-	collectTimeout             = 5 * time.Minute
-	maxLoadConfigRetries       = 10
+	runSchedulerCheckInterval = 3 * time.Second
+	collectTimeout            = 5 * time.Minute
+	maxLoadConfigRetries      = 10
 	// pushOperatorTickInterval is the interval try to push the operator.
 	pushOperatorTickInterval = 500 * time.Millisecond
 
-	// It takes about 1.3 minutes(1000000/128*10/60/1000) to iterate 1 million regions(with DefaultPatrolRegionInterval=10ms).
-	patrolScanRegionLimit = 128
 	// PluginLoad means action for load plugin
 	PluginLoad = "PluginLoad"
 	// PluginUnload means action for unload plugin
 	PluginUnload = "PluginUnload"
 )
 
-var (
-	// WithLabelValues is a heavy operation, define variable to avoid call it every time.
-	pendingProcessedRegionsGauge = regionListGauge.WithLabelValues("pending_processed_regions")
-	priorityListGauge            = regionListGauge.WithLabelValues("priority_list")
-)
-
 // Coordinator is used to manage all schedulers and checkers to decide if the region needs to be scheduled.
 type Coordinator struct {
 	syncutil.RWMutex
@@ -73,7 +63,6 @@ type Coordinator struct {
 	cancel context.CancelFunc
 
 	schedulersInitialized bool
-	patrolRegionsDuration time.Duration
 
 	cluster           sche.ClusterInformer
 	prepareChecker    *prepareChecker
@@ -110,22 +99,6 @@ func NewCoordinator(parentCtx context.Context, cluster sche.ClusterInformer, hbS
 	}
 }
 
-// GetPatrolRegionsDuration returns the duration of the last patrol region round.
-func (c *Coordinator) GetPatrolRegionsDuration() time.Duration {
-	if c == nil {
-		return 0
-	}
-	c.RLock()
-	defer c.RUnlock()
-	return c.patrolRegionsDuration
-}
-
-func (c *Coordinator) setPatrolRegionsDuration(dur time.Duration) {
-	c.Lock()
-	defer c.Unlock()
-	c.patrolRegionsDuration = dur
-}
-
 // markSchedulersInitialized marks the scheduler initialization is finished.
 func (c *Coordinator) markSchedulersInitialized() {
 	c.Lock()
@@ -146,106 +119,13 @@ func (c *Coordinator) IsPendingRegion(region uint64) bool {
 }
 
 // PatrolRegions is used to scan regions.
-// The checkers will check these regions to decide if they need to do some operations.
 // The function is exposed for test purpose.
 func (c *Coordinator) PatrolRegions() {
 	defer logutil.LogPanic()
-
 	defer c.wg.Done()
-	ticker := time.NewTicker(c.cluster.GetCheckerConfig().GetPatrolRegionInterval())
-	defer ticker.Stop()
-
 	log.Info("coordinator starts patrol regions")
-	start := time.Now()
-	var (
-		key     []byte
-		regions []*core.RegionInfo
-	)
-	for {
-		select {
-		case <-ticker.C:
-			// Note: we reset the ticker here to support updating configuration dynamically.
-			ticker.Reset(c.cluster.GetCheckerConfig().GetPatrolRegionInterval())
-		case <-c.ctx.Done():
-			patrolCheckRegionsGauge.Set(0)
-			c.setPatrolRegionsDuration(0)
-			log.Info("patrol regions has been stopped")
-			return
-		}
-		if c.cluster.IsSchedulingHalted() {
-			continue
-		}
-
-		// Check priority regions first.
-		c.checkPriorityRegions()
-		// Check pending processed regions first.
-		c.checkPendingProcessedRegions()
-
-		key, regions = c.checkRegions(key)
-		if len(regions) == 0 {
-			continue
-		}
-		// Updates the label level isolation statistics.
-		c.cluster.UpdateRegionsLabelLevelStats(regions)
-		if len(key) == 0 {
-			dur := time.Since(start)
-			patrolCheckRegionsGauge.Set(dur.Seconds())
-			c.setPatrolRegionsDuration(dur)
-			start = time.Now()
-		}
-		failpoint.Inject("break-patrol", func() {
-			failpoint.Break()
-		})
-	}
-}
-
-func (c *Coordinator) checkRegions(startKey []byte) (key []byte, regions []*core.RegionInfo) {
-	regions = c.cluster.ScanRegions(startKey, nil, patrolScanRegionLimit)
-	if len(regions) == 0 {
-		// Resets the scan key.
-		key = nil
-		return
-	}
-
-	for _, region := range regions {
-		c.tryAddOperators(region)
-		key = region.GetEndKey()
-	}
-	return
-}
-
-func (c *Coordinator) checkPendingProcessedRegions() {
-	ids := c.checkers.GetPendingProcessedRegions()
-	pendingProcessedRegionsGauge.Set(float64(len(ids)))
-	for _, id := range ids {
-		region := c.cluster.GetRegion(id)
-		c.tryAddOperators(region)
-	}
-}
-
-// checkPriorityRegions checks priority regions
-func (c *Coordinator) checkPriorityRegions() {
-	items := c.checkers.GetPriorityRegions()
-	removes := make([]uint64, 0)
-	priorityListGauge.Set(float64(len(items)))
-	for _, id := range items {
-		region := c.cluster.GetRegion(id)
-		if region == nil {
-			removes = append(removes, id)
-			continue
-		}
-		ops := c.checkers.CheckRegion(region)
-		// it should skip if region needs to merge
-		if len(ops) == 0 || ops[0].Kind()&operator.OpMerge != 0 {
-			continue
-		}
-		if !c.opController.ExceedStoreLimit(ops...) {
-			c.opController.AddWaitingOperator(ops...)
-		}
-	}
-	for _, v := range removes {
-		c.checkers.RemovePriorityRegions(v)
-	}
+	c.checkers.PatrolRegions()
+	log.Info("patrol regions has been stopped")
 }
 
 // checkSuspectRanges would pop one suspect key range group
@@ -255,60 +135,16 @@ func (c *Coordinator) checkSuspectRanges() {
 	defer logutil.LogPanic()
 	defer c.wg.Done()
 	log.Info("coordinator begins to check suspect key ranges")
-	ticker := time.NewTicker(checkSuspectRangesInterval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-c.ctx.Done():
-			log.Info("check suspect key ranges has been stopped")
-			return
-		case <-ticker.C:
-			keyRange, success := c.checkers.PopOneSuspectKeyRange()
-			if !success {
-				continue
-			}
-			limit := 1024
-			regions := c.cluster.ScanRegions(keyRange[0], keyRange[1], limit)
-			if len(regions) == 0 {
-				continue
-			}
-			regionIDList := make([]uint64, 0, len(regions))
-			for _, region := range regions {
-				regionIDList = append(regionIDList, region.GetID())
-			}
-
-			// if the last region's end key is smaller the keyRange[1] which means there existed the remaining regions between
-			// keyRange[0] and keyRange[1] after scan regions, so we put the end key and keyRange[1] into Suspect KeyRanges
-			lastRegion := regions[len(regions)-1]
-			if lastRegion.GetEndKey() != nil && bytes.Compare(lastRegion.GetEndKey(), keyRange[1]) < 0 {
-				c.checkers.AddSuspectKeyRange(lastRegion.GetEndKey(), keyRange[1])
-			}
-			c.checkers.AddPendingProcessedRegions(regionIDList...)
-		}
-	}
+	c.checkers.CheckSuspectRanges()
+	log.Info("check suspect key ranges has been stopped")
 }
 
-func (c *Coordinator) tryAddOperators(region *core.RegionInfo) {
-	if region == nil {
-		// the region could be recent split, continue to wait.
-		return
-	}
-	id := region.GetID()
-	if c.opController.GetOperator(id) != nil {
-		c.checkers.RemovePendingProcessedRegion(id)
-		return
-	}
-	ops := c.checkers.CheckRegion(region)
-	if len(ops) == 0 {
-		return
-	}
-
-	if !c.opController.ExceedStoreLimit(ops...) {
-		c.opController.AddWaitingOperator(ops...)
-		c.checkers.RemovePendingProcessedRegion(id)
-	} else {
-		c.checkers.AddPendingProcessedRegions(id)
+// GetPatrolRegionsDuration returns the duration of the last patrol region round.
+func (c *Coordinator) GetPatrolRegionsDuration() time.Duration {
+	if c == nil {
+		return 0
 	}
+	return c.checkers.GetPatrolRegionsDuration()
 }
 
 // drivePushOperator is used to push the unfinished operator to the executor.
diff --git a/pkg/schedule/core/cluster_informer.go b/pkg/schedule/core/cluster_informer.go
index b97459d26ea..ce2cf01ed16 100644
--- a/pkg/schedule/core/cluster_informer.go
+++ b/pkg/schedule/core/cluster_informer.go
@@ -30,7 +30,6 @@ type ClusterInformer interface {
 	CheckerCluster
 
 	GetStorage() storage.Storage
-	UpdateRegionsLabelLevelStats(regions []*core.RegionInfo)
 }
 
 // SchedulerCluster is an aggregate interface that wraps multiple interfaces
@@ -43,7 +42,6 @@ type SchedulerCluster interface {
 	GetSchedulerConfig() sc.SchedulerConfigProvider
 	GetRegionLabeler() *labeler.RegionLabeler
 	GetStoreConfig() sc.StoreConfigProvider
-	IsSchedulingHalted() bool
 }
 
 // CheckerCluster is an aggregate interface that wraps multiple interfaces
@@ -52,6 +50,7 @@ type CheckerCluster interface {
 
 	GetCheckerConfig() sc.CheckerConfigProvider
 	GetStoreConfig() sc.StoreConfigProvider
+	UpdateRegionsLabelLevelStats(regions []*core.RegionInfo)
 }
 
 // SharedCluster is an aggregate interface that wraps multiple interfaces
@@ -63,6 +62,7 @@ type SharedCluster interface {
 	GetSharedConfig() sc.SharedConfigProvider
 	GetRuleManager() *placement.RuleManager
 	AllocID() (uint64, error)
+	IsSchedulingHalted() bool
 }
 
 // BasicCluster is an aggregate interface that wraps multiple interfaces
diff --git a/pkg/schedule/metrics.go b/pkg/schedule/metrics.go
index 6927fb1f178..de654846412 100644
--- a/pkg/schedule/metrics.go
+++ b/pkg/schedule/metrics.go
@@ -24,26 +24,8 @@ var (
 			Name:      "status",
 			Help:      "Status of the hotspot.",
 		}, []string{"address", "store", "type"})
-
-	regionListGauge = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Namespace: "pd",
-			Subsystem: "checker",
-			Name:      "region_list",
-			Help:      "Number of region in waiting list",
-		}, []string{"type"})
-
-	patrolCheckRegionsGauge = prometheus.NewGauge(
-		prometheus.GaugeOpts{
-			Namespace: "pd",
-			Subsystem: "checker",
-			Name:      "patrol_regions_time",
-			Help:      "Time spent of patrol checks region.",
-		})
 )
 
 func init() {
 	prometheus.MustRegister(hotSpotStatusGauge)
-	prometheus.MustRegister(regionListGauge)
-	prometheus.MustRegister(patrolCheckRegionsGauge)
 }
diff --git a/server/cluster/cluster_test.go b/server/cluster/cluster_test.go
index 8c89225ffca..cd7f94e001a 100644
--- a/server/cluster/cluster_test.go
+++ b/server/cluster/cluster_test.go
@@ -2843,7 +2843,7 @@ func TestCheckCache(t *testing.T) {
 
 	// Add a peer with two replicas.
 	re.NoError(tc.addLeaderRegion(1, 2, 3))
-	re.NoError(failpoint.Enable("github.com/tikv/pd/pkg/schedule/break-patrol", `return`))
+	re.NoError(failpoint.Enable("github.com/tikv/pd/pkg/schedule/checker/breakPatrol", `return`))
 
 	// case 1: operator cannot be created due to replica-schedule-limit restriction
 	co.GetWaitGroup().Add(1)
@@ -2877,7 +2877,7 @@ func TestCheckCache(t *testing.T) {
 
 	co.GetSchedulersController().Wait()
 	co.GetWaitGroup().Wait()
-	re.NoError(failpoint.Disable("github.com/tikv/pd/pkg/schedule/break-patrol"))
+	re.NoError(failpoint.Disable("github.com/tikv/pd/pkg/schedule/checker/breakPatrol"))
 }
 
 func TestPeerState(t *testing.T) {
diff --git a/server/join/join.go b/server/join/join.go
index 1319dc08d07..6bf111b9b45 100644
--- a/server/join/join.go
+++ b/server/join/join.go
@@ -154,7 +154,7 @@ func PrepareJoinCluster(cfg *config.Config) error {
 
 	var addResp *clientv3.MemberAddResponse
 
-	failpoint.Inject("add-member-failed", func() {
+	failpoint.Inject("addMemberFailed", func() {
 		listMemberRetryTimes = 2
 		failpoint.Goto("LabelSkipAddMember")
 	})
diff --git a/tests/server/api/api_test.go b/tests/server/api/api_test.go
index 234d603b58d..31769d91ffc 100644
--- a/tests/server/api/api_test.go
+++ b/tests/server/api/api_test.go
@@ -595,7 +595,7 @@ func (suite *redirectorTestSuite) SetupSuite() {
 	})
 	re.NoError(err)
 	re.NoError(cluster.RunInitialServers())
-	re.NotEmpty(cluster.WaitLeader(), 0)
+	re.NotEmpty(cluster.WaitLeader())
 	suite.cluster = cluster
 }
 
diff --git a/tests/server/join/join_fail/join_fail_test.go b/tests/server/join/join_fail/join_fail_test.go
index 12774f366f0..0e376281070 100644
--- a/tests/server/join/join_fail/join_fail_test.go
+++ b/tests/server/join/join_fail/join_fail_test.go
@@ -36,9 +36,9 @@ func TestFailedPDJoinInStep1(t *testing.T) {
 	re.NotEmpty(cluster.WaitLeader())
 
 	// Join the second PD.
-	re.NoError(failpoint.Enable("github.com/tikv/pd/server/join/add-member-failed", `return`))
+	re.NoError(failpoint.Enable("github.com/tikv/pd/server/join/addMemberFailed", `return`))
 	_, err = cluster.Join(ctx)
 	re.Error(err)
 	re.Contains(err.Error(), "join failed")
-	re.NoError(failpoint.Disable("github.com/tikv/pd/server/join/add-member-failed"))
+	re.NoError(failpoint.Disable("github.com/tikv/pd/server/join/addMemberFailed"))
 }