当多个读者从 Rust 中的不同线程读取时写入

Question

I know I can use RwLock to wait for reading threads to finish reading, although I was wondering if it was possible to write data while the readers were reading non-atomically (I don't really care whether readers get an old copy of the data or a new one, as long as the memory gets updated) Is this possible in safe (or unsafe rust)?

A little more about my specific problem: I have an object that may take a long time to write to but I want to have readers reading from it constantly.

EDIT: More specifically, I have a Cache that holds different objects. These objects simply hold a byte (u8) array. This byte array needs to be read from different threads as well as being written to (the writing parses a large cumbersome struct and converts various fields into the byte array).

Answer 1

This is a good use-case of the arc-swap crate, which allows you to atomically swap oneArc for another. Every time you wish to create a new version of your data, you create a clone of the data and put the new version in an Arc , swapping out the old Arc . Code that needs to read can get a clone to the Arc currently in the ArcSwap , and the old version is destroyed once there are no more handles to the old version.

If you need to modify the data from multiple places, you should employ the following pattern using a Mutex .

1. You have an extra version used for updates stored inside the Mutex .
2. When you wish to update the data, lock the mutex and make your changes.
3. Make a clone of the object stored in the Mutex and put it into the ArcSwap .
4. Then unlock the mutex.

Any code that wishes to read the data will take a clone from the ArcSwap and never touch the Mutex . It is important that the mutex is unlocked after swapping the Arc with the new version.