Little confusion about Threading and DataConsistent on Realm - objective-c

Question

You can have any number of threads working on the same Realms in parallel, and since they all have their own snapshots, they will never cause each other to see inconsistent state
Consider if the write thread change some value and complete faster than the read thread, however, since the read thread has its own snapshots, it won't change because what have done on the write thread, but if the read thread's operation is base on the latest value, so it's that means the read thread can not do the right operation? thx for helping.
my test demo to describe my confusion

Answer 1

By "inconsistent", the documentation mean "partially modified". They cannot be partially modified, because you see specific version that was created by transactional changes, at all times.
However, updating is not immediate across threads.
since the read thread has its own snapshots, it won't change because what have done on the write thread, but if the read thread's operation is base on the latest value, so it's that means the read thread can not do the right operation?
True, that is exactly why the read thread should use collection notifications.
// from https://realm.io/docs/objc/latest/#collection-notifications
- (void)viewDidLoad {
[super viewDidLoad];
// Observe RLMResults Notifications
__weak typeof(self) weakSelf = self;
self.notificationToken = [[Person objectsWhere:#"age > 5"] addNotificationBlock:^(RLMResults<Person *> *results, RLMCollectionChange *changes, NSError *error) {
if (error) {
NSLog(#"Failed to open Realm on background worker: %#", error);
return;
}
UITableView *tableView = weakSelf.tableView;
// Initial run of the query will pass nil for the change information
if (!changes) {
[tableView reloadData];
return;
}
// Query results have changed, so apply them to the UITableView
[tableView beginUpdates];
[tableView deleteRowsAtIndexPaths:[changes deletionsInSection:0]
withRowAnimation:UITableViewRowAnimationAutomatic];
[tableView insertRowsAtIndexPaths:[changes insertionsInSection:0]
withRowAnimation:UITableViewRowAnimationAutomatic];
[tableView reloadRowsAtIndexPaths:[changes modificationsInSection:0]
withRowAnimation:UITableViewRowAnimationAutomatic];
[tableView endUpdates];
}];
}
- (void)dealloc {
[self.notificationToken stop];
}
In addition to that, transactions always "create the latest version" (and there can be only 1 transaction at a time), so a query inside a write transaction cannot be out-of-date.
dispatch_async(writeQueue, ^{
[[RLMRealm defaultRealm]] transactionWithBlock:^{
Cinema* b = [Cinema allObjects].firstObject; // query cannot be out of date
...
Obviously this does NOT mean that you should execute transaction on the UI thread just to bump its version. Use the notification token for that.

Answer 2

Yes, this is correct. If you want to make sure that you always get consistent data form Realm, do not access it concurrently from separate threads, since the write transactions done on one thread will not be reflected on the other thread. This is the behaviour that can be seen in your example as well.
There is also no need to access realm asynchronously unless you have a huge number of objects to read from it/write to it. If you want to work with such a big number of objects that your queries/write transactions would take several seconds and hence doing them synchronously would block UI updates for too long, make sure that you only access Realm from a single thread and also make sure that your asynchronous read/write operations are not running in parallel.