best practices, recommendations for working with transactions and microstream

[sare3th]

Hi all @hg-ms,
Please check example below.
Suppose we create a device named "rollback_device". This device will not be stored in the microstream. However, because we've added this device to memory, if another thread calls findAll, it will see this device, which is something I want to avoid.

What is the best practice for achieving a "read committed" isolation level for transactions with microstream(without locking/creating copies of objects)? Is there any built-in feature for this?

P.S. I came across Reloader.New(persistenceManager);, which can revert the root to its state before a transaction, but it doesn't prevent dirty reads.

public class Root {
    private List<Device> devices = new ArrayList<>();
    // getters and setters

    public static class Device {
        private String name;
        // getters and setters
    }
}

public class DeviceRepository {

    private final StorageManager storageManager;

    public DeviceRepository(StorageManager storageManager) {
        this.storageManager = storageManager;
    }
    public List<Device> findAll() {
        return root().getDevices();
    }

    public void create(Device device) {
        var storer = storageManager.createStorer();
        try {
            List<Device> devices = root().getDevices();
            devices.add(device);
            if (device.getName().equals("rollback_device")) {
                throw new IllegalArgumentException();
            }
            storer.store(devices);
            //some other code that can throw exception
            storer.commit();
        } catch (Exception e) {
            storer.clear();
        }
    }

    private Root root() {
        return ((Root) storageManager.root());
    }
}

[hg-ms]

Hi,
We can’t prevent other threads from accessing application objects. Solving concurrency problems like your must be done by the application as Microstream does not own the object graph. From my point of view reentrant read write locks are the best options.
If you’re looking for a simpler solution you may have a look at the class ‘one.microstream.concurrency.XThreads’ that provides a basic approach to handle such concurrency issues in simple applications.