diff --git a/pkg/kubelet/container/runtime_cache.go b/pkg/kubelet/container/runtime_cache.go
index 41307854033..0926107da5a 100644
--- a/pkg/kubelet/container/runtime_cache.go
+++ b/pkg/kubelet/container/runtime_cache.go
@@ -23,8 +23,7 @@ import (
 
 var (
 	// TODO(yifan): Maybe set the them as parameters for NewCache().
-	defaultCachePeriod    = time.Second * 2
-	defaultUpdateInterval = time.Millisecond * 100
+	defaultCachePeriod = time.Second * 2
 )
 
 type RuntimeCache interface {
@@ -39,8 +38,7 @@ type podsGetter interface {
 // NewRuntimeCache creates a container runtime cache.
 func NewRuntimeCache(getter podsGetter) (RuntimeCache, error) {
 	return &runtimeCache{
-		getter:   getter,
-		updating: false,
+		getter: getter,
 	}, nil
 }
 
@@ -48,13 +46,6 @@ func NewRuntimeCache(getter podsGetter) (RuntimeCache, error) {
 // before updating the pods, so the timestamp is at most as new as the pods
 // (and can be slightly older). The timestamp always moves forward. Callers are
 // expected not to modify the pods returned from GetPods.
-// The pod updates can be triggered by a request (e.g., GetPods or
-// ForceUpdateIfOlder) if the cached pods are considered stale. These requests
-// will be blocked until the cache update is completed. To reduce the cache miss
-// penalty, upon a miss, runtimeCache would start a separate goroutine
-// (updatingThread) if one does not exist, to periodically updates the cache.
-// updatingThread would stop after a period of inactivity (no incoming requests)
-// to conserve resources.
 type runtimeCache struct {
 	sync.Mutex
 	// The underlying container runtime used to update the cache.
@@ -63,15 +54,10 @@ type runtimeCache struct {
 	cacheTime time.Time
 	// The content of the cache.
 	pods []*Pod
-	// Whether the background thread updating the cache is running.
-	updating bool
-	// Time when the background thread should be stopped.
-	updatingThreadStopTime time.Time
 }
 
 // GetPods returns the cached pods if they are not outdated; otherwise, it
 // retrieves the latest pods and return them.
-// If the cache updating loop has stopped, this function will restart it.
 func (r *runtimeCache) GetPods() ([]*Pod, error) {
 	r.Lock()
 	defer r.Unlock()
@@ -80,12 +66,6 @@ func (r *runtimeCache) GetPods() ([]*Pod, error) {
 			return nil, err
 		}
 	}
-	// Stop refreshing thread if there were no requests within the default cache period
-	r.updatingThreadStopTime = time.Now().Add(defaultCachePeriod)
-	if !r.updating {
-		r.updating = true
-		go r.startUpdatingCache()
-	}
 	return r.pods, nil
 }
 
@@ -103,7 +83,7 @@ func (r *runtimeCache) updateCache() error {
 	if err != nil {
 		return err
 	}
-	r.writePodsIfNewer(pods, timestamp)
+	r.pods, r.cacheTime = pods, timestamp
 	return nil
 }
 
@@ -114,32 +94,3 @@ func (r *runtimeCache) getPodsWithTimestamp() ([]*Pod, time.Time, error) {
 	pods, err := r.getter.GetPods(false)
 	return pods, timestamp, err
 }
-
-// writePodsIfNewer writes the pods and timestamp if they are newer than the
-// cached ones.
-func (r *runtimeCache) writePodsIfNewer(pods []*Pod, timestamp time.Time) {
-	if timestamp.After(r.cacheTime) {
-		r.pods, r.cacheTime = pods, timestamp
-	}
-}
-
-// startUpdateingCache continues to invoke GetPods to get the newest result until
-// there are no requests within the default cache period.
-func (r *runtimeCache) startUpdatingCache() {
-	run := true
-	for run {
-		time.Sleep(defaultUpdateInterval)
-		pods, timestamp, err := r.getPodsWithTimestamp()
-		if err != nil {
-			continue
-		}
-
-		r.Lock()
-		if time.Now().After(r.updatingThreadStopTime) {
-			r.updating = false
-			run = false
-		}
-		r.writePodsIfNewer(pods, timestamp)
-		r.Unlock()
-	}
-}
diff --git a/pkg/kubelet/container/runtime_cache_test.go b/pkg/kubelet/container/runtime_cache_test.go
index c1f0477aeb9..1025d40b8dd 100644
--- a/pkg/kubelet/container/runtime_cache_test.go
+++ b/pkg/kubelet/container/runtime_cache_test.go
@@ -86,27 +86,3 @@ func TestForceUpdateIfOlder(t *testing.T) {
 		t.Errorf("expected %#v, got %#v", newpods, actual)
 	}
 }
-
-func TestUpdatePodsOnlyIfNewer(t *testing.T) {
-	runtime := &FakeRuntime{}
-	cache := newTestRuntimeCache(runtime)
-
-	// Cache new pods with a future timestamp.
-	newpods := []*Pod{{ID: "1111"}, {ID: "2222"}, {ID: "3333"}}
-	cache.Lock()
-	cache.pods = newpods
-	cache.cacheTime = time.Now().Add(20 * time.Minute)
-	cache.Unlock()
-
-	// Instruct runime to return a list of old pods.
-	oldpods := []*Pod{{ID: "1111"}}
-	runtime.PodList = oldpods
-
-	// Try to update the cache; the attempt should not succeed because the
-	// cache timestamp is newer than the current time.
-	cache.updateCacheWithLock()
-	actual := cache.getCachedPods()
-	if !reflect.DeepEqual(newpods, actual) {
-		t.Errorf("expected %#v, got %#v", newpods, actual)
-	}
-}