Sendable — ano ito, protocol ng kaligtasan ng thread

Ano ang Sendable protocol sa Swift?

Sendable — ay isang protocol mula sa standard library ng Swift (SE-0302) na nagmamarka ng mga uri na ligtas para sa pagpapadala sa pagitan ng mga domain ng isolation. Ang domain ng isolation ay tumutukoy sa actor, Task, o @MainActor na konteksto. Ang Sendable ay hindi naglalaman ng mga kinakailangan — ito ay kumikilos bilang isang marker ng kaligtasan.

Bakit kailangan ang Sendable

Bago ang Swift 5.5, ang mga developer ay maaaring magpadala ng anumang bagay sa pagitan ng mga thread sa pamamagitan ng DispatchQueue, at hindi sinusuri ng compiler kung ito ay ligtas. Sendable ay sumasara ng puwang na ito: ngayon ang compiler mismo ay sumusubaybay sa mga pagpapadala sa pagitan ng thread at hinaharangan ang mga hindi ligtas. Ginagawa nitong mas maaasahan ang concurrent code bago pa man ito patakbuhin.

struct UserProfile: Sendable {
    let name: String
    let age: Int
}

class NonSendableClass {
    var counter: Int = 0
}

Sa halimbawa, ang UserProfile ay maaaring ligtas na maipadala sa pagitan ng mga thread, dahil ito ay isang istraktura na may pare-parehong mga pag-aari ng mga uri ng Sendable. Ang NonSendableClass ay magdudulot ng error sa compilation kapag sinubukang ipadala sa pamamagitan ng await o sa Task.

Anong mga uri ang default na sumusunod sa Sendable

Mga uri ng Sendable sa Swift ay nahahati sa tatlong kategorya: mga uri ng halaga na may mga pag-aari ng Sendable, mga final na klase na may hindi nababagong estado, at mga function/pagsasara na minarkahan ng @Sendable. Awtomatikong tinutukoy ng compiler ang pagsunod sa Sendable para sa mga uri ng halaga.

Mga uri ng halaga at awtomatikong pagsunod

Struct, enum at tuple ay awtomatikong nagiging Sendable kung ang lahat ng kanilang mga pag-aari at nauugnay na halaga ay Sendable din. Ito ay isang konserbatibong diskarte: kung kahit isang pag-aari ay hindi sumusunod sa Sendable, ang buong uri ay hindi ituturing na ligtas.

Mga pangunahing uri

Lahat ng built-in na uri ng Swift — Int, String, Double, Bool, Optional, Array, Dictionary, Set — ay sumusunod sa Sendable. Ginagawa nitong ligtas ang komposisyon ng uri bilang default. Ang developer ay kailangan lamang maging maingat sa mga custom na klase.

Sendable at mga klase: @unchecked Sendable

@unchecked Sendable — ay isang mekanismo na nagpapahintulot sa isang klase na tahasang ideklara ang sarili bilang Sendable, na lumalampas sa mga pagsusuri ng compiler. Ang developer ay umaako ng responsibilidad para sa kaligtasan ng thread ng naturang klase. Ito ay kapaki-pakinabang para sa mga tulay ng Objective-C at mga optimized na istraktura.

Kailan gagamitin ang @unchecked Sendable

Ang @unchecked Sendable ay inilalapat kapag ang isang klase ay panloob na ginagarantiyahan ang kaligtasan sa pamamagitan ng mga lock o atomic na operasyon, ngunit hindi ito maaaring suriin ng compiler nang statically. Halimbawa, isang klase na may os_unfair_lock o pthread_mutex_t — ang kaligtasan ng thread nito ay sinisiguro ng code, ngunit hindi ito nakikita ng Swift.

final class AtomicCounter: @unchecked Sendable {
    private var value: Int = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        value += 1
        lock.unlock()
    }
}

Gamitin ang @unchecked Sendable nang maingat. Ito ay isang malinaw na senyales para sa ibang mga developer: “Sinuri ko, ito ay ligtas”. Ang isang error sa implementasyon ay maaaring humantong sa mga race condition na mahirap matukoy. Bago ilapat ang @unchecked, tiyakin na ang uri ay talagang hindi maisusulat muli bilang isang uri ng halaga.

Sendable na may Actor

Actor at Sendable ay dalawang panig ng parehong barya. Inihiwalay ng Actor ang estado nito, ngunit para sa pagpapalitan ng data sa labas ng mundo kailangan nitong magbalik ng mga uri ng Sendable. Kung ang isang pamamaraan ng actor ay nagbalik ng isang non-Sendable na uri, ang compiler ay naglalabas ng babala o error.

Pagpapadala ng data sa pamamagitan ng Sendable

Kapag nagpapadala ang actor ng data sa panlabas na code, ang data na ito ay tumatawid sa hangganan ng isolation. Sendable ay ginagarantiyahan na ang tatanggap ay maaaring gamitin ang mga ito nang ligtas sa labas ng actor. Ang actor mismo ay nananatiling nakahiwalay — ang panloob na estado nito ay hindi nabubunyag.

struct AccountSnapshot: Sendable {
    let id: UUID
    let balance: Double
    let lastUpdated: Date
}

actor BankActor {
    private var balance: Double = 0
    
    func snapshot() async -> AccountSnapshot {
        return AccountSnapshot(
            id: UUID(),
            balance: balance,
            lastUpdated: Date()
        )
    }
}

AccountSnapshot — ay isang Sendable na istraktura na naglalaman lamang ng let na mga pag-aari ng mga uri ng Sendable. Ang diskarte na ito ay best practice para sa pagkuha ng data mula sa isang actor. Ang snapshot ng estado ay ipinapadala ayon sa halaga, at hindi nawawalan ng kontrol ang actor sa estado nito.

Mga function at pagsasara ng Sendable

@Sendable — ay isang attribute para sa mga function at pagsasara na ginagarantiyahan na ang pagsasara ay hindi kumukuha ng non-Sendable na data sa isang nababagong paraan. Kapag ang isang pagsasara ay ipinadala sa Task o pamamaraan ng actor, ito ay dapat na Sendable.

Pagsusuri ng pagkuha sa @Sendable na mga pagsasara

Sinusuri ng compiler na ang @Sendable na pagsasara ay hindi kumukuha ng nababagong mga sanggunian sa mga klase. Ang pagkuha ng let na mga pag-aari ng mga uri ng Sendable ay pinapayagan. Ang pagkuha ng var variable ng isang reference type ay magdudulot ng error, dahil ang pagsasara ay maaaring isagawa nang sabay sa mutation.

func performAsync(operation: @Sendable () -> Void) {
    Task {
        await operation()
    }
}

let constant = "Safe"
var counter = 0
// counter — ang pagkuha ng var ay namumutate ng counter, error sa compilation
performAsync { // ❌ Mutation ng nakuhang var
    print(constant)
}

Ang patakaran ay simple: ang @Sendable na pagsasara ay maaari lamang kumuha ng data na mismo ay Sendable at hindi mamumutate mula sa labas. Para sa mga klase, ang pagkuha ng weak self reference ay pinapayagan kung ang klase ay hindi minarkahan bilang Sendable. Pinipigilan nito ang mga klasikong retain cycle at race condition.