I-Swift Competition—I-Part 1: Imisebenzi, Abasebenzi, nokuphakama kwePriority

I-Swift 6 ibonise indlela entsha yokusebenza kwe-app concurrents. Kule nqaku, sincoma imiphumela esisebenzayo, ibonise indlela yokusebenza ngaphansi kwe-cockpit, ibonise imodeli entsha ne-anterial, futhi ubonise imodeli ye-Actor. Kule izingxenye ezidlulayo, sincoma futhi i-executors, i-schedulers, i-concurrents eyenziwe, izinhlobo ezahlukene ze-executors, ukulawula i-executor yethu, nokuningi. Umhlahlandlela we-Swift Competition: Imibuzo nezisombululo Ukubhalisa ikhowudi okuzenzakalelayo okuzenzakalelayo kungenziwa ngempumelelo nokuphucula ukusebenza nokuphendula, kodwa kusebenza ngokuvamile nge-complexity kanye ne-bugs ezincinane njenge-racing conditions, deadlocks, ne-trade-safety issues. I-Swift Concurrency, eyenziwa ku-Swift 6, inikeza ukucubungula ukucubungula okuzenzakalelayo ngokuvumela imodeli eluhlaza, elawulwa futhi efanelekayo yokufakelwa kwezinqubo asynchronous. I-Swift Concurrency inikeza abathengisi ukunceda iziphakamiso ezivamile ngokuvumelana nezinsizakalo ezincinane zokusebenzisa idatha kanye nesikhathi sokusebenza. 💡Uma usebenzisa i-Swift 5.x futhi ukhangela ku-Swift 6, ungakwazi ukufaka izivivinyo ze-Swift ye-Concurrency ezivela ku-project yakho. Lokhu kukuvumela ukuvumelele ngokushesha imodeli entsha ye-concurrency ngokuvumelana nokugcina ukuxhumana ne-code eyenziwe. Ukuvumelela kwezivivinyo ezivela ku-Swift kusiza ukuthatha imibuzo ye-concurrency emibi ngokushesha, okwenza ukufinyelela okuhlobene futhi ekhuselekileyo. Njengoba usethule isisekelo sakho se-codebase, ungakwazi ukuqala ukuhlanganisa i-async/await syntax kanye nezinye izici ze-Swift ye-Concurrency ngokushesha ngaphandle kokuqinisekisa okugcwele. 💡Uma usebenzisa i-Swift 5.x futhi uthetha ukuguqulwa ku-Swift 6, ungakwazi ukufaka izivivinyo ze-Concurrency ze-Swift ku-project yakho. Lokhu kukuvumela ukuthatha imodeli entsha ye-concurrency ngokushesha ngenkathi ukugcina ukuxhumana ne-code eyenziwe. Ukusebenza kwezivivinyo ze-concurrency kunceda ukuthatha imibuzo ye-concurrency emibi ngokushesha, okwenza ukufinyelela ngokushesha futhi kulula. Njengoba usethule isisekelo sakho se-codebase, ungakwazi ukuqala ukuhlanganiswa async/await I-syntax kanye nezinye izici ze-Swift Concurrency zihlanganisa ngokushesha ngaphandle kokubili okugcwele. Some of the key problems Swift Concurrency addresses include: Izimo ze-Race: Ukukhangisa ukufinyelela okuqhubekayo ku-shared mutable state okuyinto kungabangela ukusebenza okuqhubekayo. Callback hell: Ukunciphisa ikhodi asynchronous okuyinto asebenzayo kakhulu ku-nested callbacks noma ukucubungula ukucubungula, okwenza ikhodi kulula ukucubungula nokuphathwa. Thread ukulawula ukucindezeleka: Ukukhuthaza ukwakhiwa okuphansi kanye synchronization, okuvumela abathengisi ukuncintisana logic kunoma ukucutshungulwa thread. I-Coordinating Task Concurrent: I-Concurrent Structured ivumela i-hierarchy ye-tasks ngokucacileyo nge-cancellation kanye ne-error propagation. Ukusetshenziswa kwezinto ezintsha zebhizinisi ezifana I-Actors, ne-Structured concurrent, i-Swift 6 inikeza indlela enhle futhi enhle yokubhala ikhodi enhle, okwandisa ukukhiqizwa kwama-developer ne-app stability. async/await Multitasking I-operating systems kanye ne-runtimes ezivamile zisebenzisa i-multi-tasking ukuze isebenze izinhlayiya zokusebenza ngokufanayo. I-Swift Concurrency isebenzisa i-multi-tasking e-cooperative, okuyinto ingahlukile kakhulu emadolobheni ye-multi-tasking e-preemptive esetshenziselwa ama-OS-level threads. Ukuphathelela ukuhlangabezana kunomthombo yokubhalisa i-asynchronous asynchronous Swift code. Ukukhishwa kweMultitasking I-preemptive multitasking iyimodeli esetshenziselwa izinhlelo zokusebenza ukulawula i-threads kanye ne-processes. Kule imodeli, i-system-level scheduler ingathintela i-threads noma iyiphi i-threads ngexesha elilodwa ukuze isebenze i-context switch kanye nokuthintela isikhathi ye-CPU kwamanye ama-threads. Lokhu kuncike ukunemba kwinkqubo futhi ivumela izicelo ezisebenzayo - ikakhulukazi lapho ukulawula izicelo eziningana ezisebenzayo noma zokusebenzayo. I-preemptive multitasking ivumela ukuhanjiswa okwenziwe phakathi kwama-CPU amaningi futhi ivimbela ukuhanjiswa okungenani noma ukuhanjiswa okungenani kusuka ku-monopolizing izinhlelo izinsiza. Kodwa-ke, lokhu ukuhanjiswa kunezinto. Ngenxa yokuba ama-threads angakwazi ukuchithwa ngesikhathi esikhathini esizayo - ngisho emzimbeni lokusebenza esiyingqayizivele - ama-developer kufanele usebenzisa ama-synchronization primitives efana ne-mutexes, i-semaphores, noma izinsizakalo ze-atomic ukuvikela izimo ezahlukile ezahlukile. Ukunciphisa lokhu kungase kuholele ku-data races, i-crashes, noma ama-bugs ezinzima ezinzima ezinzima ezihamb Kuyinto model inikeza ukulawula okuningi kanye nokuhlukaniswa okungenani, kodwa kunikeza isisindo ephakeme kakhulu kwama-developer. Ukupholisa ukhuseleko kwe-trade ku-environment preemptive kunokukwazi ukufakelwa kwama-error futhi kungabangela ekuphenduleni kwe-non-deterministic - isebenza esihlukile ukusuka ku-run-to-run - okuyinto enzima kakhulu ukuhlola noma ukuhlola kahle. Ngokusho lwezobuchwepheshe, i-preemptive multitasking inikeza uhlelo lokusebenza ukuhlangabezana nokulethwa kwe-thread. I-OS inokukwazi ukuhlangabezana i-thread ngexesha elilodwa - ngisho phakathi kwe-function - futhi ukuguqulwa kwalo. Ukuze ukwenza lokhu, uhlelo kufuneka usebenza i-context switch, okuyinto kuhlanganise ukugcina idatha ephelele yokulethwa kwe-thread yamanje (njenge-CPU registers, i-instruction pointer, ne-stack pointer), futhi ukuguqulwa kwegama elidlulayo ye-thread elinye. Le nqubo kungenzeka futhi ukwehlisa ama-cache ye-CPU, ukunciphisa i-Translation Lookaside Buffer (TLB), kanye nokuguqulwa phakathi kw Lezi zokusebenza zihlanganisa isikhathi esikhulu sokusebenza. Umshicileli we-context usebenzisa isikhathi futhi isisindo se-system - ikakhulukazi lapho izixazululo ze-context zihlanganisa ngokushesha noma lapho ama-threads eziningi zihlanganisa izici ze-CPU amancane. Ngaphezu kwalokho, i-preemptive multitasking inikeza abathuthukisi ukudala ikhodi e-thread-safe ngokuvamile, ukwandisa ukuxuba okuqukethwe jikelele kanye ne-risk ye-concurrency bugs. Nangona le model inikeza ukunambitheka okuphakeme kanye ne-parallelism enhle, kubaluleke kakhulu ku-asynchronous workflows, lapho izinsizakalo zihlola isikhathi esikhulu sokuhamba i-I/O, i-user input, noma imibuzo ye-network ngaphandle kokusebenzisa i-CPU. I-Multitasking ye-Cooperative Ngaphandle kwalokho, isikhathi sokusebenza se-Swift isebenzisa i-cooperative multitasking. Kulesi model, umsebenzi isebenza kuze kube lithunyelwe ngokuvumelana – ikakhulukazi ngesikhathi esifundeni noma ngokusebenzisa isicelo esifundeni Ngokungafani ne-threads ezivamile, izivakashi zokuhlobisa akuyona ngokushesha. Lokhu kuholele ekukhiqizeni okuhlobisa: izibuyekezo ze-context zihlanganisa kuphela ngezindawo zokuhlobisa ezivamile. Task.yield() Swift’s cooperative tasks are scheduled onto a lightweight, runtime-managed cooperative thread pool—separate from Grand Central Dispatch queues. Tasks running in this pool are expected to be “good citizens,” yielding control when appropriate, especially during long-running or CPU-intensive work. To support this, Swift provides njenge-manual suspension point, ukuhlinzeka ukuthi izinhlelo ezingaphezu zihlanganisa izinga lokusebenza. Task.yield() Nangona kunjalo, i-co-operative multitasking inikeza isibuyekezo: Uma isebenze isivumelwano, kungase i-monopoly ye-trade esebenzayo, ukunciphisa noma ukunciphisa ezinye izivumelwano emkhakheni. Ngakho-ke, kubaluleke ukuthi isivumelwano se-long-running kuhlanganisa amaphuzu e-suspension. Ngo-co-operative multitasking, isakhiwo esisodwa sokusebenza akuyona i-thread, kodwa i-chunk of work, ebizwa nangokuthi yi-continuation. I-continuation kuyinto ingxenye esisondelene ye-asynchronous function. Uma i-asynchronous Function isixazululwa at an , i-Swift runtime ibonisa isimo se-execution esilandelayo ku-heap-allocated continuation. Lokhu ukuhambisana inikeza isikhokelo se-resumption futhi iyatholakala ekupheleni esilandelayo. async await Ngaphandle kokuhlanganisa i-thread nge-task eside, i-Swift runtime ithatha i-thread njenge-pipeline ye-continuations. I-thread yenza isinyathelo esisodwa esilandelayo. Uma isinyathelo esilandelayo ivuliwe noma ivuliwe esilandelayo, i-thread ithatha isinyathelo esilandelayo esilandelayo esilandelayo esilandelayo esilandelayo. Njengoba kubangelwa emaphaketheni, le imodeli ukunceda izibani zokusebenza ezivamile zokusebenza-level. Akukho ukugcina futhi ukuguqulwa ama-CPU registers noma ama-string stacks; isikhathi sokuhamba ngokuphathelene nesikhathi esilandelayo se-closure-like. Lokhu kwenza isibani se-task enhle kakhulu futhi enhle, kodwa kuhlanganise ukwanda kwe-heap allocations ukugcina isimo se-async esilandelayo. I-comprom-off ebalulekile: usebenzisa i-memory eningi kodwa ukwandisa i-overhead emangalisayo ekulawuleni umsebenzi. Ukuhlolwa kwe-cooperative inikeza ukulawula okusheshayo lapho izixazululo zitholakala, okwandisa ukubuyekeza futhi kusebenza ngokushesha. Ukusungula Ukusebenza Ukusebenza I-Swift Competition, a inikeza isikhungo sokusebenza asynchronous. Ngokungafani kokufaka kuphela isicelo, a is a managed object that runs concomitantly with other tasks in a cooperative thread pool. Task async Task 💡 Izinqubo zokusebenza nge-co-operative thread pool. I-co-operative thread pool yenzelwe ukulawula i-concurrency ngokushesha ngokuvumela izinsizakalo ukukhiqiza i-CPU ngenhloso izinsizakalo ze-asynchronous zokusebenza. Lokhu kufinyelela ngokusebenzisa ukusetshenziswa kwezinhlelo ze-async kanye nezinsizakalo, okuyizinhlelo eziyisisekelo ze-concurrency ku-Swift. 💡 Izinqubo zokusebenza nge-co-operative thread pool. I-co-operative thread pool yenzelwe ukulawula i-concurrency ngokushesha ngokuvumela izinsizakalo ukukhiqiza i-CPU ngenhloso izinsizakalo ze-asynchronous zokusebenza. Lokhu kufinyelela ngokusebenzisa ukusetshenziswa kwezinhlelo ze-async kanye nezinsizakalo, okuyizinhlelo eziyisisekelo ze-concurrency ku-Swift. Tasks can be created to run concurrently, and they can also be awaited or canceled. They provide fine-grained control over asynchronous behavior and are an integral part of structured concurrency in Swift. Ukwakha a Task A task can be created using the , okuyinto uqala ngokushesha isebenze asynchronous isebenze: Task Waze Waze Task(priority: .userInitiated) { await fetchData() } Uma utshintshe a ukusetshenziswa kwe-initializer ye-standard (isib. Akukho ), it wahlala i-akhawunti, i-priority, kanye ne-task-local values. Lezi zokusebenza kubaluleke ukuxhaswa kanye nokuphepha ku-coding ephilayo. Task Ukuhlobisa Ukuhlobisa 💡 I-Swift 6.2 ibonise ukuguqulwa okuphakeme kwindlela yokusebenza kwe-concurrency: ngokuvamile, wonke ikhodi isebenza ku-MainActor. Ukuze isebenze ikhodi emkhakheni, i-Swift 6.2 ibonise impahla entsha ye- @concurrent. Ungasebenzisa futhi kungekho-isolated uma ikhodi akufanele ukufinyelela kwama-akhawunti yokuqala. I-WWDC Embracing Swift Concurrency 💡 I-Swift 6.2 ibonise ukuguqulwa okukhanyisa indlela yokusebenza kwe-concurrency: ngokuvamile, yonke ikhodi isebenza ku-concurrency. MainActor Ukuze isebenze ikhodi emkhakheni, i-Swift 6.2 inikeza impahla entsha @concurrent Ngaba usebenzisa futhi nonisolated uma ikhodi akudingeki ukufinyelela umbhali wokuqala. WWDC Embracing Swift Concurrency I-WWDC ibopha i-Swift Competition I-WWDC ibopha i-Swift Competition Phakathi ne-cap, ezivamile ezivamile ezivela ku-Swift Concurrency, i-Swift runtime isetshenziselwa isakhiwo se-internal ebizwa ngokuthi i-Swift Runtime. to track which actor a task was associated with. Although this property wasn’t part of the public API, it played a key role in ensuring that tasks created inside actor-isolated code would execute on the same actor, preserving data race safety. @_inheritActorContext Nge izinzuzo ze-Swift, i-runtime ihamba ukusuka Ukusebenza kwe-Mechanism ebizwa ngokuthi , okuyinto kusebenza ngokuvamile ku-compiler kanye ne-runtime. @_inheritActorContext sending 💡 What is sending ? sending is a new keyword introduced in Swift 6 as a part of language’s move toward safer and more explicit concurrency. It’s used to mark function parameters and return values that are moved across concurrency boundaries. It works especially well noncopyable types, ensuring memory safety and preventing use-after-move errors. When a parameter is marked with sending , the compiler enforces that the original instance is no longer accessed after the transfer. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } Yini sending ? sending is a new keyword eyenziwa ku-Swift 6 njenge-part of the language's move towards safer and more explicit concurrent. It is used to mark function parameters and return values that are moved across concurrent boundaries. It works especially well noncopyable types, enikezela ukhuseleko memory and preventing use-after-move errors. When a parameter is marked with sending , i-compiler ivimbele ukuthi isithombe se-original akuyona engatholakali emva kokuthumela. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } Uma uqala a , kufanele uqinisekisa ukuthi ezinye izindleko eziholile eziholile . The compiler now enforces this at compile-time using I-Protocol kanye ne- Umsebenzi uhlobo. Task.detached Sendable Sendable @Sendable Ukukhangisa ukuhambisa kungenziwa ku-compile-time error, ikakhulukazi ku-strict concurrency mode. Sendable Tasks also support priorities, similar to how Grand Central Dispatch queues handle them. Waze Task Task.detached Uma usebenzise ne-Swift Concurrency, kubaluleke ukucaciswa phakathi Waze , njengoba zihlanganisa indlela futhi lapho ukusebenza umsebenzi asynchronous. Task Task.detached Task Ukusebenza umkhakha umkhakha we-akhawunti (njenge noma noma unayo i-actor eyodwa) kanye ne-priority. Isetshenziselwa ngokuvamile lapho ufuna ukuqala isebenze isebenze esisha asynchronous okuyinto kuncike isakhiwo se-tree ye-concurrency noma isibonelelo se-actor. Lokhu kubalulekile ikakhulukazi ukulethwa kwe-UI noma ukusebenza ngaphakathi kwedoma ye-concurrency ezithile. Task MainActor Task { await updateUI() } In the example above, if called from the main actor, the will also run on the main actor unless explicitly moved elsewhere. Task Task.detached Ukusebenza Yenza umsebenzi olungapheliyo ngokuphelele. Akukwazi ukuvuselelwa kwe-akhawunti yamanje noma i-priority. Lokhu kubalulekile ukuba kuqala ku-global concurrent context futhi kufuneka ukulawula ukhuseleko, ikakhulukazi uma ufike idatha eyahlukile. Task.detached Task.detached { await performBackgroundWork() } Ukusebenzisa Uma ungenza imisebenzi emkhakheni ngaphandle kwe-context esebenzayo yamanje, njenge-computations eside-running noma ukunikela ukujongana kwama-actor. Task.detached Thread Pool Ukuhambisana I-Cooperative Thread Pool ku-Swift Concurrency iyinhlangano elawula ukusebenza kwezinqubo asynchronous ngokuphathelene inani elincane le-threads, ngokuvamile ekubeni inani le-CPU core. I-Cooperative Thread Pool ku-Swift Concurrency iyinhlangano elawula ukusebenza kwezinqubo asynchronous ngokuphathelene inani elincane le-threads, ngokuvamile ekubeni inani le-CPU core. I-Swift Concurrency isebenza ngokusebenzisa i-cooperative thread pool eyenziwe ukulungiswa okusheshayo kanye nokuhlanganiswa kwe-thread engaphansi. Ngokungafani ne-traditional thread-per-task executing model, indlela ye-Swift ibonise ukulungiswa okuzenzakalelayo nokuhlanganiswa okuzenzakalelayo. A common oversimplification is to say that Swift Concurrency uses one thread per core, which aligns with its goal to reduce context switching and maximize CPU utilization. While not strictly false, this view omits important nuances about quality-of-service buckets, task priorities, and Darwin scheduler behavior. Thread Count: Hhayi Kulula Thread Count: Hhayi Kulula On a 16-core Mac, it’s possible to observe up to 64-threads managed by Swift Concurrency alone - without GCD involvement. This is because Swift’s cooperative thread pool maps not just per-core, but per core per QoS bucket. Ukuhlobisa: Max threads = (CPU cores) × (dedicated quality-of-service buckets) Ngokwesibonelo, ku-16 core uhlelo: 16 cores × 4 QoS buckets = 64 threads Konke i-QoS bucket iyinhlangano ye-thread lane ye-thread for a group of tasks that share a similar execution priority. Lezi zokusebenza ngokwe-internally yi-Darwin's thread scheduling mechanism futhi akuyona efanayo ne-GCD queues. I-QoS Buckets ne-Task Priority QoS Buckets and Task Priority Nokho Izinto ezingu-6 zihlanganisa, ezinye ze-aliases: TaskPriority Usuku lokuqala High Ukusebenza Low default → okwenziwe ngempumelelo ku medium For the kernel’s perspective, this simplifies to 4 core priority levels, each mapped to a QoS bucket, which influences thread allocation in the cooperative thread pool. Ngaba i-Overcommit ithathwa? Ngaba i-Overcommit ithathwa? Phakathi nesisindo se-normally, i-Swift Concurrency ibhalisele ama-cooperative pool limits. Kodwa-ke, ngaphansi kwe-conflict (isib. Izinsizakalo ze-high-priority ezihlangene izinsizakalo ezincinane), inqubo ingangena ama-threads ukuze ukugcina ukuphendula. Lokhu ukucubungula okuzenzakalelayo kunconywa ukuthi izinsizakalo ze-time-sensitive asikaze ezihlangene ngempumelelo emzimbeni ye-low-priority. Lezi zokusebenza zokusebenza yi-Darwin kernel ngokusebenzisa i-Mach planning policies kanye ne-high-priority izindandatho - akuyona into elawulwa ngokuvamile yi-code yakho. pthreads Ukubuyekezwa I-Swift inikeza uhlelo lokuphelelwa kwezinqubo, efana ne-Grand Central Dispatch (GCD), kodwa i-semantically integrated ku-structured concurrency model. Ungafakwa ukhetho lokuphelelwa kwezinqubo ngokusebenzisa i-GCD. Waze: Task Task(priority: .userInitiated) { await loadUserData() } Izinzuzo ezisebenzayo zihlanganiswa nge- Ngena ngemvume: TaskPriority Priority Description / .high .userInitiated For tasks initiated by user interaction that require immediate feedback. .medium For tasks that the user is not actively waiting for. / .low .utility For long-running tasks that don’t require immediate results, such as copying files or importing data. .background For background tasks that the user is not directly aware of. Primarily used for work the user cannot see. / ukunakekelwa .high .userInitiated Ukuze izivakashi ezidlulile ukusebenzisana kwamakhasimende ezidingekayo ukubuyekeza ngokushesha. .medium Ukuze izivakashi okuyinto abasebenzisi akuyona ngokushesha. / ukunakekelwa .low .utility For long-running tasks that don’t require immediate results, such as copying files or importing data. .background Izixhobo ze-background ezaziwa ngqo kumakhasimende. Isetshenziswa ikakhulukazi ekusebenzeni kumakhasimende ayikwazi ukubona. Ukwakha umsebenzi nge izici ezahlukene Ukwakha umsebenzi nge izici ezahlukene Uma utshintshe a ngaphakathi umsebenzi olandelayo (default Priority), ungakwazi ukucubungula ngokuvamile isikhokelo esahlukile ngamunye isicelo esihlalweni. Lapha, isikhokelo se-child is , futhi omunye .high. Lokhu kubonisa ukuthi ama-priorities angakwazi ukucindezeleka ngokulinganayo ngaphandle kwe-parent. Task .medium .low Task { // .medium by default Task(priority: .low) { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .high) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } // 1, thread: {number = 1, name = main}, priority: TaskPriority.low // 2, thread: {number = 1, name = main}, priority: TaskPriority.high Uma ungasetshenziswa ngokuvumelana ne-priority ye-task embhedeni, i-priority iyahambisana ne-parent emkhakheni. Kulesi isibonelo, izinsizakalo ze-anonymous zihlanganisa emkhakheni. Waze ama-blocks zihlala ama-priorities ezithile ngaphandle kokubili. .high .low Izinzuzo zokusebenza zingatholakala Izinzuzo zokusebenza zingatholakala Task { Task(priority: .high) { Task { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") Task { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } } // 2, thread: {number = 1, name = main}, priority: TaskPriority.low // 1, thread: {number = 1, name = main}, priority: TaskPriority.high // 3, thread: {number = 1, name = main}, priority: TaskPriority.low // 4, thread: {number = 1, name = main}, priority: TaskPriority.medium Uma ungasetshenziswa ngokuvumelana ne-priority ye-task ingxubevange, i-priority iyahambisana ne-mother's immediate. Kulesi isibonelo, izinsizakalo ze-anonymous ngaphakathi kwe-blocks .high kanye ne-low zihlukanise izinsizakalo ezifanayo, ngaphandle kokubili. Ukuphakama kwe-Task Priority Ukuphakama kwe-Task Priority Task(priority: .high) { Task { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } await Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") await Task { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") }.value Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } }.value } // 1, thread: {number = 1, name = main}, priority: TaskPriority.high // 2, thread: {number = 1, name = main}, priority: TaskPriority.high // 3, thread: {number = 1, name = main}, priority: TaskPriority.high // 4, thread: {number = 1, name = main}, priority: TaskPriority.medium This mechanism is called priority escalation — when a task is awaited by a higher-priority task, the system may temporarily raise its priority to avoid bottlenecks and ensure responsiveness. As a result: I-Task 2, okuyinto i-.low, i-escalated kuya ku-.high lapho i-attend. I-Task 3, okuyinto ayikho ikheli le-priority, ivela ikheli le-escalated kusuka ku-mother (Task 2) futhi isebenza nge-.highpriority. I-Task 4 ibeka ngempumelelo i-priority yayo ku-.medium, ngakho-ke akufanele ngokushesha. Ukukhipha Priority Task.detached Ukusebenza Imininingwane ( ) zokusebenza ngokuzimela futhi akuyona inkulumo lokuphendula umsebenzi yayo yokuzimela. Amasebenza njenge izinsizakalo zehlabathi nge-charting yayo. Lokhu kunezinto ezisebenzayo yokuzimela umsebenzi sokuphendula, kodwa kungase kuholele ekugqibeleni okungenani lokuphendula uma akufakiwe ngempumelelo. Task.detached Task(priority: .high) { Task.detached { print("\(1), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .low) { print("\(2), "thread: \(Thread.current)", priority: \(Task.currentPriority)") Task.detached { print("\(3), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } Task(priority: .medium) { print("\(4), "thread: \(Thread.current)", priority: \(Task.currentPriority)") } } } // 1, thread: {number = 4, name = (null)}, priority: TaskPriority.medium // 2, thread: {number = 1, name = main}, priority: TaskPriority.low // 3, thread: {number = 4, name = (null)}, priority: TaskPriority.medium // 4, thread: {number = 1, name = main}, priority: TaskPriority.medium Suspension Points and How Swift Manages Async Execution Ku-Swift, wonke umyalezo ku-a Ukusebenzisa is a potential suspension point – a place in the function where executing might pause and resume latter. It is a transformation that involves saving the state of the function so it can be resumed latter, after the expected operation completes. async await Here’s an example: func fetchData() async -> String { let result = await networkClient.load() return result } Ngemuva kwalokho, is a suspension point. Uma ifunyenwe lokhu umugqa, kungase ngempumelelo ukusebenza, ukunikeza ukulawula ku-system, futhi ngemva kokufaka Phakathi nenkinga, i-compiler yenza le umsebenzi ku-state machine elawula ukucubungula ukucubungula kanye nemingcele zangaphakathi. await networkClient.load() load() Nge-Under the Hood: Ukuhambisa kanye ne-State Machines Wonke I-function ku-Swift iyahlukaniswa ku-state machine. Noma Ukubonisa isikhokelo se-transition point. Ngaphambi kokufika Ukubuyekezwa: async await await Ukubhalisa isimo lokugqibela le-function - kuhlanganise izinga lokugqibela kanye ne-instruction pointer. I-Suspends execution futhi i-schedule a continuation. Once the async operation completes, it resumes the function from where it left off. Kuyinto efana ne-continuation-passing style (CPS) esetshenziselwa izinhlelo zokusebenza eziningi zokusebenza zokusebenza. Kwi-Swift's concurrency model, lokhu kusungulwa nge-internal types like futhi umzila runtime competition. ParticialAsyncTask Ukuhlobisa! = Ukuhlobisa Ngase something in Swift, the current thread is not blocked, instead: await Ukusebenza okuzenzakalelayo ivumela ukulawula ekhukhwini Other tasks can run while waiting Uma isebenze isebenze esifundeni esifundeni, isebenze esifundeni esifundeni esifundeni esifundeni esifundeni esifundeni. Yenza fundamentally more efficient and scalable than thread-based blocking operations like . async/await DispatchQueue.sync : letting other tasks run Imininingwane ( Imininingwane ( I-Swift is a static method provided by the concurrency system that voluntarily suspends the current task, enikeza inqubo yokuhlanza ezinye umsebenzi enqueued. Kuyinto ikakhulukazi ezisebenzayo ekupheleni-long-running operations asynchronous or tight loops that do not naturally contain suspension points. Task.yield() func processLargeBatch() async { for i in 0..<1_000_000 { if i % 10_000 == 0 { await Task.yield() } } } Ngaphandle , le loop ngeke monopolise umsebenzisi. Ngokufaka periodically, you’re cooperating with Swift’s concurrency runtime, allowing to maintain responsivness and fairness. await await Task.yield() Phakathi Hood Ukubuyekeza isixazululo se-akhawunti se-akhawunti se-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti ye-akhawunti. Task.yield() It’s part of Swift’s cooperative multitasking model: tasks run to the next suspension point and are expected to yield fairly. Unlike preemptive systems (e.g., threads), Swift tasks don’t get forcibly interrupted — they must voluntarily yield control. Ukuhlobisa I-Swift 6 inikeza isinyathelo esikhulu ekusebenziseni indlela yokusebenza kwe-concurrency, enikeza abathengi ukulawula, ukucaciswa kanye nokhuseleko. Nakuba isinyathelo sokucwaninga kunokufunda kunokwenzeka ekuqaleni, ukucaciswa kwezi zinhlelo zibonisa ukwakha izicelo eziningana nezimpendulo. Njengoba siqhubeke ukuhlola izakhiwo ezincinane ze-concurrency entsha ye-Swift, kubalulekile ukuthi lezi zokusebenza zihlanganisa isisekelo sokuthuthukiswa kwe-app enhle futhi enhle.