added callInReadTxWithRetry

Author: greenrobot

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

@@ -596,13 +596,48 @@ public void runInReadTx(Runnable runnable) {
         }
     }
 
+    @Experimental
+    public <T> T callInReadTxWithRetry(Callable<T> callable, int attempts, int initialBackOffInMs, boolean logAndHeal) {
+        if (attempts == 1) {
+            return callInReadTx(callable);
+        }
+        long backoffInMs = initialBackOffInMs;
+        DbException lastException = null;
+        for (int attempt = 1; attempt <= attempts; attempt++) {
+            try {
+                return callInReadTx(callable);
+            } catch (DbException e) {
+                lastException = e;
+                if (logAndHeal) {
+                    System.err.println(attempt + ". of " + attempts + " attempts of calling a read TX failed:");
+                    e.printStackTrace();
+                    System.err.println(diagnose());
+                    System.err.flush();
+
+                    System.gc();
+                    System.runFinalization();
+                    cleanStaleReadTransactions();
+                }
+                try {
+                    Thread.sleep(backoffInMs);
+                } catch (InterruptedException ie) {
+                    ie.printStackTrace();
+                    throw lastException;
+                }
+                backoffInMs *= 2;
+            }
+        }
+        throw lastException;
+    }
+
     /**
      * Calls the given callable inside a read(-only) transaction. Multiple read transactions can occur at the same time.
      * This allows multiple read operations (gets) using a single consistent state of data.
      * Also, for a high number of read operations (thousands, e.g. in loops),
      * it is advised to run them in a single read transaction for efficiency reasons.
      * Note that any exception thrown by the given Callable will be wrapped in a RuntimeException.
      */
+
     public <T> T callInReadTx(Callable<T> callable) {
         Transaction tx = this.activeTx.get();
         // Only if not already set, allowing to call it recursively with first (outer) TX
@@ -611,6 +646,8 @@ public <T> T callInReadTx(Callable<T> callable) {
             activeTx.set(tx);
             try {
                 return callable.call();
+            } catch (DbException e) {
+                throw e;
             } catch (Exception e) {
                 throw new RuntimeException("Callable threw exception", e);
             } finally {

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

@@ -19,6 +19,7 @@
 import org.junit.Test;
 
 import java.io.File;
+import java.util.concurrent.Callable;
 
 import io.objectbox.exception.DbException;
 
@@ -144,4 +145,31 @@ private void closeStoreForTest() {
         assertFalse(boxStoreDir.exists());
     }
 
+    @Test
+    public void testCallInReadTxWithRetry() {
+        final int[] countHolder = {0};
+        String value = store.callInReadTxWithRetry(createTestCallable(countHolder), 5, 0, true);
+        assertEquals("42", value);
+        assertEquals(5, countHolder[0]);
+    }
+
+    @Test(expected = DbException.class)
+    public void testCallInReadTxWithRetry_fail() {
+        final int[] countHolder = {0};
+        store.callInReadTxWithRetry(createTestCallable(countHolder), 4, 0, true);
+    }
+
+    private Callable<String> createTestCallable(final int[] countHolder) {
+        return new Callable<String>() {
+            @Override
+            public String call() throws Exception {
+                int count = ++countHolder[0];
+                if (count < 5) {
+                    throw new DbException("Count: " + count);
+                }
+                return "42";
+            }
+        };
+    }
+
 }