Início / coding / Perguntas / 78701623
Accepted
Reinhard Männer
Asked: 2024-07-03 18:56:17 +0800 CST

Como acessar uma propriedade estática do Swift 6 segura para simultaneidade?

  • 772

Meu aplicativo usa uma classe Ae suas subclasses SubA_x. Apossui uma propriedade estática serialNumberque só é modificada pela classe Aquando uma subclasse é inicializada. Ele define uma propriedade let namepara que cada subclasse tenha um nome exclusivo. Aqui está o código:

class A {
    static var serialNumber = 0
    let name: String

    init( /* some parameters */ ) {
        A.serialNumber += 1
        self.name = "\(A.serialNumber)"
    }
}

final class SubA_1: A {
    init( /* some parameters */ ) {
        super.init( /* some parameters */ )
    }
}

Com a verificação estrita de simultaneidade do Swift 6, a linha onde serialNumberé inicializada fornece o erro

A propriedade estática 'serialNumber' não é segura para simultaneidade porque é um estado mutável compartilhado global não isolado

Entendo que cada subclasse Apode ser modificada var serialNumberem qualquer thread, portanto, corridas de dados são possíveis.

Mas como consigo essa funcionalidade de maneira segura para a simultaneidade?

Tentei fornecer serialNumberpor um ator:

actor SerialNumberManager {
    private var serialNumber = 0
    
    func getNextSerialNumber() -> Int {
        serialNumber += 1
        return serialNumber
    }
}

mas não consigo ligar getNextSerialNumber(), initexceto quando inité assíncrono. Mas então posso inicializar uma subclasse apenas em um contexto assíncrono, etc.

Provavelmente eu poderia fornecer minha própria sincronização baseada em GCD, mas deveria haver uma maneira de fazer isso dentro da simultaneidade do Swift.

swift

1 respostas

  1. Best Answer

    Se você deseja um estado compartilhado e seguro para threads, actoré uma abordagem lógica. Porém, se você quiser um que possa ser invocado a partir de contextos síncronos, basta escrever seu próprio gerenciador, implementando sua própria sincronização manual (com fila serial GCD ou, como mostrado abaixo, com um bloqueio):

    class SerialNumberManager: @unchecked Sendable {
    static let shared = SerialNumberManager()

    private let lock = NSLock()
    private var serialNumber = 0

    private init() { }

    func nextSerialNumber() -> Int {
        lock.withLock {
            serialNumber += 1
            return serialNumber
        }
    }
}

    Observe que só usaríamos @unchecked Sendablequando implementássemos a sincronização manual, como acima.

    E você poderia usá-lo assim:

    class A {
    let serialNumber = SerialNumberManager.shared.nextSerialNumber()
    let name: String

    init( /* some parameters */ ) {
        self.name = "\(serialNumber)"
    }
}

    Alternativamente, você poderia usar um OSAllocatedUnfairLock, que já é Sendable:

    import os.lock

class A {
    private static let serialNumber = OSAllocatedUnfairLock(initialState: 0)
    let name: String

    init( /* some parameters */ ) {
        let value = Self.serialNumber.withLock { value in
            value += 1
            return value
        }
        self.name = "\(value)"
    }
}

    Por uma questão de integridade, outras alternativas incluem atômicos ou UUIDs .

    • 1

relate perguntas