Swift Competition - Bagian 1: Tugas, Eksekutif, dan Eskalasi Prioritas

Swift 6 memperkenalkan pendekatan baru untuk concurrency dalam aplikasi. dalam artikel ini, kita akan mengeksplorasi masalah yang dimaksudkan untuk memecahkan, menjelaskan bagaimana itu bekerja di bawah kapsul, membandingkan model baru dengan yang sebelumnya, dan melihat lebih dekat pada model Actor. dalam bagian yang akan datang, kita juga akan membagi eksekutor, jadwal, concurrency terstruktur, jenis eksekutor yang berbeda, menerapkan eksekutor kita sendiri, dan banyak lagi. Pendekatan Persaingan Swift: Masalah dan Solusi Menulis kode yang menjalankan tugas secara bersamaan dapat meningkatkan kinerja dan responsif, tetapi sering memperkenalkan kompleksitas dan bug halus seperti kondisi balap, deadlock, dan masalah keamanan thread. Swift Concurrency, yang diperkenalkan di Swift 6, bertujuan untuk menyederhanakan pemrograman simultan dengan menyediakan model yang jelas, aman, dan efisien untuk menangani tugas asinkron. 💡Jika Anda menggunakan Swift 5.x dan berencana untuk bermigrasi ke Swift 6, Anda dapat mengaktifkan pemeriksaan Swift Concurrency dalam pengaturan proyek Anda. Ini memungkinkan Anda untuk secara bertahap mengadopsi model concurrency baru sambil mempertahankan kompatibilitas dengan kode yang ada. mengaktifkan pemeriksaan ini membantu menangkap masalah concurrency potensial lebih awal, membuat transisi lebih lancar dan lebih aman. Ketika Anda memperbarui basis kode Anda, Anda dapat mulai mengintegrasikan sintaks async/await dan fitur Swift Concurrency lainnya secara bertahap tanpa rewrite penuh. 💡Jika Anda menggunakan Swift 5.x dan berencana untuk bermigrasi ke Swift 6, Anda dapat mengaktifkan Swift Concurrency checks dalam pengaturan proyek Anda. Ini memungkinkan Anda untuk secara bertahap mengadopsi model concurrency baru sambil mempertahankan kompatibilitas dengan kode yang ada. mengaktifkan checks ini membantu menangkap masalah concurrency potensial lebih awal, membuat transisi lebih lancar dan lebih aman. async/await syntax dan fitur Swift lainnya secara bertahap tanpa rewrite lengkap. Some of the key problems Swift Concurrency addresses include: Kondisi Ras: Mencegah akses simultan ke keadaan mutasi bersama yang dapat menyebabkan perilaku yang tidak dapat diprediksi. Callback hell: Menyederhanakan kode asynchronous yang sebelumnya sangat bergantung pada panggilan balik atau pengendali penyelesaian, membuat kode lebih mudah dibaca dan dipelihara. Kompleksitas manajemen thread: Mengabaikan penciptaan dan sinkronisasi tingkat rendah, memungkinkan pengembang untuk fokus pada logika daripada pengolahan thread. Koordinasi tugas bersamaan: Konjugasi terstruktur memungkinkan hierarki tugas yang jelas dengan pembatalan dan penyebaran kesalahan yang tepat. Dengan memanfaatkan fitur bahasa baru seperti Swift 6 menyediakan cara yang lebih intuitif dan kuat untuk menulis kode bersamaan, meningkatkan produktivitas pengembang dan stabilitas aplikasi. async/await Multitasking Sistem operasi modern dan runtime menggunakan multitasking untuk melakukan unit kerja secara bersamaan. Swift Concurrency mengadopsi multitasking kolaboratif, yang secara fundamental berbeda dari model multitasking preemptive yang digunakan oleh thread tingkat OS. Multitasking Preventif Preemptive multitasking adalah model yang digunakan oleh sistem operasi untuk mengelola thread dan proses. dalam model ini, perencana tingkat sistem dapat dengan paksa mengganggu setiap thread pada hampir setiap saat untuk melakukan switch konteks dan mendistribusikan waktu CPU ke thread lain. Preemptive multitasking memungkinkan paralelisme sejati di berbagai inti CPU dan mencegah thread yang tidak berperilaku atau berjalan lama dari monopolisasi sumber daya sistem. Namun, fleksibilitas ini datang dengan biaya. Karena thread dapat dihentikan pada setiap titik dalam eksekusi mereka - bahkan di tengah operasi kritis - pengembang harus menggunakan primitif sinkronisasi seperti mutex, semaphore, atau operasi atom untuk melindungi shared mutable state. Model ini menawarkan kontrol yang lebih besar dan konsistensi mentah, tetapi juga menempatkan beban yang jauh lebih besar pada pengembang.Mengamankan keamanan thread dalam lingkungan preemptive rentan terhadap kesalahan dan dapat menyebabkan perilaku non-determinis - perilaku yang bervariasi dari run ke run - yang terkenal sulit untuk membayangkan atau diuji secara dapat diandalkan. Dari sudut pandang teknis, multitasking preemptive bergantung pada sistem operasi untuk menangani eksekusi thread. OS dapat mengganggu thread pada hampir setiap titik – bahkan di tengah-tengah fungsi – dan beralih ke fungsi lain. Untuk melakukan ini, sistem harus melakukan konteks switch, yang melibatkan menyimpan seluruh kondisi eksekusi thread saat ini (seperti registri CPU, penunjuk instruksi, dan penunjuk stack), dan memulihkan status yang sebelumnya disimpan dari thread lain. Proses ini juga mungkin memerlukan pembersihan cache CPU, menonaktifkan Translation Lookaside Buffer (TLB), dan transisi antara mode pengguna dan mode kernel. Operasi ini memperkenalkan waktu runtime yang signifikan. setiap switch konteks membutuhkan waktu dan mengkonsumsi sumber daya sistem – terutama ketika switch konteks sering atau ketika banyak thread bersaing untuk inti CPU terbatas. Sementara model ini memberikan fleksibilitas maksimum dan paralelisme sejati, seringkali berlebihan untuk alur kerja asinkron, di mana tugas biasanya menghabiskan sebagian besar waktu mereka menunggu I/O, input pengguna, atau tanggapan jaringan daripada secara aktif menggunakan CPU. Kerjasama Multitasking Sebaliknya, runtime concurrency Swift menggunakan multitasking kolaboratif. dalam model ini, sebuah tugas berjalan sampai secara sukarela menghasilkan kontrol – biasanya pada titik menunggu atau melalui panggilan eksplisit ke Tidak seperti thread tradisional, tugas-tugas kolaboratif tidak pernah dipaksakan secara paksa. Ini menghasilkan eksekusi yang dapat diprediksi: konteks switch hanya terjadi pada titik suspensi yang ditentukan dengan jelas. Task.yield() Tugas-tugas kolaboratif Swift dijadwalkan ke dalam kolaboratif thread pool yang ringan dan dikelola oleh runtime – terpisah dari barisan Grand Central Dispatch. Tugas-tugas yang dijalankan dalam kolaborasi ini diharapkan menjadi “pemilik yang baik”, memberikan kontrol ketika diperlukan, terutama selama bekerja lama atau kerja CPU-intensif. sebagai titik suspensi manual, memastikan tugas-tugas lain memiliki kesempatan untuk dilakukan. Task.yield() Namun, multitasking kooperatif datang dengan peringatan: jika sebuah tugas tidak pernah ditangguhkan, itu dapat memonopoli thread yang sedang berjalan, menunda atau melemahkan tugas-tugas lain di sistem. 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 Fungsi penghentian pada a , runtime Swift menangkap keadaan eksekusi saat ini menjadi kelanjutan yang ditugaskan oleh heap. kelanjutan ini mewakili titik pemulihan dan diikat untuk eksekusi masa depan. async await Alih-alih mengasosiasikan thread dengan tugas yang berlangsung lama, runtime Swift memperlakukan thread sebagai pipa kontinuasi. Setiap thread melakukan satu kontinuasi setelah yang lain. Seperti disebutkan di atas, model ini menghindari switching konteks tingkat OS tradisional. Tidak ada kebutuhan untuk menyimpan dan memulihkan registri CPU atau tumpukan thread; runtime hanya memanggil kelanjutan seperti penutupan berikutnya. Ini membuat switching tugas sangat cepat dan ringan, meskipun melibatkan alokasi tumpukan yang meningkat untuk menyimpan keadaan async yang ditangguhkan. Kompromi kunci: Anda menggunakan sedikit lebih banyak memori tetapi mendapatkan overhead yang lebih rendah secara dramatis untuk manajemen tugas. perencanaan kolaboratif memberikan kontrol yang ketat ketika suspensi terjadi, yang meningkatkan prediktabilitas dan membuat concurrence lebih mudah untuk berpendapat. Untuk memperkenalkan Tugas Tugas Dalam kompetisi ini, a memberikan unit kerja asynchronous. tidak seperti hanya memanggil fungsi, a is a managed object that runs concurrently with other tasks in a cooperative thread pool. Task async Task Tugas dikelola oleh kolaboratif thread pool. kolaboratif thread pool dirancang untuk mengelola concurrency secara efisien dengan memungkinkan tugas untuk menghasilkan CPU sementara menunggu operasi asynchronous untuk selesai. Tugas dikelola oleh kolaboratif thread pool. kolaboratif thread pool dirancang untuk mengelola concurrency secara efisien dengan memungkinkan tugas untuk menghasilkan CPU sementara menunggu operasi asynchronous untuk selesai. Tugas dapat dibuat untuk berjalan bersamaan, dan mereka juga dapat ditunggu-tunggu atau dibatalkan. Mereka memberikan kontrol halus atas perilaku asynchronous dan merupakan bagian integral dari concurrency terstruktur di Swift. menciptakan a Task Tugas dapat dibuat dengan menggunakan , yang segera memulai operasi asynchronous yang disediakan: Task initializer inisiatif Task(priority: .userInitiated) { await fetchData() } Ketika Anda membuat a menggunakan initializer standar (yaitu, tidak ), ia mewarisi konteks, prioritas, dan nilai-lokal tugas aktor di sekitarnya. perilaku ini sangat penting untuk konvergennya terstruktur dan keamanan dalam kode konvergennya. Task Detasemen Detasemen 💡 Swift 6.2 memperkenalkan perubahan yang signifikan dalam cara concurrency ditangani: secara default, semua kode berjalan di MainActor. Untuk menjalankan kode di latar belakang, Swift 6.2 menambahkan atribut baru @concurrent. Anda juga dapat menggunakan nonisolated jika kode tidak memerlukan akses ke aktor utama. 💡 Swift 6.2 memperkenalkan perubahan signifikan pada bagaimana concurrency diproses: secara default, semua kode berjalan pada MainActor Untuk menjalankan kode di latar belakang, Swift 6.2 menambahkan atribut baru @concurrent Anda juga dapat menggunakan nonisolated if the code doesn’t require access to the main actor. WWDC Mengadopsi Kompetisi Swift WWDC Mengadopsi Kompetisi Swift WWDC Mengadopsi Kompetisi Swift Di bawah topi, dalam versi sebelumnya dari Swift Concurrency, runtime Swift menggunakan mekanisme internal yang disebut Meskipun properti ini bukan bagian dari API publik, itu memainkan peran kunci dalam memastikan bahwa tugas yang dibuat dalam kode terisolasi aktor akan dilakukan pada aktor yang sama, mempertahankan keamanan balapan data. @_inheritActorContext Dengan kemajuan di Swift, runtime telah mulai beralih dari Sebuah sistem baru yang dikenal sebagai , yang sekarang lebih eksplisit ditangani oleh kompilator dan runtime. @_inheritActorContext sending 💡 Apa itu mengirim? mengirim adalah kata kunci baru yang diperkenalkan di Swift 6 sebagai bagian dari pergeseran bahasa ke arah concurrency yang lebih aman dan lebih eksplisit. Ini digunakan untuk menandai parameter fungsi dan mengembalikan nilai yang dipindahkan melintasi batas concurrency. Ini bekerja sangat baik jenis noncopyable, memastikan keamanan memori dan mencegah kesalahan-kesalahan setelah digunakan. Ketika parameter ditandai dengan mengirim, kompilator memaksa bahwa instansi asli tidak lagi diakses setelah transfer. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } 💡 Apa itu mengirim? mengirim adalah kata kunci baru yang diperkenalkan di Swift 6 sebagai bagian dari pergeseran bahasa ke arah concurrency yang lebih aman dan lebih eksplisit. Ini digunakan untuk menandai parameter fungsi dan mengembalikan nilai yang dipindahkan melintasi batas concurrency. Ini bekerja sangat baik jenis noncopyable, memastikan keamanan memori dan mencegah kesalahan-kesalahan setelah digunakan. Ketika parameter ditandai dengan mengirim, kompilator memaksa bahwa instansi asli tidak lagi diakses setelah transfer. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } When you launch a , Anda harus memastikan bahwa semua nilai yang ditangkap oleh tugas adalah Kompiler sekarang menegakkan ini pada waktu kompilasi menggunakan Protokol dan Fungsi tipe Task.detached Sendable Sendable @Sendable Tidak dapat mematuhi dapat mengakibatkan kesalahan waktu kompilasi, terutama dalam mode concurrency yang ketat. Sendable Tugas juga mendukung prioritas, mirip dengan bagaimana barisan Grand Central Dispatch menangani mereka. vs Task Task.detached Ketika bekerja dengan Swift Concurrency, penting untuk memahami perbedaan antara dan , karena mereka mendefinisikan bagaimana dan di mana kerja asinkron dilakukan. Task Task.detached Task Tugas menguasai konteks aktor saat ini (seperti Ini biasanya digunakan ketika Anda ingin melahirkan operasi asynchronous baru yang masih menghormati pohon konjugasi terstruktur saat ini atau isolasi aktor. Task MainActor Task { await updateUI() } Dalam contoh di atas, jika dipanggil dari aktor utama, juga akan berjalan pada aktor utama kecuali secara eksplisit pindah ke tempat lain. Task Task.detached Task.detached yang membuat tugas yang sepenuhnya independen. tidak mewarisi konteks atau prioritas aktor saat ini. Ini berarti dimulai dalam konteks bersamaan global dan membutuhkan manajemen keamanan, terutama saat mengakses data yang dibagikan. Task.detached Task.detached { await performBackgroundWork() } Use ketika Anda perlu menjalankan operasi latar belakang di luar konteks terstruktur saat ini, seperti menjalankan perhitungan panjang atau melarikan diri dari isolasi aktor. Task.detached Kolaborasi Thread Pool Cooperative Thread Pool dalam Swift Concurrency adalah mekanisme yang mengelola pelaksanaan tugas-tugas asynchronous dengan menjadwalkan mereka pada sejumlah thread terbatas, biasanya sesuai dengan jumlah inti CPU. Cooperative Thread Pool dalam Swift Concurrency adalah mekanisme yang mengelola pelaksanaan tugas-tugas asynchronous dengan menjadwalkan mereka pada sejumlah thread terbatas, biasanya sesuai dengan jumlah inti CPU. Swift Concurrency beroperasi menggunakan kolaboratif thread pool yang dirancang untuk perencanaan yang efisien dan overhead thread minimal. Tidak seperti model eksekusi thread-per-task tradisional, pendekatan Swift menekankan konsistensi terstruktur dan perencanaan sadar sumber daya. Sebuah supersemplifikasi umum adalah untuk mengatakan bahwa Swift Concurrency menggunakan satu thread per inti, yang selaras dengan tujuannya untuk mengurangi switching konteks dan memaksimalkan penggunaan CPU. Thread Count: Tidak semudah itu Thread Count: Tidak semudah itu Pada Mac 16-core, memungkinkan untuk mengamati hingga 64-threads yang dikelola oleh Swift Concurrency saja - tanpa keterlibatan GCD. Ini karena kolaboratif Swift thread pool memetakan tidak hanya per-core, tetapi per-core per QoS bucket. Secara resmi : Max threads = (CPU cores) × (dedicated quality-of-service buckets) Dengan demikian, pada sistem 16-core: 16 cores × 4 QoS buckets = 64 threads Setiap bucket QoS pada dasarnya adalah thread lane yang didedikasikan untuk sekelompok tugas yang berbagi prioritas eksekusi yang sama. QoS dan Prioritas Task QoS dan Prioritas Task Meskipun Ada enam konstanta, beberapa di antaranya adalah alias: TaskPriority Usia yang tinggi Manfaatnya yang rendah default → sudah dipaparkan ke medium Untuk perspektif kernel, ini menyederhanakan ke 4 tingkat prioritas inti, masing-masing dipaparkan ke bucket QoS, yang mempengaruhi alokasi thread di kolaboratif thread pool. Kapan Overcommit Terjadi? Kapan Overcommit Terjadi? Di bawah beban normal, Swift Concurrency menghormati batasan kolaboratif. Namun, di bawah perselisihan (misalnya, tugas prioritas tinggi menunggu untuk yang prioritas rendah), sistem mungkin overcommit thread untuk mempertahankan responsif. penyesuaian dinamis ini memastikan bahwa tugas-tugas sensitif waktu tidak diblokir tanpa batas di belakang pekerjaan prioritas rendah. This behavior is managed by the Darwin kernel via Mach scheduling policies and high-priority jalur - bukan sesuatu yang secara eksplisit dikendalikan oleh kode Anda. pthreads Tugas Prioritas Swift menyediakan sistem prioritas untuk tugas, mirip dengan Grand Central Dispatch (GCD), tetapi lebih terintegrasi secara semantik ke dalam model concurrency terstruktur. Untuk Initializer: Task Task(priority: .userInitiated) { await loadUserData() } Prioritas yang tersedia ditentukan oleh Enum : 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. / yang .high .userInitiated Untuk tugas yang dimulai oleh interaksi pengguna yang membutuhkan umpan balik segera. .medium For tasks that the user is not actively waiting for. / yang .low .utility Untuk tugas panjang yang tidak memerlukan hasil segera, seperti menyalin file atau mengimpor data. .background Untuk tugas latar belakang yang pengguna tidak langsung menyadari. terutama digunakan untuk pekerjaan pengguna tidak dapat melihat. Menciptakan tugas dengan prioritas yang berbeda Menciptakan tugas dengan prioritas yang berbeda When you create a dalam tugas lain (default prioritas), Anda dapat secara eksplisit menetapkan prioritas yang berbeda untuk setiap tugas yang terpasang. , dan yang lainnya adalah .high. Ini menunjukkan bahwa prioritas dapat ditetapkan secara individual terlepas dari orang tua. 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 Jika Anda tidak secara eksplisit menetapkan prioritas untuk tugas yang terpasang, tugas itu mewarisi prioritas dari orang tua langsung. dan blok mewarisi prioritas masing-masing kecuali diunggah. .high .low Prioritas tugas dapat diwariskan Prioritas tugas dapat diwariskan 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 Jika Anda tidak secara eksplisit menetapkan prioritas untuk tugas yang terpasang, tugas tersebut mewarisi prioritas dari orang tuanya yang langsung. dalam contoh ini, tugas-tugas anonim di dalam blok .high dan .low mewarisi prioritas masing-masing kecuali diunggah. Tugas Prioritas Escalation Tugas Prioritas Escalation 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 Mekanisme ini disebut eskalasi prioritas – ketika tugas ditunggu oleh tugas prioritas yang lebih tinggi, sistem dapat secara sementara meningkatkan prioritasnya untuk menghindari hambatan dan memastikan responsif. As a result: Task 2, which is , is escalated to while being awaited. .low .high Tugas 3, yang tidak memiliki prioritas eksplisit, mewarisi prioritas eskalasi dari prioritas induknya (Tugas 2) dan juga dijalankan dengan .highpriority. Task 4 secara eksplisit menetapkan prioritasnya ke .medium, sehingga tidak terpengaruh oleh eskalasi. Tidak mewarisi prioritas Task.detached yang Task.detached yang Tugas yang harus dipenuhi ( Mereka berperilaku seperti tugas global dengan jadwal mereka sendiri. ini berguna untuk mengisolasi kerja latar belakang, tetapi juga dapat menyebabkan ketidakpatuhan prioritas yang tidak terduga jika tidak diatur secara manual. 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 Poin Suspension dan Cara Swift Mengelola Eksekusi Async Dalam Swift, setiap panggilan ke Fungsi Menggunakan adalah titik suspensi potensial - tempat dalam fungsi di mana eksekusi mungkin berhenti dan melanjutkan kemudian.Ini adalah transformasi yang melibatkan menyimpan keadaan fungsi sehingga dapat dilanjutkan kemudian, setelah operasi yang diharapkan selesai. async await Here’s an example: func fetchData() async -> String { let result = await networkClient.load() return result } Dalam kasus ini, Ketika fungsi mencapai garis ini, dapat menghentikan eksekusi, memberikan kontrol ke sistem, dan kemudian melanjutkan sekali. Di belakang adegan, kompilator mengubah fungsi ini menjadi mesin keadaan yang melacak kemajuan dan variabel internal. await networkClient.load() load() Under the Hood: Continuations and State Machines Setiap fungsi dalam Swift dikompilasi menjadi sebuah mesin negara. menandai titik transisi. sebelum mencapai titik Untuk Swift: async await await Menyimpan status saat ini dari fungsi - termasuk variabel lokal dan penunjuk instruksi saat ini. Menghentikan eksekusi dan merencanakan kelanjutan. Setelah operasi async selesai, ia melanjutkan fungsi dari tempat di mana ia berhenti. Ini mirip dengan gaya continuation-passing (CPS) yang digunakan dalam banyak sistem pemrograman fungsional. dalam model concurrency Swift, ini disusun oleh jenis internal seperti dan jadwal kompetisi. ParticialAsyncTask Penghentian! = Penghentian Ketika kamu sesuatu di Swift, thread saat ini tidak diblokir, sebaliknya: await Tugas saat ini menghasilkan kontrol kembali ke eksekutor Tugas lain yang dapat dijalankan saat menunggu Ketika operasi yang diharapkan selesai, tugas yang ditangguhkan berlanjut pada eksekutor yang sesuai. Hal ini membuat secara fundamental lebih efisien dan dapat diperluas daripada operasi blokir berbasis thread seperti . async/await DispatchQueue.sync : membiarkan tugas-tugas lain berjalan Task.yield() Task.yield adalah ( is a static method provided by Swift’s concurrency system that voluntarily suspends the current task, giving the system opportunity to run other enqueued tasks. It’s especially useful in long-running asynchronous operations or tight loops that don’t naturally contains suspension points. Task.yield() func processLargeBatch() async { for i in 0..<1_000_000 { if i % 10_000 == 0 { await Task.yield() } } } tanpa , this loop would monopolize the executor. By inserting secara berkala, Anda berkolaborasi dengan runtime concurrency Swift, memungkinkan untuk mempertahankan responsif dan keadilan. await await Task.yield() Di bawah Hood Panggilan menunggu menangguhkan tugas saat ini dan mengajaknya kembali pada akhir barisan untuk eksekutor saat ini (misalnya, pemain utama atau eksekutor bersamaan global). Task.yield() Ini adalah bagian dari model multitasking kooperatif Swift: tugas berjalan ke titik suspensi berikutnya dan diharapkan menghasilkan dengan adil. tidak seperti sistem preemptive (misalnya, thread), tugas Swift tidak terganggu dengan paksa - mereka harus secara sukarela memberikan kontrol. Pendekatan Swift 6 menandai langkah maju yang signifikan dalam cara concurrency ditangani, menawarkan pengembang lebih banyak kontrol, prediktabilitas, dan keamanan.Meskipun kurva belajar mungkin ketat pada awalnya, memahami konsep-konsep ini membuka pintu untuk membangun aplikasi yang sangat responsif dan kuat.Sementara kami terus mengeksplorasi aspek yang lebih dalam dari model concurrency baru Swift, jelas bahwa perubahan ini meletakkan dasar untuk masa depan pengembangan aplikasi yang aman dan dapat diperluas.