Revert dataStoreMap from ConcurrentHashMap to LinkedHashMap

Based on feedback that dataStoreMap is not accessed by multiple threads,
reverted the ConcurrentHashMap change back to LinkedHashMap.

Changes:
- Reverted dataStoreMap from ConcurrentHashMap to LinkedHashMap
- Removed ConcurrentHashMap import
- Removed dataStoreMap-related concurrency tests:
  * test_add_concurrentAccess
  * test_getDataStore_concurrentWithAdd
  * test_nullSafety_concurrentAccess

Kept volatile fields and synchronized getDataStoreNames():
- lastLoadedTime and dataStoreNames remain volatile (for cache visibility)
- getDataStoreNames() remains synchronized (for cache refresh safety)
- Related tests for getDataStoreNames() concurrency are maintained

The dataStoreMap is accessed in single-threaded context during application
initialization and data store registration.

Author: claude

src/main/java/org/codelibs/fess/ds/DataStoreFactory.java

@@ -27,7 +27,6 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 import javax.xml.parsers.DocumentBuilder;
@@ -65,9 +64,8 @@ public class DataStoreFactory {
     /**
      * Map containing registered data store instances indexed by their names and class simple names.
      * All keys are stored in lowercase for case-insensitive lookup.
-     * Thread-safe implementation using ConcurrentHashMap for concurrent access.
      */
-    protected Map<String, DataStore> dataStoreMap = new ConcurrentHashMap<>();
+    protected Map<String, DataStore> dataStoreMap = new LinkedHashMap<>();
 
     /**
      * Cached array of available data store names discovered from plugin JAR files.

src/test/java/org/codelibs/fess/ds/DataStoreFactoryTest.java

@@ -338,105 +338,7 @@ protected void storeData(DataConfig dataConfig, IndexUpdateCallback callback, Da
         }
     }
 
-    // ========== Thread Safety Tests ==========
-
-    /**
-     * Test concurrent add operations to verify ConcurrentHashMap thread safety.
-     * Multiple threads simultaneously add different data stores.
-     */
-    public void test_add_concurrentAccess() throws Exception {
-        final int threadCount = 10;
-        final Thread[] threads = new Thread[threadCount];
-        final Exception[] exceptions = new Exception[threadCount];
-
-        for (int i = 0; i < threadCount; i++) {
-            final int index = i;
-            threads[i] = new Thread(() -> {
-                try {
-                    TestDataStore dataStore = new TestDataStore("Store" + index);
-                    dataStoreFactory.add("store" + index, dataStore);
-                } catch (Exception e) {
-                    exceptions[index] = e;
-                }
-            });
-        }
-
-        // Start all threads
-        for (Thread thread : threads) {
-            thread.start();
-        }
-
-        // Wait for all threads to complete
-        for (Thread thread : threads) {
-            thread.join();
-        }
-
-        // Verify no exceptions occurred
-        for (int i = 0; i < threadCount; i++) {
-            assertNull("Thread " + i + " threw exception", exceptions[i]);
-        }
-
-        // Verify all data stores were registered
-        for (int i = 0; i < threadCount; i++) {
-            assertNotNull("DataStore " + i + " not found", dataStoreFactory.getDataStore("store" + i));
-        }
-    }
-
-    /**
-     * Test concurrent get operations while adding new data stores.
-     * Verifies that reads and writes can happen concurrently without issues.
-     */
-    public void test_getDataStore_concurrentWithAdd() throws Exception {
-        // Pre-populate with some data stores
-        for (int i = 0; i < 5; i++) {
-            TestDataStore dataStore = new TestDataStore("InitialStore" + i);
-            dataStoreFactory.add("initial" + i, dataStore);
-        }
-
-        final int threadCount = 10;
-        final Thread[] threads = new Thread[threadCount];
-        final Exception[] exceptions = new Exception[threadCount];
-        final int[] successCount = new int[threadCount];
-
-        for (int i = 0; i < threadCount; i++) {
-            final int index = i;
-            threads[i] = new Thread(() -> {
-                try {
-                    for (int j = 0; j < 100; j++) {
-                        // Half threads read, half threads write
-                        if (index % 2 == 0) {
-                            DataStore ds = dataStoreFactory.getDataStore("initial" + (j % 5));
-                            if (ds != null) {
-                                successCount[index]++;
-                            }
-                        } else {
-                            TestDataStore dataStore = new TestDataStore("ConcurrentStore" + index + "_" + j);
-                            dataStoreFactory.add("concurrent" + index + "_" + j, dataStore);
-                            successCount[index]++;
-                        }
-                    }
-                } catch (Exception e) {
-                    exceptions[index] = e;
-                }
-            });
-        }
-
-        // Start all threads
-        for (Thread thread : threads) {
-            thread.start();
-        }
-
-        // Wait for all threads to complete
-        for (Thread thread : threads) {
-            thread.join();
-        }
-
-        // Verify no exceptions occurred
-        for (int i = 0; i < threadCount; i++) {
-            assertNull("Thread " + i + " threw exception", exceptions[i]);
-            assertEquals("Thread " + i + " didn't complete all operations", 100, successCount[i]);
-        }
-    }
+    // ========== Thread Safety Tests for getDataStoreNames() ==========
 
     /**
      * Test concurrent getDataStoreNames calls to verify synchronized method works correctly.
@@ -582,35 +484,4 @@ protected List<String> loadDataStoreNameList() {
         // The count might be 2 (one initial + one reload) or slightly higher due to timing
         assertTrue("Load count should be small due to synchronization", loadCount[0] <= 3);
     }
-
-    /**
-     * Test null safety with concurrent access.
-     * Verifies that null checks work correctly under concurrent load.
-     */
-    public void test_nullSafety_concurrentAccess() throws Exception {
-        final int threadCount = 10;
-        final Thread[] threads = new Thread[threadCount];
-        final DataStore[] results = new DataStore[threadCount];
-
-        for (int i = 0; i < threadCount; i++) {
-            final int index = i;
-            threads[i] = new Thread(() -> {
-                // Try to get non-existent data store
-                results[index] = dataStoreFactory.getDataStore(null);
-            });
-        }
-
-        for (Thread thread : threads) {
-            thread.start();
-        }
-
-        for (Thread thread : threads) {
-            thread.join();
-        }
-
-        // All should return null without exceptions
-        for (int i = 0; i < threadCount; i++) {
-            assertNull("Thread " + i + " should get null", results[i]);
-        }
-    }
 }