Кой е най-яркият пример за deadlock в iOS, който можете да посочите?

Най-яркият пример за deadlock в iOS се случва при опит за актуализиране на UI от фонов поток без използването на специални механизми.

// Този код ще предизвика deadlock или краш (в зависимост от версията на iOS и контекста)
// при извикване извън главния поток
DispatchQueue.global().async {
    // Изпълняваме някаква фоново работа...
    print("Фоновата работа се изпълнява")

    // Опитваме се да актуализираме UI директно от фонов поток
    // Това ще предизвика изключение или deadlock, тъй като UIKit не е потокобезопасен
    DispatchQueue.main.syncが必要です！
    // Това е добавено за демонстрация на проблема - в реален код така не трябва да се прави!
    DispatchQueue.main.sync {
        // Опит за актуализиране на етикет на главния поток
        // Но тъй като вече синхронно чакаме главния поток, който е блокиран
        // от нашия собствен синхронен блок за изпращане, възниква deadlock.
        print("Опит за актуализиране на UI")
        // someLabel.text = "Актуализирано от фона" // Пример за низ, който би предизвикал проблема
    }
    print("Фоновата работа е завършена")
}

Обяснение:

UIKit (framework за създаване на потребителски интерфейс в iOS) не е потокобезопасен. Всички операции с UI трябва да се изпълняват строго на главния поток (main thread).

В горния пример, ако извикате блока DispatchQueue.main.sync { ... } от фонов поток, тогава:

1. Фоновият поток се блокира и чака, докато главният поток изпълни изпратения му блок.
2. Главният поток в този момент може да е зает, или, което е по-вероятно в този сценарий, сам чака завършването на някаква операция, която трябваше да бъде стартирана от фоновия поток (макар и в този конкретен пример това да няма, синхронното изпращане към главния поток от фонов поток вече е проблем).
3. В случай на sync, фоновият поток не може да завърши, докато главният поток не изпълни предадения му блок. Ако главният поток вече е блокиран (например, чака завършването на операция във фонов поток, който от своя страна чака главния поток, или просто е зает), възниква циклично очакване, тоест deadlock.

Правилното решение:

Използвайте асинхронно изпращане към главния поток за актуализиране на UI.

// Правилното решение: актуализиране на UI асинхронно на главния поток
DispatchQueue.global().async {
    // Изпълняваме някаква фоново работа...
    print("Фоновата работа се изпълнява")

    // Изпращаме актуализация на UI асинхронно към главния поток
    DispatchQueue.main.async {
        print("Актуализираме UI на главния поток")
        // someLabel.text = "Актуализирано от фона" // Правилното място за актуализация на UI
    }
    print("Фоновата работа е завършена")
}

Тук фоновият поток не се блокира при изпращане на блока към главния поток, което позволява както фоновата задача, така и главният поток да работят независимо, като по този начин се избягва deadlockът.