---
# System prepended metadata

title: ' iOS interview 4 '
tags: ["\U0001F4BB 면접 질문"]

---

<h1><center> iOS interview 4 </center></h1>

###### tags: `💻 면접 질문`
###### date: `2025-09-2017:21:33.284Z`

> [iOS interview](https://github.com/JeaSungLEE/iOSInterviewquestions)

# Async-await

# Swift Concurrency의 기본 동작 개념

> 그 전에.. Concurrency란? 일반적인 개념, 다른 언어나 플랫폼에서도 통용되는 일반적인...
- '여러 작업을 동시에 다루는 것'
``` gemini
Concurrency (동시성)

하나의 CPU 코어가 여러 작업을 번갈아 가며 실행하는 방식. => gcd, swift concurrency나 이걸 수행한다. 그런데, 작동 방식이 다르다.

예를 들어, 워드 문서를 작성하면서 동시에 음악을 듣는 경우, CPU는 워드 프로세싱과 음악 재생 작업을 매우 짧은 시간 단위로 빠르게 전환하며 실행해요.

동시에 진행되는 '것처럼' 보이는 것이 핵심이에요.
```

작업의 단위를 CPU는 Thread라는 공간에서 처리한다.

1. gcd 어떻게 동작하나?
- Grand Central Dispatch
- GCD -> Async/Await ? Thread Explosion 막기 위함 why? Context Switching 
- GCD -> Thread를 CPU가 가상으로 여러 개를 만들 수 있다.
- 동시성을 제공하기 위해서
- how? 여러 작업들의 발생을 context switching을 이용해서 다른 쓰레드로 넘어가서 cpu가 작업을 한다. 기존에 작업 중이던 쓰레드는?
- 문제점: 1. (내부 Thread에서) context switching이 일어난다. | 2. 기존 작업이던 가상의 쓰레드는 계속 남아있다... => 쓰레드 폭발 | 3. 우선순위가 잘 안 지켜짐

2. swift concurrency는 어떻게 동작하나?
- Swift Concurrency -> CPU당 Thread가 하나만 존재합니다. | **협력적 Thread Pool** <-> **선점형(GCD)**

작업의 비동기 시점이 발생하면 시스템(OS)에 넘긴다. - await

```swift
let task = Task {
    // prevA
    let a = await fn();
    // prevB
    let b = fn2();
    // prevC
    let c = await fn();
}

task.cancel()
// => CPU0 - [prevA]await [....] [a prevB b prevC] await [....] []

let queue = DispatchQueue(label: "queue")

let a = DispatchWorkItem()
let b = DispatchWorkItem()
let c = DispatchWorkItem()

// => Thread0 [prevA]
// => Thread1 ------- [a prevB prevC]     
// => Thread2 -----------------------[c] |

queue.task {
    
}
```

----

## Task와 async-await

- What is Task? → **`“비동기적인 작업 실행 단위를 만드는 것”`**
    - 메타데이터 상속: 이 작업이 어느 쓰레드에서 동작하는지, 우선순위, 로컬 변수
    - TaskLocal https://developer.apple.com/documentation/swift/tasklocal

```swift
enum Example {
    @TaskLocal
    static var traceID: TraceID?
}

func read() -> String {
    if let value = Self.traceID {
        "\(value)" 
    } else { 
        "<no value>"
    }
}


await Example.$traceID.withValue(1234) { // bind the value
  print("traceID: \(Example.traceID)") // traceID: 1234
  read() // traceID: 1234


  async let id = read() // async let child task, traceID: 1234


  await withTaskGroup(of: String.self) { group in 
      group.addTask { read() } // task group child task, traceID: 1234
      return await group.next()!
  }


  Task { // unstructured tasks do inherit task locals by copying
    read() // traceID: 1234
  }


  Task.detached { // detached tasks do not inherit task-local values
    read() // traceID: nil
  }
}
```


```swift
let taskA = Task { @MainActor in
    let a = await fnA();
}
let taskB = Task { @MainActor in
    let b = await fnB();
}
let taskC = Task { @MainActor in
    let c = await fnC();
}

actor A {
    @MainActor
    func a() {
        
    }
}

```

```swift

func A() async {
    print("a")
    print("b")
    
    await B()
}

func B() async {
    print("c")
    print("d")
    
    await C()
}

func C() async {
    print("e")
    print("f")
    
}

func run() async {
    print("run 실행됨")
}


Task { @MainActor in
    A()
}

Task {
    runt()
}

// 출력 a
// 출력 b

```

> 하나의 스레드에서 실행
> [a,b,c] -> [c, b, a] => [b,c,a]

- (실행 완료의 순서 보장이 안된다)

- Task vs Task.detached => 병렬 작업을 해줌 
    - 비구조적 동시성
    - Task: 메타데이터 상속
    - Task.detached: 메타데이터 상속 x

```swift
let parentTask: Task<Void, Error> = Task {
    let taskA = Task {
        print(Task.isCancelled)
        return "Wow"
    }
    
    let taskB: Task<String,Error> = Task {
        print(Task.isCancelled)
        return "Hello"
    }
    
    await [taskA.value, taskB.value]
    
}

parentTask.cancel()

func childrenRun() async {
    print(Task.isCancelled)
}

let asyncTask = Task {
    async let children1 = childrenRun() // 여기서 병렬로 작동함 
    async let children2 = childrenRun() // 여기서 병렬로 작동함
    
    // await children1 // 작동이 이미 다 되었으면 값 넘기고, 아니면 작업 완료된 대로 값 넘김...
    // await children2
    await [children2, children1] // 배열이 채워질 때 까지 기다린다..
}

asyncTask.cancel()

```

- async let vs withTaskGroup => 병렬 작업을 해줌
    - 구조적 동시성
    - 
- What is async-await
    - 작업 순서를 아는 방법?
    - await를 할 때 call stack
- 메타 데이터란 무엇인가?
- Task.detached()
- 스레드 풀

- Task.yield()
    - https://engineering.linecorp.com/ko/blog/about-swift-concurrency-performance
```swift

Task { @MainActor
    for i in 1200000000 {
        if i % 10 == 0 {
            Task.yield()
        }
        print(i)
    }
}

```

### 오늘 한 것과 좀 더 봐야할 것
1. TaskLocal => 바인딩, TCA 개념 - 실제로 쓰는 사례...

### 다음에 할 것

1. ⭐️ **Shared Mutable State**
2. Task isolation
3. Race Condition 문제
4. Sendable
5. actor 개념만...


## Actor / AsyncStream
- AsyncStream?