რა შეგიძლიათ თქვათ Grand Central Dispatch-ის შესახებ და მისი გამოყენების შესახებ iOS განვითარებისას?

Grand Central Dispatch (GCD) — ეს არის დაბალ დონეზე API, რომელიც დაფუძნებულია ასინქრონული დავალებების შესრულების კონცეფციაზე მრავალძრავიანი პროცესორებისათვის. იგი უზრუნველყოფს ნაკადების პულებს, რომლებიც მართავს სისტემა, გამორიცხავს პროგრამისტს ნაკადების ხელით შექმნას და მართვას:

ძირითადი კომპონენტები:

• დისპეტჩერების რიგები (Dispatch Queues): მონაცემთა სტრუქტურები, რომლებიც ინახავენ სამუშაო ბლოკებს (workItem) შესრულებისთვის. დავალებები შესრულდება დამატების წესით:

  • სერიული რიგები (Serial Queues): ასრულებენ დავალებებს ერთდროულად, დამატების წესით. უზრუნველყოფენ შესრულების წესს და მონაცემთა უსაფრთხოებას, რომლებიც იცვლება მხოლოდ ერთ რიგში:
  • კონკურენტული რიგები (Concurrent Queues): ასრულებენ დავალებებს პარალელურად, იყენებენ სისტემის ხელმისაწვდომ რესურსებს. დასრულების წესს არ გარანტირებს:
    • გლობალური კონკურენტული რიგები (Global Concurrent Queues): უზრუნველყოფს სისტემა სხვადასხვა პრიორიტეტებით (qos): .userInteractive, .userInitiated, .default, .utility, .background.
  • მთავარი რიგი (Main Queue): სპეციალური სერიული რიგი, დაკავშირებულია აპლიკაციის მთავარი ნაკადთან (main thread). გამოიყენება UI-ის განახლებისთვის:

• დავალებების ბლოკები (Work Items): კლოზურები ან ფუნქციები, რომლებიც GCD-ს მიერ იგზავნება შესრულებისთვის:

• დისპეტჩერების ჯგუფები (Dispatch Groups): საშუალებას აძლევს შესრულდეს რამდენიმე რიგზე და მიიღოს შეტყობინება ყველა დავალების დასრულების შემდეგ ჯგუფში:

• დისპეტჩერების სემაფორები (Dispatch Semaphores): მექანიზმი, რომელიც محدودავს ერთდროულად რესურსზე მიმართვიან ნაკადების რაოდენობას, ან სინქრონიზაციას ნაკადებს შორის:

iOS-პროგრამირებაში გამოყენება:

• ასინქრონული დავალებების შესრულება: რესურსის მძიმე ოპერაციების (სერვერული მოთხოვნები, მონაცემთა ბაზის მუშაობა, სურათების დამუშავება) გადატანა მთავარი ნაკადიდან, რათა შეინარჩუნოს UI-ის რეაგირება:

  let queue = DispatchQueue.global(qos: .userInitiated)
  queue.async {
      // მძიმე ოპერაციის შესრულება
      let result = performHeavyCalculation()
  
      DispatchQueue.main.async {
          // UI-ის განახლება მთავარ ნაკადზე
          self.updateUI(with: result)
      }
  }
  

• სინქრონიზაცია:
  • სემაფორების გამოყენება, რათა შეზღუდოს წვდომა გაზიარებულ რესურსებზე:

    let semaphore = DispatchSemaphore(value: 1) // საშუალებას აძლევს 1 ნაკადს წვდომა
    semaphore.wait() // ელოდება, სანამ სემაფორი ხელმისაწვდომი გახდება
    // გაზიარებული რესურსის წვდომა
    semaphore.signal() // სემაფორის განთავისუფლება
    

  • სერიული რიგები მონაცემთა უსაფრთხოების უზრუნველსაყოფად:
• ჯგუფური დავალებების შესრულება: რამდენიმე ასინქრონული დავალების შესრულება და მათი დასრულების მოლოდინი:

  let group = DispatchGroup()
  let concurrentQueue = DispatchQueue.global()
  
  group.enter() // ჯგუფში შესვლა
  concurrentQueue.async {
      // დავალება 1
      print("დავალება 1 დასრულდა")
      group.leave() // ჯგუფიდან გასვლა
  }
  
  group.enter()
  concurrentQueue.async {
      // დავალება 2
      print("დავალება 2 დასრულდა")
      group.leave()
  }
  
  group.notify(queue: .main) {
      // ყველა დავალება ჯგუფში დასრულდა
      print("ყველა დავალება დასრულდა")
  }
  

• გადადებული შესრულება: კოდის შესრულება გარკვეული დროის შემდეგ:

  DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
      // კოდი შესრულდება 2 წამში
      print("გადადებული შესრულება")
  }
  

GCD-ის უპირატესობები:

• გამოყენების სიმარტივე შედარებით ხელით მართვასთან:
• სისტემის მართვადი ნაკადების პული, ოპტიმიზირებული მრავალძრავიანი პროცესორებისთვის:
• რესურსების ეფექტიანი გამოყენება:
• დაკავშირებული პრობლემების თავიდან აცილება, როგორიცაა მდგომარეობის ბრძოლა, взаимоблокировки:

GCD-ის ნაკლოვანებები:

• ნაკლებად მოქნილი, ვიდრე ხელით მართვა ზოგიერთ რთულ სცენარებში:
• მრავალთრედული კოდის დებაგირება შეიძლება იყოს რთული.