Ushindani wa haraka - Sehemu ya 1: Kazi, Watendaji, na Kuongezeka kwa Priority

Swift 6 ilizindua mbinu mpya ya mchanganyiko katika programu. Katika makala hii, tutafuta matatizo ambayo ina lengo la kutatua, kuelezea jinsi inafanya kazi chini ya kapu, kulinganisha mfano mpya na wa awali, na kuchunguza kwa karibu mfano wa Actor. Katika sehemu inayofuata, tutakuwa pia kuharibu utekelezaji, mipangilio, mchanganyiko wa muundo, aina tofauti za utekelezaji, kutekeleza utekelezaji wetu mwenyewe, na zaidi. Utafiti wa ushindani wa Swift: matatizo na ufumbuzi Kuchapisha msimbo unaofanya kazi kwa wakati mmoja inaweza kuboresha utendaji na kujibu, lakini mara nyingi hutoa ugumu na makosa mabaya kama hali ya mashindano, deadlocks, na masuala ya usalama wa thread. Swift Concurrency, iliyotolewa katika Swift 6, ina lengo la kufafanua programu ya pamoja kwa kutoa mfano wazi, salama, na ufanisi wa kukabiliana na kazi za asynchronous. 💡 Ikiwa unatumia Swift 5.x na unatarajia kuhamia kwenye Swift 6, unaweza kuwezesha udhibiti wa Concurrency wa Swift katika mipangilio yako ya mradi. Hii inakuwezesha kupitisha hatua kwa hatua mfano mpya wa concurrency wakati unaendelea kuunganisha na msimbo uliopo. Kuwezesha udhibiti huu husaidia kukamata matatizo ya uwezekano wa concurrency mapema, na kufanya mabadiliko kwa urahisi zaidi na salama. Kama unakaribisha codebase yako, unaweza kuanza kuunganisha async/await syntax na vipengele vingine vya Concurrency wa Swift kwa hatua bila kuandika upya kamili. 💡Ikiwa unatumia Swift 5.x na unatarajia kuhamia kwenye Swift 6, unaweza kuwezesha udhibiti wa Swift katika mipangilio yako ya mradi. Hii inaruhusu kukuza mtindo mpya wa udhibiti wakati wa kudumisha ufanisi na msimbo unaoendelea. Kuwezesha udhibiti huu husaidia kukamata matatizo ya uwezekano wa udhibiti mapema, na kufanya mabadiliko kwa urahisi zaidi na salama. async/await Syntax na vipengele vingine vya Concurrency ya Swift huongezeka kwa kasi bila kuandika upya kamili. Some of the key problems Swift Concurrency addresses include: Race Conditions: Preventing simultaneous access to shared mutable state that can cause unpredictable behaviour. Callback hell: Ufafanuzi wa asynchronous code ambayo ilitumiwa kutegemea sana juu ya wito wito wito wito au kukamilisha handlers, kufanya code rahisi kusoma na kudumisha. Utaratibu wa usimamizi wa thread: Kuondoa uumbaji wa kiwango cha chini na synchronization, kuruhusu watengenezaji kuzingatia mantiki badala ya usimamizi wa thread. Kusimamia kazi za pamoja: Kusimamiwa kwa pamoja huwezesha uwiano wa kazi wazi na kufutwa kwa usahihi na kuenea kwa makosa. Kwa kutumia lugha mpya kama Swift 6 inatoa njia ya kuvutia zaidi na yenye nguvu ya kuandika msimbo wa pamoja, kuboresha uzalishaji wa watengenezaji na utulivu wa programu. async/await Kazi ya Multitasking Mfumo wa uendeshaji wa kisasa na muda wa uendeshaji hutumia multitasking kutekeleza sehemu za kazi kwa wakati mmoja. Swift Concurrency inachukua multitasking ya ushirikiano, ambayo inatofautiana kimsingi na mfano wa multitasking wa kuzuia unaotumika na viungo vya kiwango cha OS. Kuelewa tofauti ni muhimu kwa kuandika msimbo wa Swift wa ufanisi na salama. Preemptive Multitasking Preemptive multitasking ni mfano unaotumika na mifumo ya uendeshaji kusimamia thread na mchakato. Katika mfano huu, msimamizi wa kiwango cha mfumo anaweza kuvunja kwa nguvu thread yoyote karibu wakati wowote ili kufanya switche ya mazingira na kutenga muda wa CPU kwa thread mwingine. Hii inahakikisha usawa katika mfumo na inaruhusu maombi yanayohusika - hasa wakati wa kukabiliana na kazi nyingi zinazohusika na mtumiaji au za muda. Multitasking ya kuzuia inawezesha parallelism halisi kati ya vichwa vingi vya CPU na inawezesha viungo vya uongo au vya muda mrefu kutoka kwa monopolizing rasilimali za mfumo. Hata hivyo, ufanisi huu unakuja kwa gharama. Kwa sababu vichwa vinaweza kuharibiwa wakati wowote katika utekelezaji wao - hata katikati ya operesheni muhimu - watengenezaji wanapaswa kutumia primitives za synchronization kama mutexes, semaphores, au operesheni za atomiki kulinda hali ya kipekee iliyoshiriki. Mfano huu hutoa udhibiti mkubwa na mchanganyiko mkubwa, lakini pia huweka mzigo mkubwa zaidi kwa watengenezaji. Uhakikisho wa usalama wa thread katika mazingira ya kuzuia ni makosa ya uwezekano na inaweza kusababisha tabia isiyo ya uhakika - tabia ambayo inatofautiana kutoka kwa kuendesha kwa kuendesha - ambayo ni vigumu sana kuzingatia au kujaribu kwa uhakika. Kutokana na mtazamo wa kiufundi, multitasking ya kuzuia inategemea mfumo wa uendeshaji kukabiliana na utekelezaji wa thread. OS inaweza kuacha thread karibu wakati wowote - hata katikati ya kazi - na kubadilisha kwa nyingine. Ili kufanya hivyo, mfumo lazima uendesha switche ya mazingira, ambayo inahusisha kuokoa hali yote ya utekelezaji ya thread ya sasa (kama vile registers CPU, mwongozo wa maelekezo, na stack pointer), na kurejesha hali iliyohifadhiwa hapo awali ya thread nyingine. Utaratibu huu unazindua muda mkubwa wa uendeshaji. Kila switche ya mazingira inachukua muda na inachukua rasilimali za mfumo - hasa wakati switches ya mazingira ni ya mara kwa mara au wakati vichwa vingi vinashindana kwa vichwa vya CPU vya mdogo. Zaidi ya hayo, multitasking ya kuzuia huwafanya watengenezaji kuandika msimbo salama kwa vichwa kwa default, kuongeza utata wa jumla na hatari ya makosa ya pamoja. Wakati mfano huu hutoa ufanisi mkubwa na parallelism halisi, mara nyingi ni ya kutosha kwa harakati za kazi za asynchronous, ambapo kazi kawaida hutumia muda wao wengi wa kusubiri kwa I / O, input ya mtumiaji, au majibu ya mtandao badala ya kutumia CPU. Ushirikiano wa Multitasking Katika mfano huu, kazi inaendesha mpaka inatoa udhibiti kwa kujitolea - kwa kawaida wakati wa kusubiri au kupitia wito wa wazi kwa Tofauti na misingi ya jadi, kazi za ushirikiano hazijapunguzwa kwa nguvu. Hii inamaanisha utekelezaji unaoweza kutabiriwa: mabadiliko ya mazingira yanatokea tu kwenye pointi zilizoelezwa kwa uwazi. Task.yield() Kazi ya ushirikiano wa Swift inatarajiwa kuwa na uwezo wa kuendesha kazi kwa urahisi, wakati wa uendeshaji - tofauti na mikono ya Grand Central Dispatch. Kazi zinazoendeshwa katika kikundi hiki zinatarajiwa kuwa "Wananchi Wema", na kutoa udhibiti wakati inahitajika, hasa wakati wa kazi ya muda mrefu au CPU-intensive. kama kifungo cha mikono, kuhakikisha kazi nyingine zina nafasi ya kutekeleza. Task.yield() Hata hivyo, multitasking ya ushirikiano inakuja na tahadhari: ikiwa kazi haina kusimamishwa kamwe, inaweza monopolize thread ambayo inafanya kazi, kuharibu au kuangamia kazi zingine katika mfumo. In cooperative multitasking, the fundamental unit of execution is not a thread, but a chunk of work, often called a continuation. A continuation is a suspended segment of an asynchronous function. When an Kazi ya kusimamishwa katika , Swift runtime inachukua hali ya utekelezaji wa sasa katika uendelezaji unaotolewa kwa jumla. Uendelezaji huu unawakilisha pointi ya kurejesha na umewekwa kwa utekelezaji ujao. async await Badala ya kuhusisha thread na kazi ya muda mrefu, runtime ya Swift inachukua thread kama mstari wa kuendelea. Kila thread hufanya kuendelea moja baada ya nyingine. Kama ilivyoelezwa hapo juu, mfano huu unakimbia switches ya kawaida ya mazingira ya kiwango cha OS. Hakuna haja ya kuokoa na kurejesha registers ya CPU au vichaka; muda wa uendeshaji tu unaleta kuendelea ya mwisho. Hii inafanya mabadiliko ya kazi ya haraka sana na ya mwanga, ingawa inahusisha kuongezeka kwa usambazaji wa jumba ili kuhifadhi hali ya async iliyopangwa. Mchanganyiko muhimu: unatumia kumbukumbu kidogo zaidi lakini unapata juu ya chini sana kwa ajili ya usimamizi wa kazi. mipangilio ya ushirikiano inatoa udhibiti mkali juu ya wakati suspensions hutokea, ambayo inaboresha utabiri na inafanya mchanganyiko rahisi kufikiri kuhusu. Kuingia kwa Kazi ya Kazi ya Kwa upande wa ushindani, a kutafuta mbinu mbadala za kupunguza namba ya samaki aina ya sangara na kupandikiza Kazi ya A ni kitu cha kusimamiwa ambacho kinakwenda kwa wakati huo huo na kazi zingine katika kikundi cha thread ya ushirikiano. Task async Task 💡 Tasks are managed by a cooperative thread pool. The cooperative thread pool is designed to manage concurrency efficiently by allowing tasks to yield the CPU while waiting for asynchronous operations to complete. This is achieved through the use of async functions and tasks, which are the fundamental units of concurrency in Swift. 💡 Majukumu yanaendeshwa na pool ya thread ya ushirikiano. Pool ya thread ya ushirikiano ni iliyoundwa kusimamia concurrency kwa ufanisi kwa kuruhusu majukumu ya kuleta CPU wakati wa kusubiri kwa operesheni za asynchronous kukamilika. Hii inapatikana kwa kutumia kazi za async na majukumu, ambayo ni viungo vya msingi vya concurrency katika Swift. Kazi zinaweza kuundwa ili kuendesha kwa wakati huo huo, na pia zinaweza kusubiri au kufutwa. Zinatoa udhibiti mzuri juu ya tabia ya asynchronous na ni sehemu ya mchanganyiko wa muundo katika Swift. Kuunda a Task Kazi inaweza kuundwa kwa kutumia , ambayo mara moja huanza operesheni iliyotolewa asynchronous: Task initializer Mwanzo wa Task(priority: .userInitiated) { await fetchData() } Wakati wa kuunda a kwa kutumia initializer ya kawaida (yaani, sio ), inawakilisha mazingira ya watendaji, kipaumbele, na thamani za kazi za ndani. Tabia hii ni muhimu kwa usambazaji wa muundo na usalama katika msimbo wa pamoja. Task Kuondolewa Kuondolewa 💡 Swift 6.2 introduces a significant change to how concurrency is handled: by default, all code runs on MainActor Ili kuendesha msimbo kwenye background, Swift 6.2 inaongeza sifa mpya @concurrent . You can also use nonisolated if the code doesn’t require access to the main actor. WWDC inachukua ushindani wa Swift 💡 Swift 6.2 hutoa mabadiliko makubwa katika jinsi concurrency inashughulikiwa: kwa default, msimbo wote unaendesha kwenye MainActor Ili kuendesha msimbo kwenye background, Swift 6.2 inaongeza sifa mpya @concurrent . You can also use nonisolated ikiwa msimbo hauhitaji upatikanaji wa mchezaji mkuu. WWDC Embracing Swift WWDC inachukua ushindani wa Swift WWDC inachukua ushindani wa Swift Chini ya kapu, katika matoleo ya awali ya Swift Concurrency, runtime ya Swift ilitumia mfumo wa ndani unaoitwa 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 Pamoja na maendeleo katika Swift, runtime imeanza kubadilika kutoka kwa mfumo mpya unaojulikana kama , ambayo sasa inashughulikiwa kwa uwazi zaidi na compiler na runtime. @_inheritActorContext sending 💡 Nini ni kutuma? kutuma ni neno jipya lililotolewa katika Swift 6 kama sehemu ya harakati ya lugha kuelekea salama zaidi na wazi concurrency. Ni kutumika kwa alama ya vigezo kazi na kurudi thamani ambayo ni kuhamishwa juu ya mipaka ya concurrency. Ni kazi hasa vizuri noncopyable aina, kuhakikisha usalama wa kumbukumbu na kuzuia baada ya matumizi-kuhamisha makosa. Wakati parameter ni alama na kutuma, compiler inahakikisha kwamba instance ya awali haipatikani tena baada ya uhamisho. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } Nini ni sending ? sending ni neno jipya lililotolewa katika Swift 6 kama sehemu ya harakati ya lugha kuelekea salama zaidi na ya wazi. Inatumika kuonyesha vigezo vya kazi na kurudi thamani ambazo zinageuka katika mipaka ya usawa. Inafanya kazi vizuri hasa aina zisizojulikana, kuhakikisha usalama wa kumbukumbu na kuzuia makosa ya kuhamia baada ya matumizi. sending , compiler inahakikisha kwamba instance ya awali haipatikani tena baada ya uhamisho. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } Baada ya kuanza kwa a , lazima uhakikishe kwamba maadili yoyote yaliyowekwa na kazi ni Kompyuta sasa inafuatilia hili wakati wa kuchanganya kutumia Mkataba na aina ya kazi. Task.detached Sendable Sendable @Sendable Kutokuwa na uwezo wa kulingana na may result in a compile-time error, particularly in strict concurrency mode. Sendable Tasks also support priorities, similar to how Grand Central Dispatch queues handle them. vs ya Task Task.detached Wakati wa kufanya kazi na Swift Concurrency, ni muhimu kuelewa tofauti kati ya na ya , kama wanafafanua jinsi na wapi kazi ya asynchronous inafanywa. Task Task.detached Task Kazi ya kuwakilisha mazingira ya sasa ya wachezaji (kama vile au mchezaji wowote wa kibinafsi) na kipaumbele. Ni kawaida kutumika wakati unataka kuzalisha operesheni mpya ya asynchronous ambayo bado inaheshimu mti wa mchanganyiko wa sasa au utoaji wa mchezaji. Hii ni muhimu hasa kwa updates ya UI au kufanya kazi ndani ya uwanja maalum wa mchanganyiko. Task MainActor Task { await updateUI() } Katika mfano wa hapo juu, ikiwa wito kutoka kwa mchezaji mkuu, itakuwa pia kuendesha juu ya mchezaji kuu isipokuwa wazi kuhamishwa mahali pengine. Task Task.detached Task.detached creates a completely independent task. It doesn’t inherit the current actor context or priority. This means it starts in a global concurrent context and requires manage safety, especially when accessing shared data. Task.detached Task.detached { await performBackgroundWork() } matumizi ya wakati unahitaji kuendesha operesheni za nyuma nje ya mazingira ya sasa ya muundo, kama vile utekelezaji wa hesabu za muda mrefu au kuepuka kujitenga na mchezaji. Task.detached Ushirikiano wa Thread Pool Cooperative Thread Pool katika Swift Concurrency ni mekanism ambayo inashughulikia utekelezaji wa kazi za asynchronous kwa kuweka mipangilio yao juu ya idadi ndogo ya thread, kwa kawaida kulingana na idadi ya core za CPU. Cooperative Thread Pool katika Swift Concurrency ni mekanism ambayo inashughulikia utekelezaji wa kazi za asynchronous kwa kuweka mipangilio yao juu ya idadi ndogo ya thread, kwa kawaida kulingana na idadi ya core za CPU. Swift Concurrency inafanya kazi kwa kutumia pool ya ushirikiano wa thread iliyoundwa kwa mipango yenye ufanisi na kiwango cha chini cha juu cha thread. Tofauti na mfano wa jadi wa utekelezaji wa thread-per-task, mbinu ya Swift inasisitiza mchakato wa muundo na ufahamu wa rasilimali. Ufafanuzi mkubwa wa kawaida ni kusema kwamba Swift Concurrency inatumia thread moja kwa msingi, ambayo inafanana na lengo lake la kupunguza mabadiliko ya mazingira na kuongeza matumizi ya CPU. Ingawa sio uongo kabisa, mtazamo huu unachangia nuances muhimu kuhusu ubora wa huduma, vigezo vya kazi, na tabia ya programu ya Darwin. Mstari wa chini: sio rahisi Mstari wa chini: sio rahisi Kwenye Mac ya 16 core, inawezekana kufuatilia hadi viungo vya 64 vinavyoendeshwa na Swift Concurrency peke yake - bila ushiriki wa GCD. Hii ni kwa sababu pool ya ushirikiano wa Swift sio tu kwa kernel, lakini kwa kernel kwa bucket ya QoS. Kwa kifupi: Max threads = (CPU cores) × (dedicated quality-of-service buckets) Kwa hiyo, kwa mfumo wa 16 core: 16 cores × 4 QoS buckets = 64 threads Kila QoS bucket ni kimsingi thread lane maalum kwa kundi la kazi zinazoshirikiana na awali ya utekelezaji sawa. Hizi ni kusimamiwa ndani na mchakato wa Darwin thread mipangilio na si sawa na GCD umbali. QoS Buckets na Priority ya Kazi QoS Buckets na Priority ya Kazi Ingawa Miongoni mwa majaribio hayo ni majaribio sita. TaskPriority Kuanzishwa kwa kiwango cha juu Ufanisi wa chini imechapishwa kwa kiwango cha kati Kwa mtazamo wa kernel, hii inapunguza kwa viwango vya juu vya 4 vya msingi, kila moja iliyoundwa kwa bucket ya QoS, ambayo huathiri usambazaji wa thread katika pool ya thread ya ushirikiano. Ni wakati gani wa overcommit hutokea? Ni wakati gani wa overcommit hutokea? Chini ya mzigo wa kawaida, Swift Concurrency inaheshimu mipaka ya jumba la ushirikiano. Hata hivyo, chini ya migogoro (kwa mfano, kazi za kiwango cha juu zinatarajia kazi za kiwango cha chini), mfumo inaweza kuharibu vichwa ili kuhifadhi ujasiri. Tabia hii inasimamiwa na kernel ya Darwin kupitia sera za mipangilio ya Mach na kipaumbele cha juu bandia - sio kitu ambacho kimsingi kinazingatiwa na msimbo wako. pthreads Kazi ya Priority Swift provides a priority system for tasks, similar to Grand Central Dispatch (GCD), but more semantically integrated into the structured concurrency model. You can set a task’s priority via the Maelezo ya awali: Task Task(priority: .userInitiated) { await loadUserData() } Hatua zinazopatikana zinaelezwa na kwa ajili ya: 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. / ya .high .userInitiated For tasks initiated by user interaction that require immediate feedback. .medium Kwa kazi ambazo mtumiaji hawana kusubiri kwa ufanisi. / ya .low .utility Kwa kazi za muda mrefu ambazo hazihitaji matokeo ya haraka, kama vile nakala ya faili au kuagiza data. .background Kwa kazi za nyuma ambazo mtumiaji hawana ufahamu wa moja kwa moja.Kutumiwa kwa kazi ya kwanza mtumiaji hawezi kuona. Kujenga majukumu na vipaumbele tofauti Kujenga majukumu na vipaumbele tofauti Wakati wa kuunda a inside another task (default Unaweza kuunda kazi na uendelee haraka na matumizi ya masanduku. at , and the other is .high. This demonstrates that priorities can be individually set regardless of the 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 Ikiwa huwezi kuweka kipaumbele kwa ufafanuzi wa kazi iliyohifadhiwa, huipata kipaumbele kutoka kwa mzazi wake wa haraka. and Blocks urithi wa vigezo vyao husika isipokuwa kupunguzwa. .high .low Priorities ya kazi zinaweza kupewa urithi Priorities ya kazi zinaweza kupewa urithi 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 Ikiwa huwezi kuweka kipaumbele kwa ufafanuzi wa kazi iliyohifadhiwa, inawakilisha kipaumbele ya mzazi wake wa haraka. Katika mfano huu, kazi zisizojulikana ndani ya vikundi vya .high na .low hupata kipaumbele vyake husika, isipokuwa kupunguzwa. Kuanzisha mkataba wa awamu ya kwanza Kuanzisha mkataba wa awamu ya kwanza 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 Utaratibu huu unajulikana kama kiwango cha awali - wakati kazi inatarajiwa na kazi ya awali ya juu, mfumo unaweza mara kwa mara kuongeza awali yake ili kuepuka vikwazo na kuhakikisha kujibu. Kama matokeo ya: Kazi 2, ambayo ni .low, inaongezeka hadi .high wakati wa kusubiri. Kazi 3, ambayo haina kipaumbele cha wazi, ina urithi wa kipaumbele cha kuongezeka kutoka kwa mzaliwa wake (Kazi 2) na pia huendeshwa na .highpriority. Task 4 explicitly sets its priority to , so it is not affected by escalation. .medium Haipaswi kupewa kipaumbele Task.detached Task.detached Utekelezaji wa majukumu ( ) kuendesha kwa kujitegemea na hawana urithi wa kipaumbele cha kazi yao ya wazazi. Wanahusika kama kazi za kimataifa na mipangilio yao wenyewe. Hii ni muhimu kwa kujitenga kazi ya nyuma, lakini pia inaweza kusababisha tofauti zisizotarajiwa za kipaumbele ikiwa haijatengenezwa kwa mikono. 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 Points ya Suspension na Jinsi Swift inashughulikia utekelezaji wa Async Katika Swift, wito wowote kwa Kazi ya kutumia ni nafasi katika kazi ambapo utekelezaji unaweza kusimama na kuendelea baadaye. Ni mabadiliko ambayo inahusisha kuokoa hali ya kazi ili inaweza kuendelea baadaye, baada ya operesheni iliyotarajiwa kukamilika. async await Here’s an example: func fetchData() async -> String { let result = await networkClient.load() return result } Katika kesi hii, Wakati kazi inafikia mstari huu, inaweza kuacha utekelezaji, kutoa udhibiti kwa mfumo, na baadaye kuendelea mara moja. Nyuma ya matukio, compiler inabadilisha kazi hii katika mashine ya hali ambayo inafuata maendeleo yake na variables ya ndani. await networkClient.load() load() chini ya Hood: Maelezo na mashine ya serikali kila mmoja function in Swift is compiled into a state machine. Each Kuanza kucheza katika TopSlotSite , kufuata 3 hatua rahisi kujiandikisha. Kwa ajili ya SWIFT: async await await Kuokoa hali ya sasa ya kazi - ikiwa ni pamoja na variables za ndani na mwongozo wa sasa. Kuacha utekelezaji na mipango ya kuendelea. Mara baada ya operesheni ya async kukamilika, inakaribisha kazi kutoka mahali pale ilipoacha. Hii ni sawa na mtindo wa kuendelea (CPS) unaotumika katika mifumo mingi ya programu ya kazi. Katika mfano wa mchanganyiko wa Swift, hii inajumuishwa na aina za ndani kama vile na mchakato wa uendeshaji wa mashindano. ParticialAsyncTask Upungufu wa upungufu! = Upungufu Wakati wewe kitu katika Swift, thread ya sasa haifungwa, badala yake: await The current task yields control back to the executor Kazi nyingine inaweza kuendesha wakati wa kusubiri Wakati operesheni iliyotarajiwa imekamilika, kazi iliyopangwa inaendelea kwenye mwendeshaji sahihi. Hii inafanya fundamentally more efficient and scalable than thread-based blocking operations like . async/await DispatchQueue.sync : letting other tasks run Task.yield() Task.yield() ni mbinu ya static iliyotolewa na mfumo wa mchanganyiko wa Swift ambayo kwa hiari huacha kazi ya sasa, ikitoa mfumo fursa ya kuendesha kazi nyingine zilizounganishwa. Task.yield() func processLargeBatch() async { for i in 0..<1_000_000 { if i % 10_000 == 0 { await Task.yield() } } } bila ya Hivyo basi, utaratibu huu unapaswa kufanywa na mtumiaji.Kwa kuongeza mara kwa mara, wewe ni kushirikiana na Swift concurrency runtime, kuruhusu kudumisha responsiveness na haki. await await Task.yield() Chini ya Hood Calling await kuacha kazi ya sasa na kutafuta tena mwishoni mwa mstari kwa mwendeshaji wake wa sasa (kwa mfano, mchezaji mkuu au mwendeshaji wa pamoja wa kimataifa). Task.yield() Ni sehemu ya mfano wa ushirikiano wa multitasking wa Swift: kazi zinakimbia hadi hatua inayofuata na inatarajiwa kuwa na utoaji wa haki. Tofauti na mifumo ya kuzuia (kwa mfano, thread), kazi za Swift hazipaswi kuharibiwa kwa nguvu - wanapaswa kujitoa udhibiti kwa hiari. Muhtasari wa Swift 6 inawakilisha hatua kubwa mbele katika jinsi concurrency inavyoshughulikiwa, kutoa watengenezaji udhibiti zaidi, utabiri, na usalama. Ingawa mwongozo wa kujifunza inaweza kuwa mkali mwanzoni, kuelewa dhana hizi inafungua mlango wa kujenga maombi yenye kujibu sana na yenye nguvu. Kama sisi kuendelea kuchunguza vipengele zaidi ya mfumo mpya wa concurrency wa Swift, ni dhahiri kwamba mabadiliko haya yameweka msingi kwa ajili ya siku zijazo ya maendeleo ya programu salama na kupanua.