Simultaneidade Swift - Swift SDK

Advertências sobre simultaneidade de Realm

Ao implementar recursos de simultaneidade em seu aplicativo, considere esta ressalva sobre o modelo de threading do Realm e os comportamentos de threading de simultaneidade do Swift.

API assíncronas/de espera

Muitas API do Realm Swift que envolvem o trabalho com um aplicativo Atlas App Services ou um domínio sincronizado são compatíveis com a sintaxe async/await do Swift. Por exemplo, confira:

• Login Assíncrono/Aguardar

• Gerenciar usuários de e-mail/senha

• Vincular identidades de usuário - Async/Await

• Abra um Realm Sincronizado ou um termo local

• Aguardar notificações de outro ator

• Gerenciar assinaturas de sincronização flexível

• Deixar assíncrono/Aguardar chamada para uma função sem servidor

• Assíncrono/Aguardar query MongoDB

• Assíncrono/Aguardar Operações de CRUD

Se você tiver solicitações de recursos específicos relacionados às API async/await do Swift, consulte o mecanismo de feedback do MongoDB para Realm. A equipe do Swift SDK planeja continuar a desenvolver recursos relacionados à simultaneidade com base no feedback da comunidade e na evolução da simultaneidade do Swift.

Tarefas e grupos de tarefas

A Swift Concurrency fornece APIs para gerenciar Tarefas e Grupos de tarefas. A documentação de concorrência rápida define uma tarefa como uma unidade de trabalho que pode ser executada de forma assíncrona como parte do seu programa. A tarefa permite definir especificamente uma unidade de trabalho assíncrono. O grupo de tarefas permite definir uma coleção de tarefas a serem executadas como uma unidade no grupo de tarefas pai.

Tarefas e grupos de tarefas oferecem a capacidade de transferir o thread para outros trabalhos importantes ou cancelar uma tarefa de longa duração que pode estar bloqueando outras operações. Para obter esses benefícios, você pode ficar tentado a usar Tarefas e Grupos de Tarefas para managed gravações no reino em segundo plano.

No entanto, as restrições de thread confinadas descritas em Suspendendo a execução com Await acima se aplicam no contexto Tarefa. Se sua Tarefa contiver await pontos, o código subsequente poderá ser executado ou retomado em uma thread diferente e violar o confinamento de thread do Realm.

Você deve anotar as funções que você executa em um contexto de tarefa com @MainActor para garantir que o código que acessa o Realm seja executado somente no thread principal. Isso nega alguns dos benefícios de usar Tarefas e pode média que essa não é uma boa opção de design para aplicativos que usam o Realm, a menos que você esteja usando Tarefas apenas para atividades de rede, como gerenciar usuários.

Isolamento de atores

O isolamento do ator fornece a percepção de confinar o acesso ao Realm a um ator dedicado e, portanto, parece uma maneira segura de manage o access ao Realm em um contexto asíncrono.

No entanto, o uso do Realm em uma função assíncrona que não seja@MainActor atualmente não é suportado.

No Swift 5.6, isso geralmente funcionava por coincidência. A execução após um await continuaria em qualquer thread em que o item esperado fosse executado. Usar await Realm() em uma função assíncrona resultaria na execução do código seguinte na thread principal até sua próxima chamada para uma função isolada do ator.

Em vez disso, o Swift 5.7 alterna as threads sempre que muda os contextos de isolamento do ator. Em vez disso, uma função assíncrona isolada sempre é executada em uma thread de fundo.

Se você tiver código que utiliza await Realm() e trabalha no 5.6, marcar a função como @MainActor fará com que ela funcione com Swift 5.7. Ele funcionará como funcionou - involuntariamente - no 5.6.

Erros relacionados ao código de simultaneidade

Na maioria das vezes, o erro que você vê relacionado ao acesso ao Realm por meio de código de concorrência é Realm accessed from incorrect thread. Isso se deve aos problemas de isolamento de thread descritos nesta página.

Para evitar problemas relacionados a segmentações em códigos que usam recursos de simultaneidade do Swift:

• Atualize para uma versão do domínio Swift SDK que ofereça suporte a domínios isolados do ator e use isso como uma alternativa para gerenciar manualmente o threading. Para obter mais informações, consulte Usar Realm com atores - Swift SDK.

• Não altere os contextos de execução ao acessar um Realm. Se você abrir um Realm na thread principal para fornecer dados para sua UI, anote as funções subsequentes onde você acessa o Realm de forma assíncrona com o @MainActor para garantir que ele sempre seja executado na thread principal. Lembre-se de que await marca um ponto de suspensão que pode mudar para uma thread diferente.

• Os aplicativos que não usam domínios isolados por ator podem usar a API writeAsync para executar uma gravação em segundo plano. Isso gerencia o acesso ao domínio de maneira segura para threads, sem exigir que você escreva código especializado para fazer isso sozinho. Esta é uma API especial que terceiriza aspectos do processo de gravação - onde for seguro fazê-lo - para execução em um contexto assíncrono. A menos que você esteja gravando em um domínio isolado por ator, você não usa este método com a sintaxe async/await do Swift. Use este método de forma síncrona em seu código. Como alternativa, você pode usar a API asyncWrite com a sintaxe async/await do Swift ao aguardar gravações em regiões assíncronas.

• Se quiser escrever explicitamente um código de simultaneidade que não seja isolado por atores, em que o acesso a um reino seja feito de forma segura para threads, você poderá passar explicitamente instâncias entre threads, quando aplicável, para evitar falhas relacionadas a threads. Isso requer um bom entendimento do modelo de threading do Realm, além de estar atento aos comportamentos de threading de simultaneidade do Swift.

Tipos Enviáveis, Não Enviáveis e Confinados a Threads

A API pública do SDK do Realm Swift contém tipos que se enquadram em três categorias amplas:

• Enviável

• Não pode ser enviado e não está confinado a threads

• Confinado por thread

Você pode compartilhar tipos que não são Sendable e que não são confinados por thread entre threads, mas deve sincronizá-los.

Os tipos confinados por thread, a menos que congelados, estão confinados a um contexto de isolamento. Você não pode passá-los entre esses contextos, mesmo com sincronização.