Swift 6 გააჩნია ახალი მიმოხილვა concurrency app. ამ სტატიაში, ჩვენ შეამოწმოთ პრობლემები ის მიზნით, რათა გადაწყვეტა, გააჩნია, თუ როგორ მუშაობს ქვეშ კაბა, შედარებით ახალი მოდელი წინა, და მიიღოს უფრო ზუსტად Actor მოდელი. მომდევნო ნაწილებში, ჩვენ ასევე გააკეთა executors, scheduleers, სტრუქტურული concurrency, სხვადასხვა ტიპის executors, განახლება ჩვენი საკუთარი executor, და სხვა. Swift კონკურენტების მიმოხილვა: პრობლემები და გადაწყვეტილებები Concurrency has long been one of the most challenging aspects of software development. Writing code that runs tasks simultaneously can improve performance and responsiveness, but it often introduces complexity and subtle bugs as race conditions, deadlocks, and thread-safety issues. Swift Concurrency, რომელიც გამოიყენება Swift 6- ში, მიზნადა შეუზღუდავი პროგრამირება, რათა უზრუნველყოს ნათელი, უსაფრთხო და ეფექტური მოდელი asynchronous საქმიანობის მართვისთვის. ეს საშუალებას იძლევა განვითარებელს თავიდან ავიცილოთ პოპულარული რელიგიები, რათა უზრუნველყოს მკაცრი წესები მონაცემების ხელმისაწვდომობის და შესრულების ბრძანებით. 💡 თუ თქვენ გამოიყენებთ Swift 5.x და გსურთ გააუმჯობესოთ Swift 6, თქვენ შეგიძლიათ გააქტიუროთ Swift Concurrency კონცენტრაცია თქვენი პროექტში. ეს საშუალებას გაძლევთ გაუმჯობესოთ ახალი კონცენტრაციის მოდელი, ხოლო შენარჩუნება კომპიუტერულიობის არსებობს კოდი. ამ კონცენტრაციის გააქტიურება საშუალებას გაძლევთ დაწყოს პოტენციური კონცენტრაციის პრობლემები ადრე, გააკეთა გადაზიდვა გლუვი და უსაფრთხო. როდესაც თქვენ განახლება თქვენი კოდიბოს, თქვენ შეგიძლიათ დაიწყოს ინტეგრირება async/await სინთაქტი და სხვა Swift Concurrency ფუნქციები ნაცვლად გარეშე სრული rewrite. 💡 თუ თქვენ გამოიყენებთ Swift 5.x და გსურთ გააუმჯობესოს Swift 6, თქვენ შეგიძლიათ გააქტიუროთ Swift Concurrency კონცენტრაცია თქვენი პროექტში. ეს საშუალებას გაძლევთ გაუმჯობესოს ახალი კონცენტრაციის მოდელი, ხოლო შენარჩუნება თავსებადი existing კოდი. ამ კონცენტრაციის გააქტიურება დაგეხმარებათ დაწყოს პოტენციური კონცენტრაციის პრობლემები ადრე, რაც გადაზიდვა უფრო გლუვი და უსაფრთხო. როდესაც თქვენ განახლება თქვენი კოდი ბაზა, თქვენ შეგიძლიათ დაიწყოს ინტეგრირება async/await Syntax და სხვა Swift Concurrency ფუნქციები შეუზღუდავი შეუზღუდავი გარეშე სრული rewrite. Some of the key problems Swift Concurrency addresses include: Race Conditions: თავიდან ავიცილოთ ერთდროულად ხელმისაწვდომობის გაერთიანებული mutable სახელმწიფო, რომელიც შეიძლება გამოიწვიოს შეუზღუდავი ქცევა. Callback hell: Simplifying asynchronous code that used to rely heavily on nested callbacks or completion handlers, making code easier to read and maintain. Thread Management Complexity: Abstracting off დაბალი დონის შექმნა და სინქრონიზაცია, საშუალებას გაძლევთ განვითარებლები შეუზღუდავი სტრუქტურა, ვიდრე thread handling. სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურა. ახალი ენის ფუნქციები, როგორიცაა Swift 6 უზრუნველყოფს უფრო ინტელექტუალური და ძლიერი გზა ქსოვილის შექმნა, რათა გააუმჯობესოს ორივე Developer Productivity და app სტაბილურობა. async/await მრავალფუნქციური თანამედროვე ოპერაციული სისტემები და runtimes გამოიყენება multitasking გაკეთება ერთჯერადი სამუშაო ერთეული. Swift Concurrency იღებს თანამშრომლობის multitasking, რომელიც განსხვავდება ძირითადად preemptive multitasking მოდელი გამოიყენება OS დონე სფეროები. განიხილება განსხვავება არის ძირითადი და უსაფრთხო asynchronous Swift კოდი. Preventive Multitasking პროგრამა Preemptive multitasking არის მოდელი, რომელიც ოპერაციული სისტემები გამოიყენება thread და პროცესების მართვისთვის. ამ მოდელიში, სისტემის დონეზე გრაფიკერი შეუძლია თითქმის ნებისმიერ დროში ნებისმიერი thread შეჩერება და კონტექსტალური გადახდის გაკეთება და CPU დრო სხვა thread- ისთვის. ეს უზრუნველყოფს სისტემის საერთო სიზუსტით და საშუალებას გაძლევთ რეცეპტიული პროგრამები - განსაკუთრებით მრავალჯერადი მომხმარებლის მორგებული ან დროის მგრძნობიარე საქმიანობას. Preemptive multitasking საშუალებას იძლევა ნამდვილი პარამეტრიზს მრავალჯერადი CPU kernels და თავიდან ავიცილოთ ცუდი ქცევის ან ხანგრძლივი გაშვებული ქცევის monopolizing სისტემის რესურსების. თუმცა, ეს flexibility მოდის ღირებულება. იმის გამო, რომ ქცევის შეიძლება იყოს შეჩერებული ნებისმიერ ეტაპზე მათი შესრულების - მაშინაც კი მეშვეობით მნიშვნელოვანი ოპერაცია - განვითარებლები უნდა გამოიყენოთ synchronization primitives როგორიცაა mutexes, semaphores, ან atomic ოპერაციები, რათა დაცვა შეუერთებული ცუდი სახელმწიფო. არ გააკეთოს ეს შეიძლება გამოწვევა მონაცემთა ქცევის, crashes, ან სინათლის bugs, რომელიც ხშირად რთულია იპოვოს და მოპოვოს. ეს მოდელი უზრუნველყოფს უკეთესი კონტროლი და ნედლეულის კონცენტრაცია, მაგრამ იგი ასევე დააყენებს მნიშვნელოვანია უფრო მაღალი ტანსაცმელი მწარმოებლები. უზრუნველყოფა სარეცხი უსაფრთხოების თავმჯდომარე გარემოში არის შეცდომები და შეიძლება გამოიწვიოს non-deterministic ქცევა - ქცევა, რომელიც განსხვავდება run-to-run - რომელიც ცნობილია, რომ რთული განიხილება ან საიმედო ტესტირება. ტექნიკური პრაქტიკაში, preemptive multitasking დამოკიდებულია ოპერაციული სისტემაში, რათა გააკეთა thread execution. OS შეუძლია შეუწყოს thread თითქმის ნებისმიერ ეტაპზე - მაშინაც კი ფუნქციების მეშვეობით - და შეცვლა სხვა. ამისთვის, სისტემა უნდა გააკეთა context switch, რომელიც მოიცავს შენარჩუნება მთელი შესრულების სტრუქტურა ამჟამად thread (გალითად, CPU რეგისტრატორები, ინსტრუქციები pointer, და stack pointer), და დასაწყისში შენარჩუნებული სტრუქტურა სხვა thread. ეს პროცესი შეიძლება ასევე მოითხოვოს spushing CPU caches, შეუზღუდავი Translation Lookaside Buffer (TLB), და გადაზიდვა შორის user mode და kernel mode. ეს ოპერაციები იძლევა მნიშვნელოვანი runtime overhead. თითოეული კონტექსტური გადამცემი იღებს დრო და იღებს სისტემის რესურსები - განსაკუთრებით როდესაც კონტექსტური გადამცემები ხშირად არიან ან როდესაც მრავალი სინათები კონკურენციონირებენ შეზღუდული CPU კუნძულებს. გარდა ამისა, preemptive multitasking მოცულობა განვითარებლები წერილი thread-safe კოდი default, გაზრდის საერთო მოკლე და რისკის შედუღების რისკი. მიუხედავად იმისა, რომ ეს მოდელი უზრუნველყოფს მაქსიმალური ფართოობის და ნამდვილი პარამეტრიზას, ეს ხშირად უამრავია asynchronous workflows, სადაც საქმიანობა ჩვეულებრივ უამრავი დრო იძლევა I/O, მომხმარებლის input, ან ქსელის პასუხები, ვიდრე აქტიურად გამოყენებით CPU. კონტაქტი Multitasking Swift- ის კონცენტრირებული runtime- ის გამოყენებით იყენებს თანამშრომლობის multitasking- ს. ამ მოდელიში, საქმიანობა აწარმოებს, სანამ ეს უპირატესობად გაძლევთ კონტროლი – ჩვეულებრივ, შეინარჩუნების ეტაპზე ან ექსპერიმენტური მოვუწოდებით კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქტური კონტაქ Task.yield() Swift- ის თანამშრომლობის საქმიანობა დაჯავშნა მსუბუქი, runtime-managed cooperative thread pool- ისგან, რომელიც განსხვავდება Grand Central Dispatch- ის ქსოვილებისგან. ამ ქსოვილზე გაშვებული საქმიანობა მოითხოვს "მომცველი नागरिक", რომელიც საჭიროების შემთხვევაში კონტროლის საშუალებას იძლევა, განსაკუთრებით ხანგრძლივი გაშვების ან CPU-მმომცველი სამუშაო დროს. ამ მხარდაჭერა, Swift უზრუნველყოფს როგორც მექანიკური suspension point, უზრუნველყოფს სხვა საქმიანობის შანსი გაკეთება. Task.yield() მიუხედავად იმისა, რომ ოპერაციული მრავალფუნქციონირება მოიცავს შეზღუდვა: თუ საქმიანობა არასდროს შეჩერება, მას შეუძლიათ მონოპოლიზოს ქსოვილის, რომელიც იგი იღებს, დატვირთვა ან სხვა საქმიანობა სისტემაში. ასე რომ, ეს არის განვითარებლის პასუხისმგებლობა, რათა უზრუნველყოს, რომ ხანგრძლივი ოპერაციები მოიცავს შეჩერების პერსონალებს. ფართო ხარისხის ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფართო ფუნქცია შეჩერება A Swift Runtime- ს ამჟამად ამჟამად გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართოებული გაფართო async await Swift Runtime- ის მორგება, როგორც გაგრძელების მიწოდება. თითოეული მიწოდება ერთი გაგრძელება კიდევ ერთი შემდეგ. როდესაც გაგრძელება დასრულდება ან კიდევ ერთი გაგრძელება, მიწოდება შემდეგი მზად გაგრძელება. როგორც აღწერილი, ეს მოდელი თავიდან ავიცილოთ ტრადიციული ოპერაციული დონეზე კონტაქტის გადახურვა. არ არსებობს საჭიროება გადარჩენა და გადარჩენა CPU რეგისტრატორები ან thread stacks; runtime უბრალოდ მოვუწოდებს შემდეგი დახურვის სახის გაგრძელება. ეს იძლევა სამუშაო გადახურვა ძალიან სწრაფად და ადვილად, მიუხედავად იმისა, რომ ეს მოიცავს გაზრდილი ქსოვილის გადახურვა გადარჩენა შეჩერებული async სახელმწიფო. ძირითადი კონტაქტი: თქვენ იყენებთ პატარა უფრო მახასიათებლები, მაგრამ იღებთ ძალიან დაბალი overhead განხორციელების მართვისთვის. თანამშრომლობის გრაფიკაცია უზრუნველყოფს მკაცრი კონტროლი, როდესაც შეჩერება ხდება, რაც გააუმჯობესებს პროგნოზი და იძლევა შეჩერება ადვილია. მიწოდება Task სამუშაოები Swift კონკურენციაში, a იმიტომ, რომ ეს არის ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი ერთ-ერთი. ფუნქცია A ეს არის მენეჯმენტი, რომელიც აწარმოებს სხვა საქმიანობასთან ერთად ერთობლივი thread pool. Task async Task 💡 საქმიანობა მენეჯმენტი თანამშრომლობის thread pool. Cooperative thread pool განკუთვნილია მენეჯმენტი ეფექტურად საშუალებას გაძლევთ საქმიანობა გაძლევთ CPU, ხოლო დაველოდოთ asynchronous ოპერაციები დასრულდეს. ეს მიღება გამოყენებით async ფუნქციები და საქმიანობა, რომელიც არის ძირითადი ერთეული concurrency in Swift. 💡 საქმიანობა მენეჯმენტი თანამშრომლობის thread pool. Cooperative thread pool განკუთვნილია მენეჯმენტი ეფექტურად საშუალებას გაძლევთ საქმიანობა გაძლევთ CPU, ხოლო დაველოდოთ asynchronous ოპერაციები დასრულდეს. ეს მიღება გამოყენებით async ფუნქციები და საქმიანობა, რომელიც არის ძირითადი ერთეული concurrency in Swift. მას შეუძლია შექმნას ამავე დროს, და ისინი ასევე შეიძლება დაველოდოთ ან დახურვა. ისინი უზრუნველყოფს ფანტასტიკური კონტროლი asynchronous ქცევის და არის ინტეგრირებული ნაწილი სტრუქტურული concurrency in Swift. შექმნა a Task მას შეუძლია შექმნას, გამოყენებით , რომელიც დაუყოვნებლივ იწყებს უზრუნველყოს asynchronous ოპერაცია: Task ინტიმური ინტიმური Task(priority: .userInitiated) { await fetchData() } როდესაც თქვენ შექმნათ a გამოყენებით სტანდარტული initializer (მაგ. არ არის ), იგი იპოვებს გარშემო სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურული სტრუქტურ Task განთავსებული განთავსებული 💡 Swift 6.2 introduces a significant change to how concurrency is handled: by default, all code runs on MainActor Swift 6.2 ადაპტებს ახალი თვისებები კოდი ფართობიზე @concurrent . You can also use nonisolated if the code doesn’t require access to the main actor. WWDC Embracing Swift Concurrency 💡 Swift 6.2 introduces a significant change to how concurrency is handled: by default, all code runs on MainActor Swift 6.2 ადაპტებს ახალი თვისებები კოდი ფართობიზე @concurrent თქვენ ასევე შეგიძლიათ გამოიყენოთ nonisolated if the code doesn’t require access to the main actor. WWDC- ს შეთავაზება Swift კონკურენტრაციისთვის WWDC- ს შეთავაზება Swift კონკურენტრაციისთვის WWDC- ს შეთავაზება Swift კონკურენტრაციისთვის Swift Concurrency- ის წინა ვერსებში Swift Runtime- ს გამოიყენა შიდა მექანიზმი, რომელიც გამოიყენება Swift Concurrency- ს. მიუხედავად იმისა, რომ ეს თვისება არ იყო ნაწილი საზოგადოებრივი API- ს, იგი ითამაშა ძირითადი როლი, რათა უზრუნველყოს, რომ საქმიანობა, რომელიც შექმნილია სტრატე-მართული კოდიში, აწარმოებს იგივე სტრატეზე, რათა შენარჩუნოთ მონაცემთა უსაფრთხოება. @_inheritActorContext Swift- ის გაუმჯობესების შემდეგ, Runtime- ის გადაზიდვა დაიწყო ახალი მოწყობილობა, რომელიც ცნობილია როგორც , რომელიც ახლა უფრო სპეციფიკურად დამუშავებულია კომპიუტერის და runtime. @_inheritActorContext sending 💡 რა არის გადაზიდვა? გადაზიდვა არის ახალი ძირითადი სიტყვა, რომელიც Swift 6- ში შეიმუშავებულია, როგორც ნაწილი ენის გადაზიდვა უფრო უსაფრთხო და უფრო ექსკლუზიური კონკურენციაში. იგი გამოიყენება ფუნქციონალური პარამეტრების და გადაზიდვის ღირებულების შეზღუდვისთვის, რომლებიც კონკურენციაის სფეროებში გადაზიდებულია. ეს მუშაობს განსაკუთრებით კარგად აროპირურული ტიპები, რათა უზრუნველყოს მეხსიერების უსაფრთხოება და თავიდან ავიცილოთ გამოყენების შემდეგ გადაზიდვის შეცდომები. როდესაც პარამეტრი შეზღუდულია გადაზიდვის მიერ, კომბინერი უზრუნველყოფს, რომ ორიგინალური instance არ არის უფრო ხელმისაწვდომი გადაზიდვის შემდეგ func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } რა არის sending ? sending Swift 6 არის ახალი Keyword, რომელიც გამოიყენება Swift 6- ში, როგორც ნაწილი ენის გადაზიდვა უფრო უსაფრთხო და უფრო ექსპერიმენტი კონკურენციაში. იგი გამოიყენება ფუნქციონალური პარამეტრები და რეიტინგი ღირებულებები, რომლებიც კონკურენციაში ზრდის. ეს მუშაობს განსაკუთრებით კარგად არკობრიურ ტიპები, უზრუნველყოფს მეხსიერების უსაფრთხოებას და თავიდან ავიცილოთ გამოყენების შემდეგ გადაზიდვის შეცდომები. როდესაც პარამეტრი შეიცავს sending , compiler უზრუნველყოფს, რომ ორიგინალური instance არ არის უფრო ხელმისაწვდომი მას შემდეგ, რაც გადაცემა. func process(_ data: sending MyNonCopyableType) async { // `data` is moved here and can’t be used elsewhere after the call } როდესაც თქვენ დაწყებთ a , თქვენ უნდა უზრუნველყოს, რომ ნებისმიერი ღირებულება, რომელიც იღებს სამუშაო არის ახლა კომპიუტერები ამ დროს კომპიუტერის დროს იყენებენ კონტაქტი და ფუნქციონალური ტიპი Task.detached Sendable Sendable @Sendable არ შეესაბამება may result in a compile-time error, particularly in strict concurrency mode. Sendable Task ასევე მხარს უჭერს Priorities, როგორიცაა, თუ როგორ Grand Central Dispatch ხაზები გადამუშავებს მათ. vs Task Task.detached როდესაც მუშაობს Swift Concurrency, მნიშვნელოვანია გაიგოთ განსხვავება და , as they define how and where asynchronous work is executed. Task Task.detached Task Task ამჟამად, ამჟამად, ამჟამად, ამჟამად, ამჟამად, ამჟამად, ამჟამად, ამჟამად, ამჟამად. or any custom actor) and priority. It’s commonly used when you want to spawn a new asynchronous operation that still respects the current structured concurrency tree or actor isolation. This is especially useful for UI updates or working inside specific concurrency domains. Task MainActor Task { await updateUI() } მაგალითად, იმ შემთხვევაში, თუ ძირითადი მოვლენები, will also run on the main actor unless explicitly moved elsewhere. Task Task.detached Task.detached საწყისი მას შეუძლია სრულიად დამოუკიდებელი საქმიანობა. ეს არ იძლევა ამჟამად მოვლენების კონტაქტზე ან Priority. ეს იმას ნიშნავს, რომ იგი იწყება გლობალური კონტაქტში და საჭიროა უსაფრთხოების მართვა, განსაკუთრებით, როდესაც ხელმისაწვდომია შემუშავებული მონაცემები. Task.detached Task.detached { await performBackgroundWork() } გამოყენება როდესაც თქვენ უნდა აწარმოოთ ფართო ოპერაციები ამჟამად სტრუქტურული კონტაქტი, როგორიცაა ხანგრძლივი კომპიუტერები ან escaping სტრუქტურული კონტაქტი. Task.detached Cooperative Thread Pool Cooperative Thread Pool in Swift Concurrency არის მექანიზმი, რომელიც მართავს asynchronous საქმიანობის შესრულებას, მათ შეზღუდული რაოდენობით ქსელები, როგორც წესი, შეესაბამება CPU ქსელები. Cooperative Thread Pool in Swift Concurrency არის მექანიზმი, რომელიც მართავს asynchronous საქმიანობის შესრულებას, მათ შეზღუდული რაოდენობით ქსელები, როგორც წესი, შეესაბამება CPU ქსელები. Swift Concurrency operates using cooperative thread pool designed for efficient scheduling and minimal thread overhead. Unlike traditional thread-per-task executing model, Swift’s approach emphasizes structured concurrency and resource-aware scheduling. Swift Concurrency იყენებს ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი სინათლის ერთ-ერთი Thread Count: არ არის ძალიან მარტივი Thread Count: არ არის ძალიან მარტივი Swift Concurrency- ის მიერ მენეჯერირებული 64- სქემები მხოლოდ 16-კორ Mac- ში – GCD- ის შეუერთების გარეშე. ეს იმიტომ, რომ Swift- ის თანამშრომლობის სქემის კოლექცია არ არის მხოლოდ კავშირი, არამედ კავშირი კავშირი კავშირი კავშირი კავშირი. ოფიციალურად : Max threads = (CPU cores) × (dedicated quality-of-service buckets) ეს არის 16-კორანი სისტემა: 16 cores × 4 QoS buckets = 64 threads Each QoS bucket is essentially a dedicated thread lane for a group of tasks sharing similar execution priority. These are managed internally by Darwin’s thread scheduling mechanism and are not the same as GCD queues. QoS Buckets და Task Priority QoS Buckets და Task Priority თუმცა 6 სტანდარტებს აჩვენებს, მათ შორის: TaskPriority → usedInitiated high Low ეფექტურობა დასაწყისში დასაწყისში დასაწყისში Kernel- ის perspective- ისთვის, ეს ადვილად შეესაბამება 4 core priority დონეზე, თითოეული მოპოვებულია QoS bucket- ში, რომელიც ეფუძნება thread allocation- ში co-operative thread pool. როდესაც ხდება Overcommit? როდესაც ხდება Overcommit? Swift Concurrency რეგულარული სიჩქარით შეესაბამება პარტნიორული პოსტის შეზღუდვები. თუმცა, კონტაქტის დროს (გალითად, მაღალი προτεραιότητας საქმიანობა დაბალი προτεραιότητας საქმიანობისთვის), სისტემა შეიძლება შეუზღუდავი საქმიანებს შეინარჩუნოს პასუხისმგებლობა. ეს დინამიკული შეზღუდვა უზრუნველყოფს, რომ დროზე მგრძნობიარე საქმიანობა არ არის შეუზღუდავი ქვემოთ დაბალი προτεραιότητας საქმიანობას. ამ ქცევის მართვა Darwin kernel მეშვეობით Mach გრაფიკული პოლიტიკა და მაღალი Priority ხაზები - არა არაფერი, რომელიც განიხილება თქვენი კოდი. pthreads Priority სამუშაოები Swift უზრუნველყოფს პროგნოზი სისტემა საქმიანობის, როგორიცაა Grand Central Dispatch (GCD), მაგრამ უფრო სემანტიკურად ინტეგრირებული სტრუქტურული concurrency მოდელი. თქვენ შეგიძლიათ დააყენოთ საქმიანობის პროგნოზი მეშვეობით დასაწყისი : Task Task(priority: .userInitiated) { await loadUserData() } ხელმისაწვდომი პარამეტრები განკუთვნილია დასაწყისი : 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. .high .userInitiated მომხმარებლის ინტერაქტიის დაწყებული საქმიანობისთვის, რომელიც მოითხოვს დაუყოვნებლივ მიმოხილვა. .medium ფუნქციონირება, რომელიც მომხმარებელს არ ეძებს. .low .utility For long-running tasks that don’t require immediate results, such as copying files or importing data. .background ძირითადად მუშაობისთვის გამოიყენება, რომელიც მომხმარებელს არ შეუძლია ნახოთ. Creating Tasks with Different Priorities განკუთვნილია სხვადასხვა Priorities როდესაც თქვენ შექმნათ a შემდგომი საქმიანობა (default task) ამ შემთხვევაში, თქვენ შეგიძლიათ აირჩიოთ სხვადასხვა ფუნქციონირება, რომელიც განსხვავდება თითოეული ფუნქციონირებული ფუნქციონირება. აქ, ერთი ფუნქციონირება არის , და მეორე არის .high. ეს აჩვენებს, რომ Priorities შეიძლება იყოს ინდივიდუალური, მიუხედავად იმისა, რომ საავტომობილო. 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: <_NSMainThread: 0x6000017040c0>{number = 1, name = main}, priority: TaskPriority.low // 2, thread: <_NSMainThread: 0x6000017040c0>{number = 1, name = main}, priority: TaskPriority.high If you don’t explicitly set a priority for a nested task, it inherits the priority of its immediate parent. In this example, the anonymous tasks inside and ბლოკები დაჯავშნა ამ respective Priorities, თუ არ აღემატება. .high .low Task Priorities შეიძლება იყოს დაჯავშნა Task Priorities შეიძლება იყოს დაჯავშნა 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: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.low // 1, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.high // 3, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.low // 4, thread: <_NSMainThread: 0x600001708040>{number = 1, name = main}, priority: TaskPriority.medium ამ მაგალითად, .high და .low ბლოკების შიდა ანონიმალური საქმიანობა თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად თავდაპირველად მზადდება. Task Priority Escalation Task Priority 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: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 2, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 3, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.high // 4, thread: <_NSMainThread: 0x6000017000c0>{number = 1, name = main}, priority: TaskPriority.medium ეს მექანიზმი ცნობილია, როგორც Priority Escalation - როდესაც საქმიანობა დასაწყისში მაღალი Priority საქმიანობა, სისტემა შეიძლება მუდმივად გააუმჯობესოს მისი Priority, რათა თავიდან ავიცილოთ bottlenecks და უზრუნველყოს რეპუტაცია. შედეგად : Task 2, რომელიც არის .low, გააუმჯობესება .high როდესაც დაველოდება. Task 3, რომელიც არ აქვს სპეციფიკური Priority, მოვუწოდებს escalated Priority მისი საავტომობილო (Task 2) და ასევე გააკეთა .highpriority. Task 4 უპირატესობად ადაპტირება .medium, ასე რომ ეს არ არის შეხვდა escalation. Does Not Inherit Priority Task.detached Task.detached Detached tasks ( ) run independently and do not inherit the priority of their parent task. They behave like global tasks with their own scheduling. This is useful for isolating background work, but can also lead to unexpected priority mismatches if not set manually. 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: <NSThread: 0x60000174dec0>{number = 4, name = (null)}, priority: TaskPriority.medium // 2, thread: <_NSMainThread: 0x600001708180>{number = 1, name = main}, priority: TaskPriority.low // 3, thread: <NSThread: 0x60000174dec0>{number = 4, name = (null)}, priority: TaskPriority.medium // 4, thread: <_NSMainThread: 0x600001708180>{number = 1, name = main}, priority: TaskPriority.medium შეზღუდვის მიზნები და როგორ Swift მართავს Async Execution Swift- ში, ნებისმიერი მოვუწოდება function using ეს არის პოტენციური შეზღუდვის წერტილი - ადგილი ფუნქციაში, სადაც შესრულება შეიძლება შეჩერდეს და შემდეგ დაიწყოს. ეს არის გადარჩენა, რომელიც მოიცავს ფუნქციის სტანდარტის გადარჩენა, ასე რომ მას შეუძლიათ განახლდეს შემდეგი, მას შემდეგ, რაც მოთხოვნილია ოპერაცია დასრულდება. async await Here’s an example: func fetchData() async -> String { let result = await networkClient.load() return result } ამ შემთხვევაში, is a suspension point. When the function reaches this line, it may pause execution, yield control to the system, and later resume once finishes. Behind the scenes, the compiler transforms this function into a state machine that tracks its progress and internal variables. await networkClient.load() load() Under the Hood: Continuations and State Machines Every Swift- ში ფუნქცია შეფუთულია სტატისტიკა მანქანაში. თითოეული marks a transition point. Before reaching an და Swift: async await await შეინახავს ფუნქციების მიმდინარე სტანდარტი, მათ შორის ადგილობრივი ცვლილებები და ამჟამად ხელმისაწვდომი შეტყობინება. განთავსება და განთავსება განთავსება. მას შემდეგ, რაც async ოპერაცია დასრულდა, იგი იღებს ფუნქციას, სადაც იგი დასრულდა. This is similar to the continuation-passing style (CPS) used in many functional programming systems. In Swift’s concurrency model, this is orchestrated by internal types like და კონკურენტული runtime გრაფიკი. ParticialAsyncTask შეჩერება ! = შეჩერება როდესაც თქვენ არაფერი Swift- ში, ამჟამად ამჟამად thread არ არის ბლოკული, instead: await The current task yields control back to the executor Other tasks can run while waiting მას შემდეგ, რაც დასაწყისი ოპერაცია დასრულდა, შეჩერებული ოპერაცია განახლდება შესაბამისი ოპერატორიზე. ეს აწარმოებს ძირითადად უფრო ეფექტური და გაფართოებული, ვიდრე thread-based blocking ოპერაციები, როგორიცაა . async/await DispatchQueue.sync : letting other tasks run Task.yield() Task.yield() ეს არის სტატისტიკური მეთოდი, რომელიც უზრუნველყოფს Swift- ის concurrency სისტემა, რომელიც უპირატესობად შეჩერებს ამჟამად სამუშაო, რომელიც საშუალებას გაძლევთ სისტემას აწარმოოს სხვა enqueued სამუშაოები. ეს არის განსაკუთრებით სასარგებლო გრძელვადიანი asynchronous ოპერაციები ან მჭიდრო loops, რომელიც ბუნებრივ არ შეიცავს შეჩერების პუნქტები. Task.yield() func processLargeBatch() async { for i in 0..<1_000_000 { if i % 10_000 == 0 { await Task.yield() } } } Without , ეს loop იქნება monopolizes executor. მიერ დააყენა რეგულარულად, თქვენ თანამშრომლობთ Swift- ის concurrency runtime, რომელიც საშუალებას გაძლევთ შენარჩუნოს რეპუტაცია და ბედნიერება. await await Task.yield() Hood-ის ქვეშ Calling await ამჟამად, ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად ამჟამად. Task.yield() ეს არის ნაწილი Swift- ის თანამშრომლობის მრავალფუნქციური მოდელი: საქმიანობა გაქირავდება მომდევნო შეჩერების ეტაპზე და მოსალოდნელია, რომ დაჯავშნა. განსხვავებით preemptive სისტემები (გალითად, ხაზები), Swift- ის საქმიანობა არ გაქირავება ძალად - მათ უნდა უპირატესობად გაქირავდეს კონტროლი. Summary Swift 6 marks a significant step forward in how concurrency is handled, offering developers more control, predictability, and safety. While the learning curve may be steep at first, understanding these concepts opens the door to building highly responsive and robust applications. As we continue exploring the deeper aspects of Swift’s new concurrency model, it’s clear that these changes lay the groundwork for the future of safe and scalable app development.
