diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc
index 6961ff3..f90a6f3 100644
--- a/src/kudu/client/client-test.cc
+++ b/src/kudu/client/client-test.cc
@@ -116,6 +116,7 @@
 #include "kudu/util/random_util.h"
 #include "kudu/util/semaphore.h"
 #include "kudu/util/slice.h"
+#include "kudu/util/scoped_cleanup.h"
 #include "kudu/util/status.h"
 #include "kudu/util/stopwatch.h"
 #include "kudu/util/test_macros.h"
@@ -2075,11 +2076,40 @@
   ASSERT_FALSE(meta_cache->LookupEntryByKeyFastPath(client_table_.get(), "", &entry));
 
   // Force a lookup and ensure the entry is refreshed.
-  CHECK_NOTNULL(MetaCacheLookup(client_table_.get(), "").get());
+  ASSERT_NE(nullptr, MetaCacheLookup(client_table_.get(), ""));
+  ASSERT_TRUE(entry.stale());
   ASSERT_TRUE(meta_cache->LookupEntryByKeyFastPath(client_table_.get(), "", &entry));
   ASSERT_FALSE(entry.stale());
 }
 
+// This test scenario verifies that reset of the metacache is safe while working
+// with the client. The scenario calls MetaCache::ClearCache() in a rather
+// synthetic way, but the natural control flow does something similar to that
+// when alterting a table by adding a new range partition (see
+// KuduTableAlterer::Alter() for details).
+TEST_F(ClientTest, ClearCacheAndConcurrentWorkload) {
+  CountDownLatch latch(1);
+  thread cache_cleaner([&]() {
+    const auto sleep_interval = MonoDelta::FromMilliseconds(3);
+    while (!latch.WaitFor(sleep_interval)) {
+      client_->data_->meta_cache_->ClearCache();
+    }
+  });
+  auto thread_joiner = MakeScopedCleanup([&] {
+    latch.CountDown();
+    cache_cleaner.join();
+  });
+
+  constexpr const int kLowIdx = 0;
+  constexpr const int kHighIdx = 1000;
+  const auto runUntil = MonoTime::Now() + MonoDelta::FromSeconds(1);
+  while (MonoTime::Now() < runUntil) {
+    NO_FATALS(InsertTestRows(client_table_.get(), kHighIdx, kLowIdx));
+    NO_FATALS(UpdateTestRows(client_table_.get(), kLowIdx, kHighIdx));
+    NO_FATALS(DeleteTestRows(client_table_.get(), kLowIdx, kHighIdx));
+  }
+}
+
 TEST_F(ClientTest, TestGetTabletServerBlacklist) {
   shared_ptr<KuduTable> table;
   NO_FATALS(CreateTable("blacklist",
diff --git a/src/kudu/client/client.h b/src/kudu/client/client.h
index f8d16d8..51c5d15 100644
--- a/src/kudu/client/client.h
+++ b/src/kudu/client/client.h
@@ -622,6 +622,7 @@
   friend class tools::RemoteKsckCluster;
 
   FRIEND_TEST(kudu::ClientStressTest, TestUniqueClientIds);
+  FRIEND_TEST(ClientTest, ClearCacheAndConcurrentWorkload);
   FRIEND_TEST(ClientTest, TestCacheAuthzTokens);
   FRIEND_TEST(ClientTest, TestGetSecurityInfoFromMaster);
   FRIEND_TEST(ClientTest, TestGetTabletServerBlacklist);
diff --git a/src/kudu/client/meta_cache.cc b/src/kudu/client/meta_cache.cc
index b005256..5b4cd22 100644
--- a/src/kudu/client/meta_cache.cc
+++ b/src/kudu/client/meta_cache.cc
@@ -40,7 +40,6 @@
 #include "kudu/gutil/basictypes.h"
 #include "kudu/gutil/map-util.h"
 #include "kudu/gutil/port.h"
-#include "kudu/gutil/stl_util.h"
 #include "kudu/gutil/strings/substitute.h"
 #include "kudu/master/master.pb.h"
 #include "kudu/master/master.proxy.h"
@@ -521,20 +520,30 @@
       replica_visibility_(replica_visibility) {
 }
 
-MetaCache::~MetaCache() {
-  STLDeleteValues(&ts_cache_);
-}
-
 void MetaCache::UpdateTabletServer(const TSInfoPB& pb) {
   DCHECK(lock_.is_write_locked());
-  RemoteTabletServer* ts = FindPtrOrNull(ts_cache_, pb.permanent_uuid());
+  const auto& ts_uuid = pb.permanent_uuid();
+  auto* ts = FindPtrOrNull(ts_cache_, ts_uuid);
   if (ts) {
     ts->Update(pb);
     return;
   }
 
-  VLOG(1) << "Client caching new TabletServer " << pb.permanent_uuid();
-  InsertOrDie(&ts_cache_, pb.permanent_uuid(), new RemoteTabletServer(pb));
+  // First check whether the information about the tablet server is already
+  // present in the registry.
+  ts = FindPointeeOrNull(ts_registry_, ts_uuid);
+  if (ts) {
+    // If the tablet server is already registered, update the existing entry.
+    ts->Update(pb);
+  } else {
+    // If the tablet server isn't registered, add a new entry.
+    unique_ptr<RemoteTabletServer> entry(new RemoteTabletServer(pb));
+    ts = entry.get();
+    EmplaceOrDie(&ts_registry_, ts_uuid, std::move(entry));
+  }
+  // Now add the entry into the cache.
+  VLOG(1) << Substitute("client caching new TabletServer $0", ts_uuid);
+  InsertOrDie(&ts_cache_, ts_uuid, ts);
 }
 
 
@@ -997,7 +1006,7 @@
 void MetaCache::ClearCache() {
   VLOG(3) << "Clearing cache";
   std::lock_guard<percpu_rwlock> l(lock_);
-  STLDeleteValues(&ts_cache_);
+  ts_cache_.clear();
   tablets_by_id_.clear();
   tablets_by_table_and_key_.clear();
 }
diff --git a/src/kudu/client/meta_cache.h b/src/kudu/client/meta_cache.h
index 2e9a216..e3b0b6b 100644
--- a/src/kudu/client/meta_cache.h
+++ b/src/kudu/client/meta_cache.h
@@ -135,6 +135,8 @@
   bool failed;
 };
 
+typedef std::unordered_map<std::string, std::unique_ptr<RemoteTabletServer>>
+    TabletServerRegistry;
 typedef std::unordered_map<std::string, RemoteTabletServer*> TabletServerMap;
 
 // A ServerPicker for tablets servers, backed by the MetaCache.
@@ -379,7 +381,7 @@
  public:
   // The passed 'client' object must remain valid as long as MetaCache is alive.
   MetaCache(KuduClient* client, ReplicaController::Visibility replica_visibility);
-  ~MetaCache();
+  ~MetaCache() = default;
 
   // Determines what type of operation a MetaCache lookup is being done for.
   enum class LookupType {
@@ -471,11 +473,21 @@
 
   percpu_rwlock lock_;
 
-  // Cache of Tablet Server locations: TS UUID -> RemoteTabletServer*.
+  // Registry of all tablet servers as a map of tablet server's
+  // UUID -> std::unique_ptr<RemoteTabletServer>.
   //
-  // Given that the set of tablet servers is bounded by physical machines, we never
-  // evict entries from this map until the MetaCache is destructed. So, no need to use
-  // shared_ptr, etc.
+  // Given that the set of tablet servers in a cluster is bounded by physical
+  // machines and every tablet server has its unique identifier, we never remove
+  // entries from this map until the MetaCache is destructed. Note that the
+  // ClearCache() method doesn't touch this registry, but updates ts_cache_ map
+  // below which contains raw pointers to the elements in this registry.
+  // So, there is no need to use shared_ptr and alike for the entries.
+  //
+  // Protected by lock_.
+  TabletServerRegistry ts_registry_;
+
+  // Cache of Tablet Server locations: TS UUID -> RemoteTabletServer*.
+  // The cache can be cleared by the ClearCache() method.
   //
   // Protected by lock_.
   TabletServerMap ts_cache_;