realm-swift: Opening Realm with async/await in actor causes Crash

Using Realm in a non-@MainActor async function is currently not supported. In Swift 5.6 it would often work by coincidence because execution after an await would continue on whatever thread the awaited thing ran on, so await Realm() in an async function would result in the code following that running on the main thread until your next call to an actor-isolated function. Swift 5.7 instead hops threads whenever changing actor isolation contexts, so an unisolated async function always run on a background thread instead.

If you have code which uses await Realm() and works in 5.6, marking the function as @MainActor will make it work with Swift 5.7 and function very similarly to what it happened to be doing in 5.6.

I ended up mapping to lightweight structs when returning any data from a function using Realm. This can have a slight overhead, but ensures items are passed as a copy instead of references.

We will be working on this in the next quarter.

Here’s an example of an actor that that performs backgrounded “utility” tasks using anasync function. Also mixed in a GCD for example. Easy way to remember: you cannot use a previously instantiated realm instance anytime after an await is used in the same scope, which actually makes sense.

await Realm() seems nonsensical to me, basically asking to yield the current run loop, asking the system to coordinate concurrency for some work, i picture something like this let realm = Thread.random { returning(Realm()) }

actor BackgroundTasks {
    static let GCDWorker = DispatchQueue(label: "experiments", qos: .utility, autoreleaseFrequency: .workItem)
    
    func example() async {
        let olderThan = 2.months.ago!
        
        // await for filtered frozen objects for reading
        let filteredChallenges: Results<Challenge> = await withCheckedContinuation { continuation in
            // We are confined to one thread in this block, go to town
            let realm = try! Realm()
            
            let challenges = realm.objects(Challenge.self).where { $0.refreshed_at < olderThan }
            continuation.resume(returning: challenges.freeze())
        }
        
        log.info("We filtered \(filteredChallenges.count) challenges, with ids \(filteredChallenges.map {$0.id} )")
        
        // await for old challenges to be deleted, and return the count that were deleted
        let numDeleted: Int = await withCheckedThrowingContinuation { continuation in
            let realm = try! Realm()
            
            let challenges = realm.objects(Challenge.self).where { $0.refreshed_at < olderThan }
            realm.write {
                realm.delete(challenges)
            }
            continuation.resume(returning: challenges.count)
        }
        
        log.info("We just deleted \(numDeleted) challenges")
        
        // Returns immediately
        GCDWorker.async {
            let realm = try! Realm(configuration: .defaultConfiguration, queue: GCDWorker)
            let groups = realm.objects(Group.self).where { $0.refreshed_at < olderThan }
            try! realm.write {
                realm.delete(groups)
            }
            
            log.info("deleted \(groups.count) groups")
        }
        log.info("GCD is doing stuff, i cant tell you anything ")
    }
    
}

do {
    let actor = BackgroundTasks()
    Task.detached(priority: .background) {
        await actor.example()
    }
}

We had the same issue on our project as well using Realm 10.26.0.

I ended up with a workaround by calling let realm = try Realm(queue: nil) which is the same as calling the try Realm() in a non-async version in an async function to make sure the returned realm instance is not on main thread.

This is now included in release 10.38.3:

@MainActor function mainThreadFunction() async throws {
    // These are identical: the async init continues to produce a
    // MainActor-confined Realm if no actor is supplied
    let realm1 = try await Realm()
    let realm2 = try await Realm(MainActor.shared)
}

// A simple example of a custom global actor
@globalActor actor BackgroundActor: GlobalActor {
    static var shared = BackgroundActor()
}

@BackgroundActor backgroundThreadFunction() async throws {
    // Explicitly specifying the actor is required for everything but MainActor
    let realm = try await Realm(actor: BackgroundActor.shared)
    try await realm.write {
        _ = realm.create(MyObject.self)
    }
    // Thread-confined Realms would sometimes throw an exception here, as we
    // may end up on a different thread after an `await`
    print("\(realm.objects(MyObject.self).count)")
}

actor MyActor {
    // An implicitly-unwrapped optional is used here to let us pass `self` to
    // `Realm(actor:)` within `init`
    var realm: Realm!
    init() async throws {
        realm = try await Realm(actor: self)
    }

    var count: Int {
        realm.objects(MyObject.self).count
    }

    func create() async throws {
        try await realm.asyncWrite {
            realm.create(MyObject.self)
        }
    }
}

// This function isn't isolated to the actor, so each operation has to be async
func createObjects() async throws {
    let actor = try await MyActor()
    for _ in 0..<5 {
      await actor.create()
    }
    print("\(await actor.count)")
}

// In an isolated function, an actor-isolated Realm can be used synchronously
func createObjects(in actor: isolated MyActor) async throws {
    await actor.realm.write {
        actor.realm.create(MyObject.self)
    }
    print("\(actor.realm.objects(MyObject.self).count)")
}

Any news on this topic?

@tgoyne Thanks, that did the trick. Now I’m finally rid of the thread race crashes.

@LilaQ @Drag0ndust Have you tried the workaround proposed by @yliu342: let realm = try Realm(queue: nil). It’s more a compiler issue than one of Realm probably, because the compiler produces an error if there is an equivalent async variant. However, in this case the async variant should not be used except you are using a synced Realm.

Any news on this topic?

Currently I have the problem that I have app code which runs perfectly fine with Xcode 13.4.1 and Swift 5.6.1. But with Xcode 14 Beta 6 Swift 5.7 it is instantly crashing with Terminating app due to uncaught exception 'RLMException', reason: 'Realm accessed from incorrect thread.'