スレッディング - Swift SDK

非同期書込みの完了を待機する

SDK は、Realm が現在非同期書込みを実行しているかどうかを示すBoolを提供します。 isPerformingAsynchronousWriteOperations変数は、次のいずれかを呼び出した後にtrueになります。

• writeAsync

• beginAsyncWrite

• commitAsyncWrite

スケジュールされたすべての非同期書込み操作が完了するまで true のままになります。 これは true ですが、Realm を閉じるか無効にすることをブロックします。

非同期書込みのコミットまたはキャンセル

非同期書込みを完了するには、ユーザーまたは SDK は次のいずれかを呼び出す必要があります。

• commitAsyncWrite

• CancelAsyncWrite

writeAsyncメソッドを使用すると、SDK はトランザクションのコミットまたはキャンセルを処理します。 This provides the convenience of the async write without the need to manually keep state tied to the scope of the object. ただし、 writeAsyncブロック内では、 commitAsyncWriteまたはcancelAsyncWriteを明示的に呼び出すことができます。 これらのメソッドのいずれかを呼び出せずに戻る場合、 writeAsyncは次のいずれかになります。

• 書込みブロック内の指示を実行した後に書込みをコミットする

• エラーを返します

どちらの場合も、これによりwriteAsync操作が完了します。

非同期書込みトランザクションをコミットまたはキャンセルするタイミングをより詳細に制御するには、 beginAsyncWriteメソッドを使用します。 このメソッドを使用する場合は、トランザクションを明示的にコミットする必要があります。 非同期書込み (write) をコミットせずに戻ると、トランザクションがキャンセルされます。 beginAsyncWriteはcancelAsyncWriteに渡すことができる ID を返します。

commitAsyncWrite は書込みトランザクションを非同期にコミットします。 これは、データを Realm に永続化するステップです。 commitAsyncWriteにはonCompleteブロックが含まれます。 。 このブロックは、コミットが完了するかエラーで失敗すると、ソース スレッドで を実行します。

commitAsyncWriteを呼び出すと、すぐに が返されます。 これにより、SDK がバックグラウンド スレッドで I/O を実行している間にも、呼び出し元を続行できます。 このメソッドはcancelAsyncWriteに渡すことができる ID を返します。 これにより、完了ブロックの保留中の呼び出しがキャンセルされます。 コミット自体はキャンセルされません。

commitAsyncWriteへの連続した呼び出しをグループ化できます。 これらの呼び出しをバッチすることで、書込みパフォーマンスが向上します。特にバッチされたトランザクションが小さい場合。 グループ化トランザクションを許可するには、 isGroupingAllowedパラメータをtrueに設定します。

beginAsyncWriteまたはcommitAsyncWriteでcancelAsyncWriteを呼び出すことができます。 これをbeginAsyncWriteで呼び出すと、書込みトランザクション全体がキャンセルされます。 commitAsyncWriteでこれを呼び出すと、 commitAsyncWriteに渡した可能性のあるonCompleteブロックのみがキャンセルされます。 コミット自体はキャンセルされません。 キャンセルするbeginAsyncWriteまたはcommitAsyncWriteの ID が必要です。

バックグラウンド スレッドで Realm を使用するための直列キューの作成

バックグラウンド スレッドで Realm を使用する場合は、シリアル キューを作成します。 Realm では、 global()キューなどの同時キューで Realm の使用をサポートしていません。

// Initialize a serial queue, and
// perform realm operations on it
let serialQueue = DispatchQueue(label: "serial-queue")
serialQueue.async {
    let realm = try! Realm(configuration: .defaultConfiguration, queue: serialQueue)
    // Do something with Realm on the non-main thread
}

スレッド間で インスタンスを渡す

Realm 、 Results 、 List 、および管理対象Objectsのインスタンスは、スレッド定義です。 つまり、それらを作成したスレッドでのみ使用できます。 ただし、Realm は、あるスレッドで作成された インスタンスを別のスレッドにコピーできる「スレッドセーフ参照」と呼ばれるメカニズムを提供します。

let realm = try! Realm()
let person = Person(name: "Jane")
try! realm.write {
    realm.add(person)
}
// Create thread-safe reference to person
@ThreadSafe var personRef = person
// @ThreadSafe vars are always optional. If the referenced object is deleted,
// the @ThreadSafe var will be nullified.
print("Person's name: \(personRef?.name ?? "unknown")")
// Pass the reference to a background thread
DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async {
    let realm = try! Realm()
    try! realm.write {
        // Resolve within the transaction to ensure you get the
        // latest changes from other threads. If the person
        // object was deleted, personRef will be nil.
        guard let person = personRef else {
            return // person was deleted
        }
        person.name = "Jane Doe"
    }
}

func someLongCallToGetNewName() async -> String {
    return "Janet"
}
@MainActor
func loadNameInBackground(@ThreadSafe person: Person?) async {
    let newName = await someLongCallToGetNewName()
    let realm = try! await Realm()
    try! realm.write {
        person?.name = newName
    }
}
@MainActor
func createAndUpdatePerson() async {
    let realm = try! await Realm()
    
    let person = Person(name: "Jane")
    try! realm.write {
        realm.add(person)
    }
    await loadNameInBackground(person: person)
}
await createAndUpdatePerson()

let person = Person(name: "Jane")
let realm = try! Realm()
try! realm.write {
    realm.add(person)
}
// Create thread-safe reference to person
let personRef = ThreadSafeReference(to: person)
// Pass the reference to a background thread
DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async {
    let realm = try! Realm()
    try! realm.write {
        // Resolve within the transaction to ensure you get the latest changes from other threads
        guard let person = realm.resolve(personRef) else {
            return // person was deleted
        }
        person.name = "Jane Doe"
    }
}

extension Realm {
    func writeAsync<T: ThreadConfined>(_ passedObject: T, errorHandler: @escaping ((_ error: Swift.Error) -> Void) = { _ in return }, block: @escaping ((Realm, T?) -> Void)) {
        let objectReference = ThreadSafeReference(to: passedObject)
        let configuration = self.configuration
        DispatchQueue(label: "background", autoreleaseFrequency: .workItem).async {
            do {
                let realm = try Realm(configuration: configuration)
                try realm.write {
                    // Resolve within the transaction to ensure you get the latest changes from other threads
                    let object = realm.resolve(objectReference)
                    block(realm, object)
                }
            } catch {
                errorHandler(error)
            }
        }
    }
}

let realm = try! Realm()
let readEmails = realm.objects(Email.self).where {
    $0.read == true
}
realm.writeAsync(readEmails) { (realm, readEmails) in
    guard let readEmails = readEmails else {
        // Already deleted
        return
    }
    realm.delete(readEmails)
}

スレッド間で同じ Realm を使用

スレッド間で Realm インスタンスを共有することはできません。

スレッド間で同じ Realm ファイルを使用するには、各スレッドで異なる Realm インスタンスを開きます。 同じ構成を使用している限り、すべての Realm インスタンスがディスク上の同じ ファイルにマッピングされます。

Realm の更新

Realm を開くと、最新の成功した書込みコミットが反映され、更新される までそのバージョンのままになります。 つまり、Realm は次回の更新まで、別のスレッドで発生した変更を参照できません。 UI スレッド上の Realm（より正確には、任意のイベント ループ スレッド上の）は、そのスレッドのループの開始時に自動的に更新されます。 ただし、ループ スレッドに存在しない、または自動更新が無効になっている Realm インスタンスは、手動で更新する必要があります。

if (![realm autorefresh]) {
    [realm refresh]
}

if (!realm.autorefresh) {
   // Manually refresh
   realm.refresh()
}

凍結されたオブジェクト

スレッドで区切られたライブ オブジェクトはほとんどの場合正常に動作します。 ただし、一部のアプリ（リアクティブなイベントストリームベースのアーキテクチャに基づくものなど）では、UI スレッドで最終的に終了する前に、処理のために不変のコピーを多数のスレッドに送信する必要があります。 毎回深いコピーを作成するとコストが高くなるため、Realm ではライブ インスタンスをスレッド間で共有できません。 この場合、オブジェクト、コレクション、Realm をフリーズして解凍できます。

固定化により、特定のオブジェクト、コレクション、または Realm の不変のビューが作成されます。 固定されたオブジェクト、コレクション、または Realm は引き続きディスク上に存在するため、他のスレッドに渡す際に深くコピーする必要はありません。 スレッドの問題に関係なく、固定されたオブジェクトをスレッド間で自由に共有できます。 Realm を固定すると、その子オブジェクトも固定されます。

凍結されたオブジェクトはライブではなく、自動的に更新されません。 実質的に、停止時にオブジェクトの状態のスナップショットです。 オブジェクトを解凍すると、固定されているオブジェクトのライブ バージョンが返されます。

// Get an immutable copy of the realm that can be passed across threads
RLMRealm *frozenRealm = [realm freeze];
RLMResults *dogs = [Dog allObjectsInRealm:realm];
// You can freeze collections
RLMResults *frozenDogs = [dogs freeze];
// You can still read from frozen realms
RLMResults *frozenDogs2 = [Dog allObjectsInRealm:frozenRealm];
Dog *dog = [dogs firstObject];
// You can freeze objects
Dog *frozenDog = [dog freeze];
// To modify frozen objects, you can thaw them
// You can thaw collections
RLMResults *thawedDogs = [dogs thaw];
// You can thaw objects
Dog *thawedDog = [dog thaw];
// You can thaw frozen realms
RLMRealm *thawedRealm = [realm thaw];

let realm = try! Realm()
// Get an immutable copy of the realm that can be passed across threads
let frozenRealm = realm.freeze()
assert(frozenRealm.isFrozen)
let people = realm.objects(Person.self)
// You can freeze collections
let frozenPeople = people.freeze()
assert(frozenPeople.isFrozen)
// You can still read from frozen realms
let frozenPeople2 = frozenRealm.objects(Person.self)
assert(frozenPeople2.isFrozen)
let person = people.first!
assert(!person.realm!.isFrozen)
// You can freeze objects
let frozenPerson = person.freeze()
assert(frozenPerson.isFrozen)
// Frozen objects have a reference to a frozen realm
assert(frozenPerson.realm!.isFrozen)

固定されたオブジェクトを操作している場合、次のいずれかを実行しようとすると例外がスローされます。

• 固定された Realm で書込みトランザクションを開始する。

• 固定されたオブジェクトを変更します。

• 固定された Realm、コレクション、またはオブジェクトへの変更リスナーの追加。

isFrozenを使用して、オブジェクトが固定されているかどうかを確認できます。 これは常にスレッドセーフです。

if ([realm isFrozen]) {
    // ...
}

if (realm.isFrozen) {
    // ...
}

凍結されたオブジェクトは、それを生成したライブ環境が開いている限り有効のままです。 したがって、すべてのスレッドが固定されたオブジェクトの処理を完了するまで、ライブ邦土を閉じないようにします。 ライブ Realm が閉じられる前に、固定された Realm を閉じることができます。

// Read from a frozen realm
let frozenPeople = frozenRealm.objects(Person.self)
// The collection that we pull from the frozen realm is also frozen
assert(frozenPeople.isFrozen)
// Get an individual person from the collection
let frozenPerson = frozenPeople.first!
// To modify the person, you must first thaw it
// You can also thaw collections and realms
let thawedPerson = frozenPerson.thaw()
// Check to make sure this person is valid. An object is
// invalidated when it is deleted from its managing realm,
// or when its managing realm has invalidate() called on it.
assert(thawedPerson?.isInvalidated == false)
// Thawing the person also thaws the frozen realm it references
assert(thawedPerson!.realm!.isFrozen == false)
// Let's make the code easier to follow by naming the thawed realm
let thawedRealm = thawedPerson!.realm!
// Now, you can modify the todo
try! thawedRealm.write {
   thawedPerson!.name = "John Michael Kane"
}

// Get a copy of frozen objects.
// Here, we're getting them from a frozen realm,
// but you might also be passing them across threads.
let frozenTimmy = frozenRealm.objects(Person.self).where {
    $0.name == "Timmy"
}.first!
let frozenLassie = frozenRealm.objects(Dog.self).where {
    $0.name == "Lassie"
}.first!
// Confirm the objects are frozen.
assert(frozenTimmy.isFrozen == true)
assert(frozenLassie.isFrozen == true)
// Thaw the frozen objects. You must thaw both the object
// you want to append and the collection you want to append it to.
let thawedTimmy = frozenTimmy.thaw()
let thawedLassie = frozenLassie.thaw()
let realm = try! Realm()
try! realm.write {
    thawedTimmy?.dogs.append(thawedLassie!)
}
XCTAssertEqual(thawedTimmy?.dogs.first?.name, "Lassie")

Gitとの比較と対比

Git のような分散バージョン管理システムに理解がある場合 、MVCC について直感的に理解しているかもしれません。Git の 2 つの基本要素は次のとおりです。

• アトミックな書込みである コミット 。

• ブランチはコミット履歴の異なるバージョンです。

同様に、Realm にはトランザクションの形式でアトミックにコミットされた書込み (write) があります。 Realm には、ブランチと同様に、常に多くの異なるバージョンの履歴があります。

フォークを通じて分散と相違をアクティブにサポートする Git とは異なり、Realm には常に最新バージョンが 1 つだけあり、常にその最新バージョンのヘッドに書込まれます。 Realm は以前のバージョンに書込むことはできません。 つまり、データは 1 つの最新バージョンの真実のバージョンに変換されます。

内部構造

Realm は B+ ツリー を使用して実装されています データ構造。最上位の ノードは Realm のバージョンを表します。子ノードは、そのバージョンの Realm 内のオブジェクトです。 Realm には最新バージョンへのポインターがあります。これは、Git が ヘッドコミット へのポインターを持っているのと同様です。

Realm はコピーオンライト手法を使用して 分離 を確保します と の 耐久性 。変更を加えると、Realm は書き込みのためにツリーの関連部分をコピーします。 その後、Realm は 2 つのフェーズで変更をコミットします。

• Realm は変更をディスクに書き込み、成功を確認します。

• 次に、Realm は最新バージョンのポインターを新しく書込まれたバージョンを指すように設定します。

この 2 段階のコミット プロセスにより、書込み (write) が部分的に失敗した場合でも、ツリーの関連する部分のコピーに対して変更が行われていたため、元のバージョンは一切破損しないことが保証されます。 同様に、Realm のルートポインターは、新しいバージョンの有効性が保証されるまで、元のバージョンを指します。

例

次の図は、コミット プロセスを示しています。

クリックして拡大します

1. Realm はツリーとして構成されています。 Realm には最新バージョン V1 へのポインターがあります。

2. 書き込み時に、Realm は V1 に基づいて新しいバージョン V2 を作成します。 Realm は変更対象のオブジェクトのコピー（A ¹ 、C ¹ ）を作成しますが、変更されていないオブジェクトへのリンクは引き続き元のバージョン（B、D）を指します。

3. コミットを検証した後、Realm はポインターを新しい最新バージョン（V2）に更新します。 その後、Realm はツリーに接続されなくなった古いノードを破棄します。

Realm はメモリ マッピングなどのゼロコピー メソッドを使用してデータを処理します。 Realm から値を読み取る場合、ほぼそのコピーではなく、実際のディスク上の値が表示されます。 これがライブ オブジェクトの基盤です。 これは、ディスクへの書き込みが検証された後に、Realm ヘッダー ポインターを新しいバージョンを指すように設定できる理由でもあります。