Swift Concurrency - Swift SDK

Advertencias sobre la concurrencia de Realm

As you implement concurrency features in your app, consider this caveat about Realm's threading model and Swift concurrency threading behaviors.

Async/Await APIs

Many Realm Swift APIs that involve working with an Atlas App Services app or a synchronized realm are compatible with Swift's async/await syntax. For examples, check out:

• Asíncrono/Await Inicio de sesión

• Administrar usuarios de correo electrónico y contraseña

• Link User Identities - Async/Await

• Open a Synced Realm or a local realm

• Await notifications from another actor

• Administrar suscripciones de sincronización flexible

• Async/Await Call a Serverless Function

• Async/Await Query MongoDB

• Operaciones CRUD asíncronas/en espera

Si tienes solicitudes de funcionalidades específicas relacionadas con las APIs asíncronas/await de Swift, consulta el Motor de opiniones MongoDB para Realm. El equipo de Realm Swift SDK planea continuar desarrollando funcionalidades relacionadas con la concurrencia basándose en la retroalimentación de la comunidad y en la evolución de la concurrencia de Swift.

Tasks and TaskGroups

Swift concurrency provides APIs to manage Tasks and TaskGroups. The Swift concurrency documentation defines a task as a unit of work that can be run asynchronously as part of your program. Task allows you to specificially define a unit of asynchronous work. TaskGroup lets you define a collection of Tasks to execute as a unit under the parent TaskGroup.

Las tareas y los grupos de tareas permiten asignar el hilo a otras tareas importantes o cancelar una tarea de larga duración que podría bloquear otras operaciones. Para obtener estas ventajas, podrías considerar usar tareas y grupos de tareas para gestionar las escrituras en el dominio en segundo plano.

However, the thread-confined constraints described in Suspending Execution with Await above apply in the Task context. If your Task contains await points, subsequent code might run or resume on a different thread and violate Realm's thread confinement.

You must annotate functions that you run in a Task context with @MainActor to ensure code that accesses Realm only runs on the main thread. This negates some of the benefits of using Tasks, and may mean this is not a good design choice for apps that use Realm unless you are using Tasks solely for networking activities like managing users.

Actor Isolation

Actor isolation provides the perception of confining Realm access to a dedicated actor, and therefore seems like a safe way to manage Realm access in an asynchronous context.

However, using Realm in a non-@MainActor async function is currently not supported.

En Swift 5.6, esto a menudo funcionaba por casualidad. La ejecución después de un await continuaría en cualquier hilo en el que se ejecutó lo que se esperaba. El uso de await Realm() en una función asíncrona haría que el código posterior se ejecute en el hilo principal hasta la siguiente llamada a una función aislada por un actor.

Swift 5.7 instead hops threads whenever changing actor isolation contexts. An unisolated async function always runs on a background thread instead.

Si tienes código que utiliza await Realm() y funciona en la versión 5.6, marcar la función como @MainActor hará que funcione con Swift 5.7. Funcionará como lo hizo - sin querer - en 5.6.

Errores relacionados con el código de concurrencia

La mayoría de las veces, el error que ves relacionado con el acceso a Realm a través de código concurrente es Realm accessed from incorrect thread. Esto se debe a los problemas de aislamiento de hilos que se describen en esta página.

Para evitar problemas relacionados con el threading en el código que utiliza funcionalidades de concurrencia de Swift:

• Actualiza a una versión del SDK de Realm Swift que admita realms aislados por actor y utiliza esto como una alternativa a la gestión manual de hilos. Para obtener más información, consulta Usar Realm con Actores - Swift SDK.

• No cambie los contextos de ejecución al acceder a un dominio. Si abre un dominio en el hilo principal para proporcionar datos a su interfaz de usuario, anote con @MainActor las funciones posteriores donde acceda al dominio de forma asíncrona para garantizar que siempre se ejecuten en el hilo principal. Recuerde que await marca un punto de suspensión que podría cambiar a otro hilo.

• Apps that do not use actor-isolated realms can use the writeAsync API to perform a background write. This manages realm access in a thread-safe way without requiring you to write specialized code to do it yourself. This is a special API that outsources aspects of the write process - where it is safe to do so - to run in an async context. Unless you are writing to an actor-isolated realm, you do not use this method with Swift's async/await syntax. Use this method synchronously in your code. Alternately, you can use the asyncWrite API with Swift's async/await syntax when awaiting writes to asynchronous realms.

• If you want to explicitly write concurrency code that is not actor-isolated where accessing a realm is done in a thread-safe way, you can explicitly pass instances across threads where applicable to avoid threading-related crashes. This does require a good understanding of Realm's threading model, as well as being mindful of Swift concurrency threading behaviors.

Tipos enviables, no enviables y confinados a subprocesos

The Realm Swift SDK public API contains types that fall into three broad categories:

• Sendable

• Not Sendable and not thread confined

• Thread-confined

You can share types that are not Sendable and not thread confined between threads, but you must synchronize them.

Los tipos confinados por subprocesos, a menos que estén congelados, se limitan a un contexto de aislamiento. No se pueden pasar entre estos contextos, ni siquiera con sincronización.