BoxStore: do not block file open check from obtaining lock on creation #240

This prevents an "Another BoxStore is still open for this directory"
exception when a previous instance using the same directory has to be
finalized (because it wasn't closed explicitly).

Author: greenrobot-team

CHANGELOG.md

@@ -6,6 +6,10 @@ For more insights into what changed in the ObjectBox C++ core, [check the Object
 
 ## 4.3.2 - in development
 
+- When re-creating a `BoxStore` for the same directory and `close()` wasn't called on the previous instance, don't throw
+  an "Another BoxStore is still open for this directory" exception. Note that calling `close()` *is recommended* before 
+  creating a new instance. [#1201](https://github.com/objectbox/objectbox-java/issues/1201)
+
 ## 4.3.1 - 2025-08-12
 
 - Requires at least Kotlin compiler and standard library 1.7.

objectbox-java/src/main/java/io/objectbox/BoxStore.java

@@ -359,16 +359,34 @@ static String getCanonicalPath(File directory) {
     }
 
     static void verifyNotAlreadyOpen(String canonicalPath) {
+        // Call isFileOpen before, but without checking the result, to try to close any unreferenced instances where
+        // it was forgotten to close them.
+        // Only obtain the lock on openFiles afterward as the checker thread created by isFileOpen needs to obtain it to
+        // do anything.
+        isFileOpen(canonicalPath);
         synchronized (openFiles) {
-            isFileOpen(canonicalPath); // for retries
             if (!openFiles.add(canonicalPath)) {
-                throw new DbException("Another BoxStore is still open for this directory: " + canonicalPath +
-                        ". Hint: for most apps it's recommended to keep a BoxStore for the app's life time.");
+                throw new DbException("Another BoxStore is still open for this directory (" + canonicalPath +
+                        "). Make sure the existing instance is explicitly closed before creating a new one.");
             }
         }
     }
 
-    /** Also retries up to 500ms to improve GC race condition situation. */
+    /**
+     * Returns if the given path is in {@link #openFiles}.
+     * <p>
+     * If it is, (creates and) briefly waits on an existing "checker" thread before checking again and returning the
+     * result.
+     * <p>
+     * The "checker" thread locks {@link #openFiles} while it triggers garbage collection and finalization in this Java
+     * Virtual Machine to try to close any unreferenced BoxStore instances. These might exist if it was forgotten to
+     * close them explicitly.
+     * <p>
+     * Note that the finalization mechanism relied upon here is scheduled for removal in future versions of Java and may
+     * already be disabled depending on JVM configuration.
+     *
+     * @see #finalize()
+     */
     static boolean isFileOpen(final String canonicalPath) {
         synchronized (openFiles) {
             if (!openFiles.contains(canonicalPath)) return false;
@@ -522,9 +540,13 @@ public long getDbSizeOnDisk() {
     }
 
     /**
-     * Closes this if this is finalized.
+     * Calls {@link #close()}.
+     * <p>
+     * It is strongly recommended to instead explicitly close a Store and not rely on finalization. For example, on
+     * Android finalization has a timeout that might be exceeded if closing needs to wait on transactions to finish.
      * <p>
-     * Explicitly call {@link #close()} instead to avoid expensive finalization.
+     * Also finalization is scheduled for removal in future versions of Java and may already be disabled depending on
+     * JVM configuration (see documentation on super method).
      */
     @SuppressWarnings("deprecation") // finalize()
     @Override

tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java

@@ -16,7 +16,6 @@
 
 package io.objectbox;
 
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.function.ThrowingRunnable;
 
@@ -175,24 +174,17 @@ public void openSamePath_afterClose_works() {
         assertEquals(0, BoxStore.nativeGloballyActiveEntityTypes());
     }
 
-    @Ignore("Fails due to related issue")
     @Test
     public void openSamePath_closedByFinalizer_works() {
         System.out.println("Removing reference to " + store);
         store = null;
 
-        // TODO Can't, at least on a JVM 21, confirm that the gc and runFinalization calls are blocking close() from
-        //  accessing openFiles.
-        //  Instead, found another issue where openFiles appears to still contain the db directory on this thread but
-        //  not for the checker thread.
-
         // When another Store is still open using the same path, a checker thread is started that periodically triggers
         // garbage collection and finalization in the VM, which here should close store and allow store2 to be opened.
-        // Note that user code should not rely on this (for ex. finalizers on Android have a timeout, which might be
-        // exceeded if closing the store takes long, because it needs to wait on transactions to finish), the store
-        // should be explicitly closed instead.
+        // Note that user code should not rely on this, see notes on BoxStore.finalize().
         BoxStore store2 = createBoxStore();
         store2.close();
+        System.out.println("Closed " + store2);
     }
 
     @Test