Asosiy (asosiy) tashqari oqimlar bilan ishlash nima…

iOS-da asosiy (main thread) dan tashqari oqimlar bilan ishlash, UI ning asosiy oqimini bloklamasdan, asinxron vazifalarni bajarishga imkon beradi. Bu, ayniqsa, tarmoq so'rovlar, ma'lumotlarni qayta ishlash yoki fayllar bilan ishlash kabi uzoq davom etadigan operatsiyalarni bajarishda, ilovaning javob beruvchanligini saqlash uchun juda muhim.

Asosiy mexanizmlar quyidagilardan iborat:

GCD (Grand Central Dispatch):

Past darajadagi C-tilida yozilgan kutubxona.
Vazifalar navbatini (DispatchQueue) ishlatadi.
Parallel va ketma-ket navbatlarni yaratishi mumkin.
Global (concurrent) va asosiy oqim (main) uchun navbatlar bilan ishlash imkonini beradi.
Kod bloklarini fon rejimida bajarishda qulay.

// Global navbatda kodni bajarish
DispatchQueue.global(qos: .userInitiated).async {
    // Uzoq davom etadigan vazifa
    print("Vazifa fon oqimida bajarildi")

    // UI ni yangilash uchun asosiy oqimga qaytish
    DispatchQueue.main.async {
        // UI ni yangilash
        print("UI asosiy oqimda yangilandi")
    }
}

Operation Queues (Operation va OperationQueue):

GCD asosida qurilgan yuqori darajadagi abstraktsiya.
Vazifalarni Operation obyekti sifatida taqdim etadi.
Operatsiyalar o'rtasidagi bog'liqliklarni boshqarish, to'xtatish, bekor qilish va qayta boshlash imkonini beradi.
Murakkab vazifalar ketma-ketligini boshqarishda qulay.

import Foundation

class MyOperation: Operation {
    override func main() {
        if self.isCancelled { return }
        // Uzoq davom etadigan vazifa
        print("Operation fon oqimida bajarildi")

        if self.isCancelled { return }
        // UI ni yangilash uchun asosiy oqimga qo'shish
        OperationQueue.main.addOperation {
             print("UI Operation dan yangilandi")
        }
    }
}

// Operation navbatini yaratish
let queue = OperationQueue()
queue.qualityOfService = .userInitiated

// Operatsiyalarni navbatga qo'shish
queue.addOperation(MyOperation())

Async/Await (Concurrency):

Zamonaviy Swift uchun asinxron dasturlash mexanizmi.
async kalit so'zidan foydalanib, asinxron funksiyalarni belgilash va await bilan ularning yakunlanishini kutish.
Asinxron kod yozishni va o'qishni soddalashtiradi, "callback hell" ni oldini oladi.
O'tkazishni avtomatik boshqaradi.

func fetchData() async -> Data? {
    // Tarmoq so'rovini taqlid qilish
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    print("Ma'lumotlar asinxron funksiyada olindi")
    return Data()
}

// Asinxron funksiyani Task ichida chaqirish
Task {
    if let data = await fetchData() {
        print("Ma'lumotlar hajmi: \(data.count)")
        // Avtomatik ravishda mos kontekstda bajariladi (UI yangilash uchun main bo'lishi mumkin)
    }
}

Muhim jihatlar:

Thread Safety: Umumiy resurslarga (o'zgaruvchilar, obyektlar) turli oqimlardan kirishda ehtiyot bo'ling, ma'lumotlar urushlarini oldini olish uchun (data races). Buning uchun blokirovka (locks), navbatlar (seriylashtirish uchun) yoki atomar operatsiyalar ishlatiladi.
UI yangilash: Faqat asosiy oqimda (DispatchQueue.main yoki OperationQueue.main) foydalanuvchi interfeys elementlarini yangilashni amalga oshiring. Fon oqimidan UI ni yangilash harakatlari xatoliklar yoki noaniqlikka olib keladi.
Optimizatsiya: Vazifaga mos mexanizmni tanlang. GCD oddiy asinxron bloklar uchun, Operation Queues murakkab vazifa zanjirlarini boshqarish uchun, Async/Await esa zamonaviy strukturali asinxron kod uchun qulay.
Prioritetlar (QoS): Vazifalar uchun xizmat sifatini (Quality of Service) belgilash, tizimga ularning prioritetlarini to'g'ri boshqarish va resurslarni taqsimlash imkonini beradi.

Mexanizm	Abstraktsiya darajasi	Bog'liqliklarni boshqarish	Bekor qilish/To'xtatish	Foydalanish osonligi
GCD	Past	Yo'q (faqat asosiy)	Qiyin	O'rtacha
Operation Queues	Yuqori	Ha	Oson	O'rtacha/Yuqori
Async/Await	Yuqori	Qisman ichki	Oson (Task)	Yuqori

To'g'ri fon oqimlaridan foydalanish, iOS ilovalarining samarali va javob beradigan bo'lishi uchun juda muhimdir.

Asosiy (asosiy) tashqari oqimlar bilan ishlash nima?