diff --git a/internal/pool/conn.go b/internal/pool/conn.go
index 7682aa872..95d83bfde 100644
--- a/internal/pool/conn.go
+++ b/internal/pool/conn.go
@@ -27,16 +27,17 @@ var (
 	errConnNotAvailableForWrite = errors.New("redis: connection not available for write operation")
 )
 
-// getCachedTimeNs returns the current time in nanoseconds from the global cache.
-// This is updated every 50ms by a background goroutine, avoiding expensive syscalls.
-// Max staleness: 50ms.
+// getCachedTimeNs returns the current time in nanoseconds.
+// This function previously used a global cache updated by a background goroutine,
+// but that caused unnecessary CPU usage when the client was idle (ticker waking up
+// the scheduler every 50ms). We now use time.Now() directly, which is fast enough
+// on modern systems (vDSO on Linux) and only adds ~1-2% overhead in extreme
+// high-concurrency benchmarks while eliminating idle CPU usage.
 func getCachedTimeNs() int64 {
-	return globalTimeCache.nowNs.Load()
+	return time.Now().UnixNano()
 }
 
-// GetCachedTimeNs returns the current time in nanoseconds from the global cache.
-// This is updated every 50ms by a background goroutine, avoiding expensive syscalls.
-// Max staleness: 50ms.
+// GetCachedTimeNs returns the current time in nanoseconds.
 // Exported for use by other packages that need fast time access.
 func GetCachedTimeNs() int64 {
 	return getCachedTimeNs()
diff --git a/internal/pool/global_time_cache.go b/internal/pool/global_time_cache.go
deleted file mode 100644
index d7d21ea72..000000000
--- a/internal/pool/global_time_cache.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package pool
-
-import (
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// Global time cache updated every 50ms by background goroutine.
-// This avoids expensive time.Now() syscalls in hot paths like getEffectiveReadTimeout.
-// Max staleness: 50ms, which is acceptable for timeout deadline checks (timeouts are typically 3-30 seconds).
-var globalTimeCache struct {
-	nowNs       atomic.Int64
-	lock        sync.Mutex
-	started     bool
-	stop        chan struct{}
-	subscribers int32
-}
-
-func subscribeToGlobalTimeCache() {
-	globalTimeCache.lock.Lock()
-	globalTimeCache.subscribers += 1
-	globalTimeCache.lock.Unlock()
-}
-
-func unsubscribeFromGlobalTimeCache() {
-	globalTimeCache.lock.Lock()
-	globalTimeCache.subscribers -= 1
-	globalTimeCache.lock.Unlock()
-}
-
-func startGlobalTimeCache() {
-	globalTimeCache.lock.Lock()
-	if globalTimeCache.started {
-		globalTimeCache.lock.Unlock()
-		return
-	}
-
-	globalTimeCache.started = true
-	globalTimeCache.nowNs.Store(time.Now().UnixNano())
-	globalTimeCache.stop = make(chan struct{})
-	globalTimeCache.lock.Unlock()
-	// Start background updater
-	go func(stopChan chan struct{}) {
-		ticker := time.NewTicker(50 * time.Millisecond)
-		defer ticker.Stop()
-
-		for range ticker.C {
-			select {
-			case <-stopChan:
-				return
-			default:
-			}
-			globalTimeCache.nowNs.Store(time.Now().UnixNano())
-		}
-	}(globalTimeCache.stop)
-}
-
-// stopGlobalTimeCache stops the global time cache if there are no subscribers.
-// This should only be called when the last subscriber is removed.
-func stopGlobalTimeCache() {
-	globalTimeCache.lock.Lock()
-	if !globalTimeCache.started || globalTimeCache.subscribers > 0 {
-		globalTimeCache.lock.Unlock()
-		return
-	}
-	globalTimeCache.started = false
-	close(globalTimeCache.stop)
-	globalTimeCache.lock.Unlock()
-}
-
-func init() {
-	startGlobalTimeCache()
-}
diff --git a/internal/pool/pool.go b/internal/pool/pool.go
index 50663d7cb..184321c18 100644
--- a/internal/pool/pool.go
+++ b/internal/pool/pool.go
@@ -178,9 +178,6 @@ func NewConnPool(opt *Options) *ConnPool {
 		p.connsMu.Unlock()
 	}
 
-	startGlobalTimeCache()
-	subscribeToGlobalTimeCache()
-
 	return p
 }
 
@@ -981,9 +978,6 @@ func (p *ConnPool) Close() error {
 		return ErrClosed
 	}
 
-	unsubscribeFromGlobalTimeCache()
-	stopGlobalTimeCache()
-
 	var firstErr error
 	p.connsMu.Lock()
 	for _, cn := range p.conns {