그랜드 센트럴 디스패치, 원스 앤 포 올

안녕하세요! 저는 키릴 파민이고 iOS 개발자입니다.

이 글에서는 Grand Central Dispatch(GCD)를 한 번에 다룹니다. Swift Modern Concurrency가 존재하기 때문에 GCD가 오래되어 보일 수 있지만, 이 프레임워크를 사용하는 코드는 프로덕션과 인터뷰 모두에서 수년간 계속 등장할 것입니다.

오늘은 GCD의 기본적인 이해에만 집중할 것입니다. 큐와 스레드 간의 관계를 포함하여 멀티스레딩의 핵심 측면만 자세히 살펴볼 것입니다. 이는 다른 많은 기사에서 간과하는 주제입니다. 이러한 개념을 염두에 두면 DispatchGroup , DispatchBarrier , 세마포어, 뮤텍스 등의 주제를 더 쉽게 이해할 수 있습니다.

이 글은 초보자와 숙련된 개발자 모두에게 유용할 것입니다. 기술 용어의 과부하를 피하면서 모든 것을 명확한 언어로 설명하려고 노력할 것입니다.

콘텐츠 개요

• 기본 개념: 스레드, 멀티스레딩, GCD, 작업, 큐
• 큐 유형: 메인, 글로벌, 사용자 정의
• 큐 우선 순위: 서비스 품질(QoS)
• 직렬 및 동시 큐
• 작업 실행 방법: 비동기, 동기
• 이중 자물쇠
• 최대공약수 연습
• 모래밭

기본 개념: 스레드, 멀티스레딩, GCD, 작업 및 큐

스레드 - 본질적으로 시스템 명령어 집합이 배치되고 실행되는 컨테이너입니다. 사실, 모든 실행 코드는 어떤 스레드에서 실행됩니다. 우리는 메인 스레드와 워커 스레드를 구별합니다.

멀티스레딩 - 시스템이 여러 스레드를 동시에(동시에) 실행할 수 있는 능력. 이를 통해 여러 코드 분기를 병렬로 실행할 수 있습니다.

Grand Central Dispatch(GCD) – 스레드 작업을 용이하게 하는 프레임워크(멀티스레딩의 이점 활용). 주요 기본 요소는 작업과 큐입니다.

따라서 GCD는 동시에 실행되는 코드를 쉽게 작성할 수 있는 도구입니다. 간단한 예로, 메인 스레드의 UI 업데이트를 방해하지 않도록 무거운 계산을 별도의 스레드로 오프로드하는 것입니다.

작업 - 개발자가 그룹화한 일련의 지침. 개발자가 특정 작업에 속하는 코드를 결정한다는 것을 이해하는 것이 중요합니다.

예를 들어:

 print(“GCD”) // a task

 let database = Database() let person = Person(age: 23) // also a task database.store(person)

큐 - GCD의 기본 원시 요소로, 개발자가 실행할 작업을 넣는 곳입니다. 큐는 스레드 간에 작업을 분배하는 책임을 맡습니다(각 큐는 시스템의 스레드 풀에 액세스할 수 있음).

기본적으로 큐를 사용하면 스레드를 직접 관리하는 대신 코드를 작업으로 구성하는 데 집중할 수 있습니다. 작업을 큐에 디스패치하면 사용 가능한 스레드에서 실행됩니다. 이는 종종 작업을 디스패치하는 데 사용된 스레드와 다릅니다.

모든 GIF의 mp4 버전을 찾을 수 있습니다 여기 또는 아래의 "링크" 섹션에서.

대기열의 종류

1. 메인 큐 - 메인 스레드에서만 실행되는 큐입니다. 직렬입니다(나중에 자세히 설명).

    let mainQueue = DispatchQueue.main

   
   

2. 글로벌 큐 - 시스템에서 제공하는 5개의 큐(우선순위 레벨당 하나씩)가 있습니다. 이들은 동시적입니다.

    let globalQueue = DispatchQueue.global()

   
   

3. 사용자 정의 대기열 - 개발자가 만든 대기열. 개발자는 5가지 우선순위 중 하나와 유형을 선택합니다. 직렬 또는 동시(기본적으로 직렬).

    let userQueue = DispatchQueue(label: “com.kirylfamin.concurrent”, attributes: .concurrent).

대기열 우선 순위

서비스 품질(QoS) – 큐 우선순위를 위한 시스템입니다. 작업이 큐에 있는 큐의 우선순위가 높을수록 더 많은 리소스가 할당됩니다. 총 5개의 QoS 레벨이 있습니다.

1. .userInteractive – 가장 높은 우선순위. 즉각적인 실행이 필요하지만 메인 스레드에서 실행하기에 적합하지 않은 작업에 사용됩니다. 예를 들어, 실시간 이미지 보정을 허용하는 앱에서 보정 결과는 즉시 계산되어야 합니다. 그러나 메인 스레드에서 수행하면 항상 메인 스레드에서 발생하는 UI 업데이트 및 제스처 처리(예: 사용자가 보정할 영역 위로 손가락을 밀면 앱이 "손가락 아래에" 결과를 즉시 표시해야 함)에 방해가 됩니다. 따라서 메인 스레드에 부담을 주지 않고 가능한 한 빨리 결과를 얻을 수 있습니다.

   
   

2. .userInitiated – 대화형 작업만큼 중요하지는 않지만 빠른 피드백이 필요한 작업에 대한 우선순위입니다. 일반적으로 사용자가 작업이 즉시 완료되지 않고 기다려야 한다는 것을 이해하는 작업(예: 서버 요청)에 사용됩니다.

   
   

3. .default – 표준 우선순위. 개발자가 큐를 생성할 때 QoS를 지정하지 않은 경우 할당됩니다. 즉, 작업에 대한 특정 요구 사항이 없고 컨텍스트에서 우선순위를 결정할 수 없는 경우(예: .userInitiated 우선순위가 있는 큐에서 작업을 호출하는 경우 작업은 해당 우선순위를 상속함).

   
   

4. .utility – 즉각적인 사용자 피드백이 필요하지 않지만 앱 작동에 필요한 작업에 대한 우선순위입니다. 예를 들어, 서버와 데이터를 동기화하거나 디스크에 자동 저장을 쓰는 경우입니다.

   
   

5. .background – 가장 낮은 우선순위. 예를 들어 캐시 정리.

모든 큐는 직렬 큐 또는 동시 큐로 분류됩니다.

• 직렬 큐 - 이름에서 알 수 있듯이, 이것은 작업이 하나씩 실행되는 큐입니다. 즉, 다음 작업은 현재 작업이 끝난 후에만 시작됩니다.

  
  

• 동시 큐 - 이 큐는 작업이 병렬로 실행되도록 합니다. 이전 작업이 완료되었는지 여부와 관계없이 리소스가 할당되는 즉시 새 작업이 시작됩니다. 시작 순서만 보장된다는 점에 유의하세요(이전에 큐에 넣은 작업이 나중 작업보다 먼저 시작됨 ). 완료 순서는 보장되지 않습니다.

  

작업을 실행하는 방법

이제 호출 스레드 에 대한 작업 실행 방법을 논의하고 있다는 점에 유의하는 것이 중요합니다. 즉, 작업을 호출하는 방식은 작업을 큐에 디스패치하는 스레드에서 이벤트가 어떻게 전개되는지 결정합니다.

비동기적으로 ( async )

비동기 호출이란 호출하는 스레드가 차단되지 않은 호출을 말합니다. 즉, 대기열에 넣은 작업이 실행될 때까지 기다리지 않습니다.

 DispatchQueue.main.async { print(“A”) } print(“B”)

이 예제에서 우리는 메인 스레드 에서 메인 큐 에 있는 print("A") 에 작업을 비동기적으로 큐에 넣습니다(이 코드는 특정 큐 안에 있지 않기 때문에 기본적으로 메인 스레드에서 실행됩니다). 따라서 우리는 메인 스레드 에서 작업을 기다리지 않고 즉시 실행을 계속합니다. 이 특정 예제에서 print("A") 작업은 메인 큐 에 큐에 넣은 다음 print("B") 메인 스레드 에서 즉시 실행됩니다. 메인 스레드는 현재 코드를 실행하는 데 바쁘기 때문에(그리고 메인 큐의 작업은 메인 스레드에서만 실행될 수 있음) 현재 작업 print("B") 먼저 완료되고 메인 스레드가 비어 있는 후에야 메인 큐 에 큐에 넣은 작업 print("A") 실행됩니다. 출력은 BA입니다.

 DispatchQueue.global().async { updateData() DispatchQueue.main.async { updateInterface() } Logger.log(.success) } indicateLoading()

1. 우리는 메인 스레드에서 기본 우선순위로 글로벌 큐에 비동기적으로 작업을 추가합니다. 그러면 호출 스레드는 즉시 계속해서 indicateLoading() 호출합니다.

   
   

2. 얼마 후, 시스템은 작업에 필요한 리소스를 할당하고 스레드 풀의 여유 작업자 스레드에서 해당 작업을 실행하고 updateData() 호출됩니다.

   
   

3. updateInterface() 가 포함된 작업은 메인 큐에 비동기적으로 추가됩니다. 즉, 호출하는 작업자 스레드는 완료를 기다리지 않고 계속 진행합니다.

   
   

4. 작업이 비동기적으로 큐에 들어가기 때문에 리소스가 할당될 시기를 확신할 수 없습니다. 이 경우 updateInterface() (메인 스레드에서) 또는 Logger.log(.success) (워커 스레드에서)가 먼저 실행되는지 확실히 말할 수 없습니다(1-2단계에서도 알 수 없음: 먼저 실행되는 것은 메인 스레드의 indicateLoading() 또는 워커 스레드의 updateData() ). 메인 스레드는 UI 업데이트, 제스처 처리 및 기타 기본 작업을 처리하는 데 바쁘지만, 그럼에도 불구하고 항상 최대 시스템 리소스를 받습니다. 반면에 워커 스레드에서 실행하기 위한 리소스는 거의 즉시 할당될 수도 있습니다.

   
   

이 애니메이션에서 글로벌 큐는 일부 자유 작업자 스레드에서 작업을 실행합니다.

동기적으로 ( sync )

동기 호출은 호출하는 스레드가 중지되고 큐에 넣은 작업이 완료될 때까지 기다리는 호출입니다.

 let userQueue = DispatchQueue(label: "com.kirylfamin.serial") DispatchQueue.global().async { var account = BankAccount() userQueue.sync { account.balance += 10 } let balance = account.balance print(balance) }

여기서 글로벌 큐에서 작업을 실행하는 작업자 스레드에서 동기적으로 작업을 사용자 지정 큐에 인큐하여 잔액을 늘립니다. 현재 스레드는 차단되고 인큐된 작업이 완료될 때까지 기다립니다. 따라서 잔액은 사용자 지정 큐의 작업이 증가를 완료한 후에만 인쇄됩니다.

이중 자물쇠

동기 작업의 맥락에서 교착 상태에 대해 논의하는 것이 중요합니다. 교착 상태란 스레드나 스레드가 자신이나 다른 스레드가 진행되기를 무한정 기다리는 상태를 말합니다. 가장 일반적인 예는 메인 스레드 에서 DispatchQueue.main.sync {}를 호출하는 것입니다.

메인 스레드는 현재 작업을 실행하느라 바쁘고, 그 작업 내에서 동기적으로 코드를 실행하고 싶습니다.따라서 동기 호출은 메인 스레드를 차단합니다.작업은 메인 큐 에 대기하지만 메인 스레드가 현재 작업이 완료될 때까지 기다리느라 차단되어 시작할 수 없습니다.그리고 메인 큐 의 작업은 메인 스레드 에서만 실행할 수 있습니다.처음에는 시각화하기 어려울 수 있지만 핵심은 DispatchQueue.main.sync 로 대기열에 넣은 작업이 현재 작업의 일부가 되고 현재 작업 뒤에 대기열에 넣는다는 것을 이해하는 것입니다.결과적으로 스레드는 현재 작업에 의해 점유되어 시작할 수 없는 현재 작업의 일부를 기다립니다.

 func printing() { print(“A”) DispatchQueue.main.sync { print(“B”) } print(“C”) } 

메인 스레드가 차단되었기 때문에 메인 큐의 print("B")가 실행될 수 없습니다 print("B")

최대공약수 연습

이 섹션에서는 지금까지 습득한 모든 지식을 바탕으로 인터뷰에서 마주하게 될 간단한 코드 블록부터 동시 프로그래밍에 대한 이해를 높이는 고급 과제까지 다양한 복잡성의 연습을 논의합니다. 이러한 모든 작업에서 질문은 다음과 같습니다. 콘솔에 무엇이 인쇄될까요?

기본 연습

우리는 보통 난이도의 과제부터 시작할 것입니다. 산출에 불확실성이 거의 없는 과제입니다. 이러한 과제는 면접에서 가장 많이 등장할 가능성이 높습니다. 중요한 것은 시간을 내어 문제를 신중하게 분석하는 것입니다.

과제 1

 print(“A”) DispatchQueue.main.async { print(“B”) } print(“C”)

1. 메인 스레드에서 print("A") 실행됩니다.
2. print("B") 하는 작업은 메인 큐에 비동기적으로 큐에 추가됩니다. 메인 스레드가 바쁘기 때문에 이 작업은 큐에서 기다립니다.
3. 메인 스레드에서 print("C") 실행됩니다.
4. 메인 스레드가 비어 있을 때(이전 작업이 완료된 후 UI 업데이트, 제스처 처리 등과 같이 메인 큐의 작업뿐만 아니라 메인 스레드에서 처리해야 할 다른 이벤트가 있을 수 있음. 더 자세히 알아보려면 RunLoop 에 대해 자세히 읽어보세요) 큐에 있는 작업 print("B") 실행됩니다.

과제 2

 print(“A”) DispatchQueue.main.async { print(“B”) } DispatchQueue.main.async { print(“C”) } print(“D”)

1. 메인 스레드에서 print("A") 실행됩니다.
2. print("B") 하는 작업은 메인 큐에 대기합니다. 메인 스레드가 사용 가능해질 때까지 메인 큐.
3. print("C") 작업은 print("B") 뒤에 대기열에 추가되어 대기합니다.
4. 메인 스레드는 실행을 계속하면서 "D"를 인쇄합니다.
5. 메인 스레드가 사용 가능해지면(다른 RunLoop 작업을 처리한 후), 대기 중인 첫 번째 작업인 print("B") 가 실행됩니다.
6. 메인 스레드가 다시 자유로워지면(다른 RunLoop 작업을 처리한 후. 앞으로는 이 세부 내용은 전체 순서에 영향을 미치지 않으므로 생략하겠습니다.) print("C") 작업이 실행됩니다.

먼저, 몇 가지 예에서 설명을 약간 단순화하고, 나중에 논의할 동기 호출의 실행을 시스템이 최적화한다는 사실을 생략하겠습니다.

과제 3

 print(“A”) DispatchQueue.main.async { // 1 print(“B”) DispatchQueue.main.async { print(“C”) } DispatchQueue.global().sync { print(“D”) } DispatchQueue.main.sync { // 2 print(“E”) } } // 3 print(“F”) DispatchQueue.main.async { print(“G”) }

1. print("A") 메인 스레드에서 실행됩니다.
2. 비동기 작업(1~3으로 표시)은 현재(메인) 스레드를 차단하지 않고 메인 큐에 추가됩니다.
3. 메인 스레드는 실행을 계속하면서 "F" 출력합니다.
4. print("G") 작업은 이전 작업(1~3단계) 뒤에 메인 큐에 추가됩니다.
5. 메인 스레드가 자유로워지면 첫 번째 대기 작업 print("B") 실행을 시작합니다.
6. 그런 다음 print("C") 연산은 메인 큐에 대기열에 추가됩니다(현재 작업이 아직 실행 중이고 print("G") 큐에서 그 뒤에 옵니다). 비동기적으로 추가되므로 실행을 기다리지 않고 바로 넘어갑니다.
7. 다음으로, print("D") 연산이 글로벌 큐에 대기합니다. 이 호출은 동기적이므로, 진행하기 전에 글로벌 큐가 이를 실행할 때까지 기다립니다(사용 가능한 모든 워커 스레드에서 실행될 수 있음).
8. 마지막으로, print("E") 연산이 메인 큐에 대기합니다. 이 호출은 동기적이므로 현재 스레드는 작업이 완료될 때까지 차단되어야 합니다. 그러나 메인 큐에 이미 작업이 있고, print("E") 연산은 그 뒤에 끝에 추가됩니다. 따라서 이러한 연산은 print("E") 실행하기 전에 먼저 실행되어야 합니다. 그러나 메인 스레드는 여전히 현재 연산을 실행 중이므로 다음 대기 연산으로 넘어갈 수 없습니다. 현재 연산 뒤에 "G" 와 "C" 인쇄하기 위한 연산이 없더라도 현재 연산(1~3단계)이 아직 완료되지 않았기 때문에 스레드는 계속 진행할 수 없습니다.

• 호출이 비동기적이었다면 print("E") 작업은 단순히 "G" 와 "C" 인쇄하는 작업 뒤에 대기열에 추가됩니다.

과제 4

 let serialQueue = DispatchQueue(label: “com.kirylfamin.serial”) serialQueue.async { // 1 print(“A”) serialQueue.sync { print(“B”) } print(“C”) } // 2

1. 
   

   작업(1~2단계)은 사용자 정의 직렬 대기열에 비동기적으로 대기열에 추가됩니다(기본적으로 대기열은 .concurrent 속성을 사용하지 않았기 때문에 직렬입니다).

2. 시스템이 리소스를 할당하면 실행이 시작되고 "A" 가 인쇄됩니다.
3. 동일한 직렬 큐 내에서 print("B") 에 대한 동기 작업이 큐에 추가됩니다. 호출이 동기적이므로 스레드는 실행을 기다리며 차단됩니다.
4. 그러나 큐가 직렬이고 여전히 외부 작업 1-2로 바쁘기 때문에 print("B") 작업을 시작할 수 없어 교착 상태가 발생합니다.

과제 5

이전 작업의 직렬 대기열을 동시 대기열로 바꿔 보겠습니다.

 DispatchQueue.global().async { // 1 print("A") DispatchQueue.global().sync { print("B") } print("C") } // 2

1. 작업(1~2단계)은 글로벌(동시) 큐에 비동기적으로 추가됩니다.
2. 리소스가 할당되면 실행이 시작되고 "A" 인쇄됩니다.
3. 동일한 글로벌 큐에서 print("B") 실행하는 동기 호출이 이루어지며, 작업이 완료될 때까지 현재 작업자 스레드가 차단됩니다.
4. 이 경우, 스레드가 차단되어 있더라도 글로벌 큐는 동시적이기 때문에 현재 작업이 완료될 때까지 기다리지 않고 다음 작업을 실행하기 시작할 수 있습니다. 간단히 다른 스레드에서 실행하면 됩니다. 따라서 호출 스레드는 다른 워커 스레드에서 print("B") 작업이 실행될 때까지 기다립니다.
5. 작업이 완료되면 초기 호출 스레드가 차단 해제되고 "C" 출력됩니다.

과제 6

 print("A") DispatchQueue.main.async { // 1 print("B") DispatchQueue.main.async { // 2 print("C") DispatchQueue.main.async { // 3 print("D") DispatchQueue.main.sync { print("E") } } // 4 } // 5 DispatchQueue.global().sync { // 6 print("F") DispatchQueue.global().sync { print("G") } } // 7 print("H") } // 8 print("I")

1. 메인 스레드는 "A" 인쇄합니다.

2. 비동기 작업(1~8단계)은 현재 스레드를 차단하지 않고 메인 큐에 추가됩니다.

3. 메인 스레드는 계속되어 "I" 인쇄합니다.

4. 나중에 메인 스레드가 자유로워지면 메인 큐에 추가된 작업이 실행을 시작하고 "B" 를 인쇄합니다.

5. 또 다른 비동기 작업(2~5단계)은 현재 스레드를 차단하지 않고 메인 큐에 대기열에 추가됩니다.

6. 현재 스레드에서 실행을 계속하면서 작업 6~7을 글로벌 큐에 동기적으로 전송합니다. 이렇게 하면 작업이 완료될 때까지 현재(기본) 스레드가 차단됩니다.

7. 작업 6~7은 다른 스레드에서 실행을 시작하여 "F" 인쇄합니다.

8. print("G") 하는 작업은 전역 큐에 동기적으로 전송되어 현재 작업자 스레드가 완료될 때까지 차단됩니다.

9. "G" 가 인쇄되고, 이 작업이 전송된 작업자 스레드가 차단 해제됩니다.

10. 작업 6~7이 완료되고, 해당 작업이 전송된 스레드(메인 스레드)의 차단이 해제되고 "H" 출력됩니다.

11. 작업 1-2가 완료되면 실행은 메인 큐의 다음 작업인 작업 2-5로 이동하며, 이 작업이 시작되고 "C" 가 인쇄됩니다.

12. 작업 3~4는 스레드를 차단하지 않고 메인 큐에 추가됩니다.

13. 현재 작업(2-5)이 완료되면 다음 작업(3-4)이 실행되어 "D" 가 인쇄됩니다.

14. print("G") 하는 작업은 메인 큐에 동기적으로 전송되어 현재 스레드를 차단합니다.

15. 그런 다음 시스템은 메인 스레드에서 작업이 실행될 때까지 무기한 기다립니다 print("E") 스레드가 차단되었기 때문에 교착 상태가 발생합니다.

    
    

중급 연습

중간 난이도의 과제에는 불확실성이 수반됩니다. 이러한 문제는 인터뷰에서도 발생하지만 드물게 발생합니다.

과제 7

 DispatchQueue.global().async { print("A") } DispatchQueue.global().async { print("B") }

1. print("A") 현재 스레드를 차단하지 않고 글로벌 큐에 비동기적으로 추가됩니다.
2. 우리는 시스템이 글로벌 큐에 있는 작업에 대한 리소스를 할당할 때까지 기다립니다. 이론적으로, 이는 다음 명령을 실행하여 print("B") 큐에 넣기 전에도 언제든지 발생할 수 있습니다. 이 특정한 경우, 다음 작업이 먼저 큐에 추가되고, 그런 다음에야 글로벌 큐에 리소스가 할당됩니다. 이는 메인 스레드에 가장 많은 리소스가 할당되고, 메인 스레드의 다음 작업이 매우 가볍고(단순히 작업을 추가하는 작업) 실제로는 글로벌 큐의 리소스 할당보다 더 빠르게 발생하기 때문입니다. 다음 섹션에서 반대 시나리오에 대해 논의하겠습니다.
3. print("B") 가 글로벌 큐에 추가됩니다.
4. 글로벌 큐가 리소스 할당을 기다리는 동안 메인 스레드는 계속 진행됩니다.
5. 리소스가 사용 가능해지면 두 작업이 모두 실행됩니다. "A" 인쇄하는 작업이 "B" 보다 일찍 시작될 수 있지만, print가 원자적 작업이 아니기 때문에 순서를 보장할 수 없습니다(콘솔에 출력이 나타나는 순간이 작업의 끝 부분임).

괄호는 글자가 AB 또는 BA와 같이 어떤 순서로든 나타날 수 있음을 나타냅니다.

과제 8

 print("A") DispatchQueue.main.async { print("B") } DispatchQueue.global().async { print("C") }

여기서 우리는 "A"가 먼저 인쇄된다는 것만 확신할 수 있습니다. 메인 큐의 작업이나 글로벌 큐의 작업이 더 빨리 실행되는지 정확히 판단할 수 없습니다.

과제 9

 DispatchQueue.global(qos: .userInteractive).async { print(“A”) } DispatchQueue.main.async { // 1 print(“B”) }

그리고

 DispatchQueue.global(qos: .userInteractive).async { print(“A”) } print(“B”) // 1

한편, 두 경우 모두 print("B") 메인 스레드에서 실행됩니다. 또한 글로벌 큐에 리소스가 할당되는 시점을 정확히 알 수 없으므로 이론적으로 "A" 메인 스레드에서 // 1로 표시된 지점에 도달하기 직전에 인쇄될 수 있습니다. 그러나 실제로는 첫 번째 작업은 항상 AB로 인쇄되고 두 번째 작업은 BA로 인쇄됩니다. 이는 첫 번째 경우에 print("B") 최소한 메인 스레드의 다음 RunLoop 반복(또는 몇 번의 반복 후)에서 실행되는 반면 두 번째 경우에 print("B") 는 메인 스레드의 현재 RunLoop 반복에서 실행되도록 예약되기 때문입니다. 그러나 순서를 보장할 수는 없습니다.

과제 10

 print("A") DispatchQueue.global().async { print("B") DispatchQueue.global().async { print("C") } print("D") }

출력의 시작이 "AB" 인 것은 분명합니다. print("C") 큐에 넣은 후에는 리소스가 언제 할당될지 정확히 알 수 없습니다. 이 작업은 print("D") 전이나 후에 실행될 수 있습니다. 이는 실제로도 가끔 발생합니다.

과제 11

 let serialQueue = DispatchQueue(label: “com.kirylfamin.serial”, qos: .userInteractive) DispatchQueue.main.async { print(“A”) serialQueue.async { print(“B”) } print(“C”) }

다시 말하지만, 우리는 사용자 정의 대기열에서 print("B")에 리소스가 언제 할당될지 정확히 결정할 수 없습니다. 실제로 메인 스레드에 가장 높은 우선순위가 주어지기 때문에 "C"는 보통 "B"보다 먼저 인쇄되지만 이는 보장되지 않습니다.

과제 12

 DispatchQueue.global().async { print("A") } print("B") sleep(1) print("C")

여기서 출력은 BAC가 될 것이 분명합니다. 1초 sleep은 글로벌 큐가 리소스를 할당할 충분한 시간을 갖도록 보장하기 때문입니다. 메인 스레드가 sleep에 의해 차단되는 동안(프로덕션에서는 해서는 안 되는 일), print("A") 다른 스레드에서 실행됩니다.

과제 13

 DispatchQueue.main.async { print("A") } print("B") sleep(1) print("C")

이 경우, print("A") 메인 큐에 대기열에 들어가므로 메인 스레드에서만 실행할 수 있습니다. 그러나 메인 스레드는 코드를 계속 실행합니다. "B" 인쇄한 다음, sleep하고, "C" 인쇄합니다. 그런 다음에야 RunLoop가 대기열에 들어간 작업을 실행할 수 있습니다.

고급 작업

인터뷰에서 이런 문제에 부딪힐 가능성은 낮지만, 이를 이해하면 최대공약수를 더 잘 이해하는 데 도움이 될 것입니다.

 final class Counter { var count = 0 }

과제 14

 let counter = Counter() DispatchQueue.global().async { DispatchQueue.main.async { print(counter.count) } for _ in (0..<100) { // 1 counter.count += 1 } }

여기서는 메인 스레드가 얼마나 바쁜지에 따라 0에서 100 사이의 숫자가 인쇄될 수 있습니다. 아시다시피, 비동기 작업이 리소스를 얻는 정확한 시점을 예측할 수 없습니다. 워커 스레드의 루프 전, 중 또는 후에 발생할 수 있습니다.

과제 15

 DispatchQueue.global(qos: .userInitiated).async { print(“A”) } DispatchQueue.global(qos: .userInteractive).async { print(“B”) }

QoS는 우선순위가 더 높은 큐가 리소스를 더 빨리 수신할 것이라고 보장하지 않지만 iOS는 그렇게 하려고 시도할 것입니다. 실제로 여기의 출력은 (AB)입니다.

과제 16

 var count = 0 DispatchQueue.global(qos: . userInitiated).async { for _ in 0..<1000 { count += 1 } print(“A”) } DispatchQueue.global(qos: .userInteractive).async { for _ in 0..<1000 { count += 1 } print(“B”) }

어떤 실행이 먼저 시작되는지 알 수 없으므로, 1000개의 작업에 걸쳐서도 어느 작업이 더 빨리 완료되는지 판단할 수 없습니다.

과제 16.2

작업이 동시에 실행된다고 가정하면 출력은 어떻게 될까요?

.userInteractive 대기열에 더 많은 리소스가 할당되므로 1000개의 작업 범위에 걸쳐 해당 대기열의 실행은 항상 더 빨리 완료됩니다.

과제 17

비슷한 접근 방식을 사용하면 이전 섹션의 불확실성이 있는 모든 작업을 수정할 수 있습니다(예: 작업 12):

 let counter = Counter() let serialQueue = DispatchQueue(label: “com.kirylfamin.serial”, qos: .userInteractive) DispatchQueue.main.async { serialQueue.async { print(counter.count) } for _ in 0..<100 { counter.count += 1 } }

0과 100 사이의 모든 숫자를 출력할 수 있습니다. 0을 출력할 수 있다는 사실은 작업 12에서 "C" 의 출력이 항상 "B" 보다 먼저 발생한다는 것을 보장할 수 없다는 것을 확인합니다. 기본적으로 아무것도 변경되지 않았기 때문입니다. 루프가 print보다 약간 더 많은 리소스를 소모한다는 것만 다릅니다(실행 전에 루프를 시작하는 것만으로 실제로는 완전한 불확실성이 발생했음에 유의하세요).

정답 : 0-100

과제 18

 DispatchQueue.global(qos: .userInitiated).async { print(“A”) } print(“B”) DispatchQueue.global(qos: .userInteractive).async { print(“C”) }

비슷한 상황이 여기서 발생합니다. 이론적으로 print("A") print("B") 보다 더 빨리 실행될 수 있습니다( print("B") 약간 더 무거운 것으로 대체하는 경우). 실제로는 "B" 항상 먼저 인쇄됩니다. 그러나 print("C") print("B") 실행한다는 사실은 "A" "C" 보다 먼저 인쇄될 가능성을 크게 높입니다. 메인 스레드에서 print("B") 에 소요된 추가 시간이 종종 .userInitiated 큐가 리소스를 가져와 print("A") 실행하기에 충분하기 때문입니다. 그럼에도 불구하고 이는 보장되지 않으며 때로는 "C" 더 빨리 인쇄될 수 있습니다. 따라서 이론적으로는 완전한 불확실성이 있지만 실제로는 B(CA)가 되는 경향이 있습니다.

과제 19

 DispatchQueue.global().sync { print(Thread.current) }

동기화 상태에 대한 설명서 :

"성능 최적화를 위해 이 함수는 가능한 한 현재 스레드에서 블록을 실행하지만, 한 가지 예외가 있습니다. 메인 디스패치 큐에 제출된 블록은 항상 메인 스레드에서 실행됩니다."

이는 최적화 목적으로 동기 호출이 호출된 동일한 스레드에서 실행될 수 있음을 의미합니다( main.sync 는 예외입니다. 이를 사용하는 작업은 항상 메인 스레드에서 실행됩니다). 따라서 현재(메인) 스레드가 인쇄됩니다.

과제 20

 DispatchQueue.global().sync { // 1 print(“A”) DispatchQueue.main.sync { print(“B”) } print(“C”) }

교착 상태가 발생했기 때문에 "A" 만 인쇄됩니다. 최적화로 인해 작업(라벨 1)이 메인 스레드에서 실행되기 시작하고, 그런 다음 main.sync 호출하면 교착 상태가 발생합니다.

과제 21

 DispatchQueue.main.async { print("A") DispatchQueue.global().sync { print("B") } print("C") }

최적화로 인해 print("B") 작업이 큐에 들어가지 않고 현재 실행 스레드에 "스플라이스"됩니다. 따라서 코드는 다음과 같습니다.

 DispatchQueue.global().sync { print("B") }

다음과 동등해집니다:

 print(“B”)

이러한 작업을 통해 main.sync를 매우 신중하게 사용해야 한다는 것이 분명해졌습니다. 즉, 호출이 메인 스레드에서 이루어지지 않는 것이 확실한 경우에만 사용해야 합니다.

결론

이 글에서는 iOS의 멀티스레딩의 기본 개념인 스레드, 작업, 큐와 그 상호 관계에 초점을 맞추었습니다. GCD가 메인, 글로벌, 사용자 지정 큐에서 작업 실행을 관리하는 방법을 살펴보고 직렬 실행과 동시 실행의 차이점을 논의했습니다. 또한 동기(sync) 및 비동기(async) 작업 디스패치의 중요한 차이점을 살펴보고 이러한 접근 방식이 코드 실행의 순서와 타이밍에 어떤 영향을 미치는지 강조했습니다. 이러한 기본 개념을 숙지하는 것은 반응성 있고 안정적인 애플리케이션을 구축하고 교착 상태와 같은 일반적인 함정을 피하는 데 필수적입니다.

이 글에서 유용한 것을 찾으셨기를 바랍니다. 불분명한 점이 있으면 Telegram: @kfamyn 에서 무료 설명을 위해 저에게 연락하세요.

관련 링크

1. 모든 애니메이션이 있는 YouTube 채널 - https://www.youtube.com/@kirylfamin
2. 전체 연습 코드 - https://github.com/kfamyn/GCD-Tasks
3. 내 텔레그램 - http://t.me/kfamyn
4. 런루프 - https://developer.apple.com/documentation/foundation/runloop
5. sync 방법 설명서 - https://developer.apple.com/documentation/dispatch/dispatchqueue/sync(execute:)-3segw