[Storage] Make three TierManager fields thread-safe for SonarCloud's reliability gate

iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManager.java

@@ -46,13 +46,15 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 /** The main class of multiple directories. Used to allocate folders to data files. */
@@ -62,7 +64,10 @@
 
   private record TierDirectory(int tierLevel, String folderName) {}
 
-  private volatile Map<TierDirectory, TierFolderManager> folderManagers = Map.of();
+  /** Replaced as a whole by {@link #rebuildFolders()}; the published maps are unmodifiable. */
+  private final AtomicReference<Map<TierDirectory, TierFolderManager>> folderManagers =
+      new AtomicReference<>(Map.of());
+
   // A failed constructor can report DiskFull before the replacement managers are published.
   private volatile boolean rebuildingFolders;
 
@@ -75,7 +80,7 @@
   private List<String> objectDirs;
 
   /** total space of each tier, Long.MAX_VALUE when one tier contains remote storage */
-  private volatile long[] tierDiskTotalSpace = new long[0];
+  private final AtomicReference<long[]> tierDiskTotalSpace = new AtomicReference<>(new long[0]);
 
   private TierManager() {
     initFolders();
@@ -91,7 +96,7 @@
     }
   }
 
   private void rebuildFolders() {
     Map<TierDirectory, TierFolderManager> newManagers = new HashMap<>();
     Map<String, Integer> newSeqDir2TierLevel = new HashMap<>();
     Map<String, Integer> newUnSeqDir2TierLevel = new HashMap<>();
@@ -206,10 +211,10 @@
       }
     }
 
-    tierDiskTotalSpace = getTierDiskSpace(DiskSpaceType.TOTAL);
+    tierDiskTotalSpace.set(getTierDiskSpace(DiskSpaceType.TOTAL));
     seqDir2TierLevel = newSeqDir2TierLevel;
     unSeqDir2TierLevel = newUnSeqDir2TierLevel;
-    folderManagers = newManagers;
+    folderManagers.set(Collections.unmodifiableMap(newManagers));
   }
 
   private void addFolderManager(
@@ -233,28 +238,30 @@
   private final class TierFolderManager {
     private final List<String> folders;
     private final MemoizedCheckedSupplier<FolderManager, DiskSpaceInsufficientException> supplier;
-    private volatile FolderManager manager;
+    private final AtomicReference<FolderManager> manager = new AtomicReference<>();
 
     private TierFolderManager(TierDirectory key, List<String> folders, DirectoryStrategyType type) {
       this.folders = folders;
       supplier =
           MemoizedCheckedSupplier.valueOf(
               () -> {
-                manager = new FolderManager(folders, type, () -> reportDiskFull(key, this));
-                return manager;
+                FolderManager created =
+                    new FolderManager(folders, type, () -> reportDiskFull(key, this));
+                manager.set(created);
+                return created;
               });
     }
 
     private boolean hasSpaceForRecovery() {
-      FolderManager current = manager;
+      FolderManager current = manager.get();
       return current == null
           ? folders.stream().anyMatch(JVMCommonUtils::hasSpaceWithoutRetry)
           : current.hasSpaceForRecovery();
     }
   }
 
   private void reportDiskFull(TierDirectory key, TierFolderManager source) {
-    if (!rebuildingFolders && folderManagers.get(key) != source) {
+    if (!rebuildingFolders && folderManagers.get().get(key) != source) {
       return;
     }
     CommonDescriptor.getInstance()
@@ -263,13 +270,13 @@
   }
 
   private boolean hasSpaceForRecovery(TierDirectory key) {
-    Map<TierDirectory, TierFolderManager> active = folderManagers;
+    Map<TierDirectory, TierFolderManager> active = folderManagers.get();
     if (rebuildingFolders) {
       return false;
     }
     TierFolderManager current = active.get(key);
     boolean recovered = current == null || current.hasSpaceForRecovery();
-    return recovered && active == folderManagers && !rebuildingFolders;
+    return recovered && active == folderManagers.get() && !rebuildingFolders;
   }
 
   public synchronized void resetFolders() {
@@ -319,7 +326,7 @@
   private FolderManager getFolderManager(int tierLevel, String folderName)
       throws DiskSpaceInsufficientException {
     TierDirectory key = new TierDirectory(tierLevel, folderName);
-    TierFolderManager entry = folderManagers.get(key);
+    TierFolderManager entry = folderManagers.get().get(key);
     if (entry == null) {
       throw new IndexOutOfBoundsException(key.toString());
     }
@@ -414,7 +421,7 @@
   }
 
   public int getTiersNum() {
-    return tierDiskTotalSpace.length;
+    return tierDiskTotalSpace.get().length;
   }
 
   public int getFileTierLevel(File file) {
@@ -445,7 +452,7 @@
   }
 
   public long[] getTierDiskTotalSpace() {
-    return Arrays.copyOf(tierDiskTotalSpace, tierDiskTotalSpace.length);
+    return tierDiskTotalSpace.get().clone();
   }
 
   public long[] getTierDiskUsableSpace() {

iotdb-core/datanode/src/test/java/org/apache/iotdb/db/storageengine/rescon/disk/TierManagerTest.java

@@ -84,6 +84,24 @@ public void tearDown() {
     tierManager.resetFolders();
   }
 
+  @Test
+  public void testTierDiskTotalSpaceFollowsTheTiersAndIsCopied() {
+    config.setTierDataDirs(
+        new String[][] {
+          {new File(temporaryFolder.getRoot(), "tier0").getAbsolutePath()},
+          {new File(temporaryFolder.getRoot(), "tier1").getAbsolutePath()}
+        });
+    tierManager.resetFolders();
+
+    long[] totalSpace = tierManager.getTierDiskTotalSpace();
+    assertEquals(2, totalSpace.length);
+    assertEquals(tierManager.getTiersNum(), totalSpace.length);
+    assertTrue(totalSpace[0] > 0 && totalSpace[1] > 0);
+
+    totalSpace[0] = -1;
+    assertTrue(tierManager.getTierDiskTotalSpace()[0] > 0);
+  }
+
   @Test
   public void testConcurrentResetFoldersAndGetNextFolder() throws Exception {
     List<Callable<?>> folderAccessors =