Realm zugegriffen falsche thread - Swift 3

Oben auf meiner UITableViewController ist folgende:

let queue = DispatchQueue(label: "background")

Wenn eine Aufgabe gelöscht wird, wird im folgenden ausgeführt wird:

self.queue.async {
    autoreleasepool {
        let realm = try! Realm()
        realm.beginWrite()
        realm.delete(task)
        do {
            try realm.commitWrite()
        } catch let error {
            self.presentError()
        }
    } 
 }

Und dann bekomme ich den Fehler

Einstellung mit uncaught exception vom Typ
realm::IncorrectThreadException: Realm zugegriffen falsche thread.

Wie könnte ich dieses Problem beheben?

InformationsquelleAutor AppreciateIt | 2016-12-23

6

Wie es scheint, das schreiben passiert in einem anderen thread als das Objekt wurde ursprünglich aus erreichbar. Sie sollten in der Lage, es zu beheben durch die übergabe task's id und verwenden diese, um es aus der Datenbank abgerufen rechts, bevor Sie schreiben (in der async-block).

Also an der Spitze:
```
var taskId = 0  // Set this accordingly
```
und dann so etwas wie
```
self.queue.async {
    autoreleasepool {
        let realm = try! Realm()
        let tempTask = //get task from Realm based on taskId
        realm.beginWrite()
        realm.delete(tempTask)
        do {
            try realm.commitWrite()
        } catch let error {
            self.presentError()
        }
    } 
 }
```
- Ah, so ich nicht Lesen kann, vom Haupt-thread (UI-thread) wenn ich schreiben will? Sollte ich überdenken verwenden von threading dann überhaupt?
- Ja, es gibt etwas über das Reich Absturz, wenn Objekte zwischen threads übergeben. Das ist mir passiert eine Menge 🙂
- Glaubst du, es würde keine Vorteile beim Durchzug der schreibt, wenn ich auch einen extra Lesen?
- Ich denke, dass hängt von persönlichen Vorlieben und/oder Ihre app. Wenn es eine Verlangsamung des UI zu tun, alle gelöscht auf der main-thread, dann könnte ich sehen mit den async-block...aber wenn es nicht wirklich Auswirkungen auf die app-Reaktionsfähigkeit dann wäre es wahrscheinlich einfacher (und einige Datenbank-Operationen), um alle auf einen thread.
- Vielen Dank für diese! Dies ist, wie wir empfehlen-Verschiebung arbeiten, um die hintergrund-thread. Sie können taskId als primären Schlüssel des Reiches-Objekt, und klicken Sie dann abrufen einer Referenz auf einen hintergrund-thread, indem Realm.object(ofType:forPrimaryKey:).
- Als Allgemeine Faustregel empfehlen wir, die Verschiebung langlebig Reich schreiben Transaktionen, um die hintergrund-thread so viel wie möglich. Es ist möglich, weiterhin Lesen von Reich auf andere threads, die Mitte schreiben, aber Sie müssen vorsichtig sein, dass, wenn ein schreiben in Bearbeitung ist, in den hintergrund und Sie versuchen, und starten Sie auf dem Haupt-thread blockieren der UI, bis der hintergrund-Vorgang abgeschlossen wurde.
InformationsquelleAutor Samantha

Müssen wir verstehen, dass die Tatsache Reich-Objekte kann nicht zugegriffen werden, aus verschiedenen threads. Was dies bedeutet und wie man trainiert dieses Problem.

Erste, Reich-Objekte nicht den Zugriff aus verschiedenen Threads bedeutet, eine Instanz von thread definiert in einem thread werden kann den Zugriff aus dem anderen thread. Was wir tun sollten, eigentlich müssen wir eine andere Instanz des Reiches-Instanz für jeden thread.

ZB. schauen wir uns folgenden z.B. wo setzen wir 50 Datensätze in der Datenbank, die asynchron in hintergrund-thread auf button klicken und wir fügen Benachrichtigung block im Haupt-thread zu aktualisieren, die nicht von Menschen, die in count-label. Jeder thread (Haupt-und hintergrund ) haben eine eigene Instanz des Reiches-Objekt Zugriff auf Realm Datenbank. Denn Reich-Datenbank erreicht, thread-Sicherheit, indem Sie Instanzen des Reiches thread-beschränkt.

class Person: Object {
    dynamic var name = ""
    convenience init(_ name: String) {
        self.init()
        self.name = name
    }
}


override func viewDidAppear(_ animated: Bool) {
    let realmMain = try!  Realm ()
    self.people = realmMain.objects(Person.self)
    self.notification = self.people?.addNotificationBlock{ [weak self] changes in
        print("UI update needed")
        guard let countLabel = self?.countLabel else {
            return
        }
        countLabel.text = "Total People: \(String(describing: self?.people?.count))"
    }
}

@IBAction func addHandler(_ sender: Any) {
    print(#function)
    let backgroundQueue = DispatchQueue(label: "com.app.queue",
                                        qos: .background,
                                        target: nil)



    backgroundQueue.async {
        print("Dispatched to background queue")
        let realm = try! Realm()
        try! realm.write {
            for i in 1..<50 {
                let name = String(format: "rajan-%d", i)
                //print(#function, name)
                realm.add(Person(name))
            }
        }

    }
}

InformationsquelleAutor Rajan Twanabashu

0

Können Sie auch ein Threadsicher Referenz, einen bestimmten Weg zu passieren realm Objekte zwischen threads:
```
let realm = try! Realm()
let person = Person(name: "Jane") //no primary key required 
try! realm.write {
    realm.add(person)
}
let personRef = ThreadSafeReference(to: person)
DispatchQueue(label: "com.example.myApp.bg").async {
    let realm = try! Realm()
    guard let person = realm.resolve(personRef) else {
    return //person was deleted
}
try! realm.write {
    person.name = "Jane Doe"
}
```
Die Schritte von Reich-Dokumentation:
1. Initialisieren einer ThreadSafeReference mit dem thread-beschränkt Objekt.
2. Passieren, dass ThreadSafeReference zu einem Ziel-thread oder queue.
3. Beheben diese Referenz auf den Ziel-Bereich durch Aufruf von
  Reich.beheben(_:).
4. Verwenden Sie das zurückgegebene Objekt, wie Sie es normalerweise würden.
InformationsquelleAutor sheinix

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.