@@ -166,34 +166,33 @@ public void addIndex(String tagKey, String tagValue, IMeasurementMNode<?> measur
       return;
     }
 
-    int tagIndexOldSize = tagIndex.size();
-    Map<String, Set<IMeasurementMNode<?>>> tagValueMap =
-        tagIndex.computeIfAbsent(tagKey, k -> new ConcurrentHashMap<>());
-    int tagIndexNewSize = tagIndex.size();
-
-    int tagValueMapOldSize = tagValueMap.size();
-    Set<IMeasurementMNode<?>> measurementsSet =
-        tagValueMap.computeIfAbsent(tagValue, v -> Collections.synchronizedSet(new HashSet<>()));
-    int tagValueMapNewSize = tagValueMap.size();
-
-    int measurementsSetOldSize = measurementsSet.size();
-    measurementsSet.add(measurementMNode);
-    int measurementsSetNewSize = measurementsSet.size();
-
-    long memorySize = 0;
-    if (tagIndexNewSize - tagIndexOldSize == 1) {
-      // the last 4 is the memory occupied by the size of tagvaluemap
-      memorySize += RamUsageEstimator.sizeOf(tagKey) + 4;
-    }
-    if (tagValueMapNewSize - tagValueMapOldSize == 1) {
-      // the last 4 is the memory occupied by the size of measurementsSet
-      memorySize += RamUsageEstimator.sizeOf(tagValue) + 4;
-    }
-    if (measurementsSetNewSize - measurementsSetOldSize == 1) {
-      // 8 is the memory occupied by the length of the IMeasurementMNode
-      memorySize += RamUsageEstimator.NUM_BYTES_OBJECT_REF + 4;
-    }
-    requestMemory(memorySize);
+    tagIndex.compute(
+        tagKey,
+        (key, tagValueMap) -> {
+          long memorySize = 0;
+          if (tagValueMap == null) {
+            tagValueMap = new ConcurrentHashMap<>();
+            // the last 4 is the memory occupied by the size of tagvaluemap
+            memorySize += RamUsageEstimator.sizeOf(tagKey) + 4;
+          }
+
+          Set<IMeasurementMNode<?>> measurementsSet = tagValueMap.get(tagValue);
+          if (measurementsSet == null) {
+            measurementsSet = ConcurrentHashMap.newKeySet();
+            tagValueMap.put(tagValue, measurementsSet);
+            // the last 4 is the memory occupied by the size of measurementsSet
+            memorySize += RamUsageEstimator.sizeOf(tagValue) + 4;
+          }
+
+          if (measurementsSet.add(measurementMNode)) {
+            // 8 is the memory occupied by the length of the IMeasurementMNode
+            memorySize += RamUsageEstimator.NUM_BYTES_OBJECT_REF + 4;
+          }
+          if (memorySize > 0) {
+            requestMemory(memorySize);
+          }
+          return tagValueMap;
+        });
   }
 
   public void addIndex(Map<String, String> tagsMap, IMeasurementMNode<?> measurementMNode) {
@@ -208,32 +207,42 @@ public void removeIndex(String tagKey, String tagValue, IMeasurementMNode<?> mea
     if (tagKey == null || tagValue == null || measurementMNode == null) {
       return;
     }
-    // init memory size
-    long memorySize = 0;
-    if (tagIndex.get(tagKey).get(tagValue).remove(measurementMNode)) {
-      memorySize += RamUsageEstimator.NUM_BYTES_OBJECT_REF + 4;
-    }
-    if (tagIndex.get(tagKey).get(tagValue).isEmpty()) {
-      if (tagIndex.get(tagKey).remove(tagValue) != null) {
-        // the last 4 is the memory occupied by the size of IMeasurementMNodeSet
-        memorySize += RamUsageEstimator.sizeOf(tagValue) + 4;
-      }
-    }
-    if (tagIndex.get(tagKey).isEmpty()) {
-      if (tagIndex.remove(tagKey) != null) {
-        // the last 4 is the memory occupied by the size of tagValueMap
-        memorySize += RamUsageEstimator.sizeOf(tagKey) + 4;
-      }
-    }
-    releaseMemory(memorySize);
+    tagIndex.computeIfPresent(
+        tagKey,
+        (key, tagValueMap) -> {
+          long memorySize = 0;
+          Set<IMeasurementMNode<?>> measurementsSet = tagValueMap.get(tagValue);
+          if (measurementsSet == null) {
+            return tagValueMap;
+          }
+
+          if (measurementsSet.remove(measurementMNode)) {
+            memorySize += RamUsageEstimator.NUM_BYTES_OBJECT_REF + 4;
+          }
+          if (measurementsSet.isEmpty()) {
+            if (tagValueMap.remove(tagValue, measurementsSet)) {
+              // the last 4 is the memory occupied by the size of IMeasurementMNodeSet
+              memorySize += RamUsageEstimator.sizeOf(tagValue) + 4;
+            }
+          }
+          if (tagValueMap.isEmpty()) {
+            // the last 4 is the memory occupied by the size of tagValueMap
+            memorySize += RamUsageEstimator.sizeOf(tagKey) + 4;
+            if (memorySize > 0) {
+              releaseMemory(memorySize);
+            }
+            return null;
+          }
+          if (memorySize > 0) {
+            releaseMemory(memorySize);
+          }
+          return tagValueMap;
+        });
   }
 
   private List<IMeasurementMNode<?>> getMatchedTimeseriesInIndex(TagFilter tagFilter) {
-    if (!tagIndex.containsKey(tagFilter.getKey())) {
-      return Collections.emptyList();
-    }
     Map<String, Set<IMeasurementMNode<?>>> value2Node = tagIndex.get(tagFilter.getKey());
-    if (value2Node.isEmpty()) {
+    if (value2Node == null || value2Node.isEmpty()) {
       return Collections.emptyList();
     }
 
 
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.iotdb.db.schemaengine.schemaregion.tag;
+
+import org.apache.iotdb.commons.schema.node.role.IMeasurementMNode;
+import org.apache.iotdb.commons.schema.node.utils.IMNodeFactory;
+import org.apache.iotdb.db.schemaengine.rescon.MemSchemaEngineStatistics;
+import org.apache.iotdb.db.schemaengine.rescon.MemSchemaRegionStatistics;
+import org.apache.iotdb.db.schemaengine.schemaregion.mtree.impl.mem.mnode.IMemMNode;
+import org.apache.iotdb.db.schemaengine.schemaregion.mtree.loader.MNodeFactoryLoader;
+
+import org.apache.tsfile.enums.TSDataType;
+import org.apache.tsfile.external.commons.io.FileUtils;
+import org.apache.tsfile.file.metadata.enums.CompressionType;
+import org.apache.tsfile.file.metadata.enums.TSEncoding;
+import org.apache.tsfile.utils.RamUsageEstimator;
+import org.apache.tsfile.write.schema.MeasurementSchema;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+public class TagManagerTest {
+
+  private File tempDir;
+  private MemSchemaRegionStatistics regionStatistics;
+  private TagManager tagManager;
+
+  @After
+  public void tearDown() throws Exception {
+    if (tagManager != null) {
+      tagManager.clear();
+    }
+    if (regionStatistics != null) {
+      regionStatistics.clear();
+    }
+    if (tempDir != null) {
+      FileUtils.deleteDirectory(tempDir);
+    }
+  }
+
+  @Test
+  public void removeIndexIgnoresMissingEntriesAndReleasesOnlyExistingMemory() throws Exception {
+    initTagManager();
+    final IMeasurementMNode<?> node = newMeasurementMNode("s0");
+
+    tagManager.removeIndex("missingKey", "missingValue", node);
+    Assert.assertEquals(0, regionStatistics.getRegionMemoryUsage());
+
+    tagManager.addIndex("key", "value", node);
+    final long expectedMemory = indexMemory("key", "value", 1);
+    Assert.assertEquals(expectedMemory, regionStatistics.getRegionMemoryUsage());
+
+    tagManager.removeIndex("key", "missingValue", node);
+    Assert.assertEquals(expectedMemory, regionStatistics.getRegionMemoryUsage());
+
+    tagManager.removeIndex("key", "value", newMeasurementMNode("other"));
+    Assert.assertEquals(expectedMemory, regionStatistics.getRegionMemoryUsage());
+
+    tagManager.removeIndex("key", "value", node);
+    Assert.assertEquals(0, regionStatistics.getRegionMemoryUsage());
+
+    tagManager.removeIndex("key", "value", node);
+    Assert.assertEquals(0, regionStatistics.getRegionMemoryUsage());
+  }
+
+  @Test
+  public void concurrentAddIndexRequestsMemoryForActualInsertionsOnly() throws Exception {
+    initTagManager();
+    final String tagKey = "key";
+    final String tagValue = "value";
+    final int measurementCount = 128;
+    final List<IMeasurementMNode<?>> nodes = new ArrayList<>();
+    for (int i = 0; i < measurementCount; i++) {
+      nodes.add(newMeasurementMNode("s" + i));
+    }
+
+    final int workerCount = 16;
+    final ExecutorService executorService = Executors.newFixedThreadPool(workerCount);
+    final CountDownLatch readyLatch = new CountDownLatch(workerCount);
+    final CountDownLatch startLatch = new CountDownLatch(1);
+    final List<Future<?>> futures = new ArrayList<>();
+    for (final IMeasurementMNode<?> node : nodes) {
+      futures.add(
+          executorService.submit(
+              () -> {
+                readyLatch.countDown();
+                startLatch.await();
+                tagManager.addIndex(tagKey, tagValue, node);
+                return null;
+              }));
+    }
+
+    try {
+      Assert.assertTrue(readyLatch.await(10, TimeUnit.SECONDS));
+      startLatch.countDown();
+      for (final Future<?> future : futures) {
+        future.get(10, TimeUnit.SECONDS);
+      }
+    } finally {
+      executorService.shutdownNow();
+    }
+    Assert.assertTrue(executorService.awaitTermination(10, TimeUnit.SECONDS));
+
+    final long expectedMemory = indexMemory(tagKey, tagValue, measurementCount);
+    Assert.assertEquals(expectedMemory, regionStatistics.getRegionMemoryUsage());
+
+    for (final IMeasurementMNode<?> node : nodes) {
+      tagManager.addIndex(tagKey, tagValue, node);
+    }
+    Assert.assertEquals(expectedMemory, regionStatistics.getRegionMemoryUsage());
+
+    for (final IMeasurementMNode<?> node : nodes) {
+      tagManager.removeIndex(tagKey, tagValue, node);
+    }
+    Assert.assertEquals(0, regionStatistics.getRegionMemoryUsage());
+  }
+
+  private void initTagManager() throws Exception {
+    tempDir = Files.createTempDirectory("tag-manager").toFile();
+    regionStatistics = new MemSchemaRegionStatistics(0, new MemSchemaEngineStatistics());
+    tagManager = new TagManager(tempDir.getAbsolutePath(), regionStatistics);
+  }
+
+  private static IMeasurementMNode<IMemMNode> newMeasurementMNode(final String measurement) {
+    final IMNodeFactory<IMemMNode> nodeFactory =
+        MNodeFactoryLoader.getInstance().getMemMNodeIMNodeFactory();
+    return nodeFactory.createMeasurementMNode(
+        null,
+        measurement,
+        new MeasurementSchema(
+            measurement, TSDataType.INT64, TSEncoding.PLAIN, CompressionType.SNAPPY),
+        null);
+  }
+
+  private static long indexMemory(
+      final String tagKey, final String tagValue, final int measurementCount) {
+    return RamUsageEstimator.sizeOf(tagKey)
+        + 4
+        + RamUsageEstimator.sizeOf(tagValue)
+        + 4
+        + (RamUsageEstimator.NUM_BYTES_OBJECT_REF + 4) * measurementCount;
+  }
+}