Início / coding / Perguntas / 79589648
Accepted
Youmate
Asked: 2025-04-24 07:56:48 +0800 CST

A propriedade 'logs' isolada do ator não pode ser referenciada a partir de um contexto não isolado

  • 772

Estou tentando aprender Swift 6. O problema que tenho enfrentado é que não consigo ler (não tentar modificar) as propriedades de actorum UI class.

É possível ler sem adicionar propriedades armazenadas extras ou aguardar?

Você pode me dar alguma solução para isso?

final actor Logger: Sendable {
    
    static let current = Logger()
    
    private(set) final var logs: [Int] = []
    
    private init() { }
    
    nonisolated var count: Int {
        
        return self.logs.count
    }
}

final class ViewController: NSViewController, NSTableViewDataSource {
   
    @IBOutlet weak var tableView: NSTableView!
     
    func numberOfRows(in tableView: NSTableView) -> Int {
        
        return Logger.current.count
    }
}

Erro:

A propriedade 'logs' isolada do ator não pode ser referenciada a partir de um contexto não isolado

Obrigado!

swift

1 respostas

  1. Best Answer

    Você pode usar um mecanismo de sincronização diferente se quiser acessar isso de diferentes contextos de simultaneidade sem await. Por exemplo, SE-0433 diz:

    Em programas concorrentes, proteger o estado mutável compartilhado é um dos principais problemas fundamentais para garantir que a leitura e a escrita de dados sejam feitas de forma explicável. Sincronizar o acesso ao estado mutável compartilhado não é um problema novo no Swift. Introduzimos muitos recursos para ajudar a proteger dados mutáveis. Atores são uma boa solução padrão para proteger o estado mutável, pois isolam os dados armazenados em seu próprio domínio. Em qualquer momento, apenas uma tarefa estará em execução "no" ator e terá acesso exclusivo a ele. Múltiplas tarefas não podem acessar o estado protegido pelo ator ao mesmo tempo, embora possam intercalar a execução em potenciais pontos de suspensão (indicados por await). Em geral, a abordagem do ator também se presta bem à organização do código, já que o estado do ator e as operações sobre esse estado são logicamente declarados no mesmo lugar: dentro do ator.

    Nem todo código pode (ou deseja) adotar atores. Os motivos para isso podem ser muito variados; por exemplo, o código pode ter que ser executado de forma síncrona sem qualquer possibilidade de outras tarefas intercalarem com ele. Ou o asyncefeito introduzido nos métodos pode impedir que código legado que não pode usar a Concorrência Swift interaja com o estado protegido.

    Seja qual for o motivo, pode não ser viável usar um ator. Nesses casos, o Swift atualmente carece de ferramentas padrão para que os desenvolvedores garantam a sincronização adequada em suas estruturas de dados concorrentes. Muitos programas Swift optam por usar implementações ad-hoc de um bloqueio de exclusão mútua, ou um mutex. Um mutex é uma primitiva de sincronização simples de usar para ajudar a proteger dados mutáveis ​​compartilhados, garantindo que um único contexto de execução tenha acesso exclusivo aos dados relacionados. O principal problema é que não existe uma única implementação padronizada para essa primitiva de sincronização, o que faz com que todos precisem criar a sua própria.

    Então, no Swift 6 pode-se usar Mutex:

    import Synchronization

final class Logger: Sendable {
    static let current = Logger()

    private let logs = Mutex<[Int]>([])

    private init() { }

    var count: Int {
        logs.withLock { $0.count }
    }
}

    Em plataformas Apple, isso usa um bloqueio injusto. E se você quiser fazer isso em versões anteriores do sistema operacional, pode substituir o Mutexpor um OSAllocatedUnfairLock:

    import os.lock

final class Logger: Sendable {
    static let current = Logger()

    private let logs = OSAllocatedUnfairLock(initialState: [Int]())

    private init() { }

    var count: Int {
        logs.withLock { $0.count }
    }
}

    Agora, provavelmente, você pode querer acessar os próprios “logs”: se for o caso, você pode simplesmente expor isso e retirar propriedades computadas individuais como count, e similares, que introduzem corridas e, em vez disso, apenas retornar o logs:

    import Synchronization

final class Logger: Sendable {
    static let current = Logger()

    private let _logs = Mutex<[Int]>([])

    private init() { }

    var logs: [Int] {
        _logs.withLock { $0 }
    }

    func append(_ value: Int) {
        _logs.withLock { $0.append(value) }
    }
}

    Dessa forma, o chamador obtém uma cópia segura do array, evitando disputas entre a busca counte as mutações da coleção que podem estar ocorrendo em threads diferentes.

    • 1

relate perguntas