<h1><center> iOS interview 6 </center></h1>

###### tags: `💻 면접 질문`
###### date: `2025-10-0717:21:33.284Z`

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

# Concurrency

### 격리/비격리
- 각 작업이 Task 마다 고유성을 지킨다.
- Actor isolation vs Task isolation
- Task isolation - Task 메타데이터 관련 이야기, **Task.detached**
- 작업간 Share Mutable State를 허용하지 않기 위함
- Actor isolation - 이번에 알아보자...

## Actor
> 액터가 뭐지? 왜 나왔지?

#### 왜 나왔지?
Data race 해결..? => Shared mutable state (공유 가변 상태 -> 여러 곳에서 동시에 수정 가능한 데이터) 문제를 해결하기 위해서
=> 내부 저장 속성의 동시성 문제를 해결하기 위해서

class A { var c: Int = 0 }
let a = A()
Task { a.c = 1 }
Task { a.b = 2 }

> Shared mutable state

#### 매커니즘
1. 하나의 쓰레드에서만 접근을 보장한다 -> 자동 직렬화
2. 공유 가변 상태의 접근을 직렬 실행자(Serial Executor)를 이용해 직렬화시킨다. // 새로 나온 개념
{%preview https://developer.apple.com/documentation/swift/serialexecutor %}

#### 문법적 추가적인 내용
1. 상속이 안됨 - 각각의 타입마다 고유한 쓰레드를 지켜야하니깐... Why??
- (정확한건 아니지만)
- 모든 actor는 자신만의 executor를 가져야 한다..
- 하지만 상속이 되면 자식 객체에서 부모의 property 를 접근하거나 할 때 어떤 executor에서 실행되어야할지 모름..!
- 부모와 자식이 같은 메모리 공간을 공유하는데 executor가 다르게 될 수 있음
2. 힙에 저장되는 참조 타입
3. 프로토콜 채택은 가능하다. + **Actor 프로토콜을 암시적으로 채택한다.**

class Parent {
    let a: Int = 1
    
    init() { }
}

class Child: Parent {
    let b: Int = 2
    
    override init() {
        super.init()
    }
    
    func plusAB() -> Int {
        return a + b;
    }
}
// Child -> Parent(a)
// Child(a)
actor A { } // ??? A : Actor { }

(태현)
자동 직렬화? 동기화? NSLock 같은 걸로 뮤텍스 처리, 세마포어로 동기화를 처리하지 않고 actor를 사용하면 자동으로 직렬화를 보장하게 만들 수 있다?

### actor의 isolation과 nonisolation
> 액터가 외부와 어떻게 통신할지에 대한 내용

기본적으로 액터는 isolation이 지켜진다. -> 액터 외부에서 액터를 접근하려고 하면, 비동기로 접근해야함

actor A {
    nonisolated let idNumber: Int = 0 // (var는 될 수 없다... 공유 가변 상태가 되니깐...)
    nonisolated var computedNumber: Int { 
        get { 3 }
    } // 이건 되려나..? 된다..!
    
    // (안진)
    nonisolated var displayName: String {
        // idNumber가 nonisolated가 아니라면 접근 불가
        // property a는 접근 불가 (왜냐하면 자기 자신을 참조할 수 없다 -> 격리된 값에는 접근 불가)
        // nonisolated 하면 접근 가능
        
        // 변수 접근 시, Actor-isolated property 'a' can not be referenced from a nonisolated context
        return "Actor a \(a)"
    }
    
    var a: Int = 3
    
    var displayName: String { // isolated 한거...
        get async { "내가 보이니..." }
    }
    
    nonisolated func run() async { }
}

// 짤막한 응용
extension A: Hashable {
    nonisolated func hash(into hasher: inout Hasher) { }
}
class Runner {
    let a = A()
    
    func run() async {
        await a.run()
    }
    
    func parellalRun() async {
        await withTaskGroup(of: Void.self) { group in
            for i in 0..<10 {
                group.addTask {
                    await a.run() // nonisolated였으면 어차피 A액터 한 곳에서 run을 처리함
                }
            }
        }
    }
}

=> 하나의 쓰레드(actor A의 쓰레드...)만 run을 실행시킨다.
- 발생 가능한 문제
- 성능상의 문제 발생..! - 병렬 처리가 되지 않음

#### 일반적인 변수 저장 프로퍼티는 안된다... 상수는 됨..!

### 원자성
DB에서 주로 다루는 내용 - 하나의 작업을 쪼갤 수 없는 단위로 시키는 것 - Transaction

> In computer science, "atomic" describes operations that are indivisible, meaning they must complete entirely or not at all, preventing any observable intermediate states.
> 즉, 완전히 완료되거나 전혀 수행되지 않음을 의미

내부 저장 프로퍼티의 한 쓰레드 접근만 보장하는것
Actor를 쓰면 원자성을 보장한다..? 꼭 그렇지만은 않다. 그래서 주의해야할 점이 있다.

actor A {
    
    var a: [Int] = []
    
    /// 원자성이 깨지는 경우
    func run(num: Int) async {
        var copyA = await a; // 여기서 actor A 작업이 멈춤
        //(안진) 혹시 멈추는 것 자체가 중간에 다른 동작이 가능해져서 원자성이 깨지는건가? 아하 이해 완.
        copyA.append(num); // copyA의 값이 a의 값과 달라질 수 있다.
        a = await copyA;
    }
    // [1, 2]
    // -> 1: copyA: [] - [1] | 2: copyA: [] - [2] 
    // result: a -> [1] || [2] 
    
    // 내부는 동기적으로 작업하는게 좋다..! 혹은 그에 상응하는(보장) 처리를 하기
    func atomicRun(num: Int) {
        a.append(num);
    }
}

let a = A()

// 외부에서 Atomic 보장
func addOne(num: Int, a: isolated A) { // 이 함수 스코프가 A actor를 따름
    a.a.append(num) // asnyc-await 없이 동기적으로 원래 해야함...
}
// Task 내부도 isolated가 적용되어있음
Task(isolated...) {
    
}

### 재진입
-> 액터 메서드 내부에서 일시중단 이후 데이터 변경 가능성

// MARK: - Task를 이용힌 재진입

actor TaskImageDownloader {

    enum DownloadState {
        case downloading(task: Task<UIImage, Error>)
        case completed(image: UIImage)
        case failed(error: Error)
    }

    private(set) var cache = [String: DownloadState]()

    func downloadImage(url: String) async -> UIImage {
        if let state = cache[url] {
            return switch state {
            case .downloading(let task):
                return await task.value
            case .completed(let image):
                return image
            case .failed(let error):
                throw error
            }
        }

        let task = Task.detached<UIImage, Error> {
            return await downloadImageFromNetwork(url: url)
        }
        // 다운로드 중인 상태를 저장
        cache[url] = .downloading(task: task)
        do {
            let image = try await task.value
            cache[url] = .completed(image: image)
            return image
        } catch {
            cache[url] = .failed(error: error)
            throw error
        }
        return await task.value
    }

    private func downloadImageFromNetwork(url: String) async throws -> UIImage {
        let (data, response) = try await URLSession.shared.data(from: URL(string: url)!)
        return UIImage(data: data)!
    }
}

### 액터 홉핑
-> 각각 다른 액터간의 접근에서 발생하는 작업전환 오버헤드 -> context switching

> 액터를 많이 사용한다고 능사가 아니다... 비격리여도 괜찮은 것이면 class, nonisolated를 쓰든 context switch를 낮춘다. (액터 홉핑)

특정 객체를 다른 **actor에** 종속시킨다.

@globalActor
actor Aactor {
    static let shared = Aactor()
}

actor Run {
    var aActor: Aactor
}

@Aactor // 글로벌 액터
class Run {
    var aActor: Aactor!
}

### 글로벌 액터

@globalActor | actor를 하나의 객체 뿐만 아니라 전역적으로 채택할 수 있게 해주는 타입
+ 특정 객체, 메서드, 프로퍼티를 특정 Serial Executor에서만 실행시킬 수 있게 만들어준다.

ex) @MainActor

Serial Executor - **하나의 쓰레드로의 작업 보장되는게** 좋은 경우
1. View 렌더링
2. DB Transaction
3. Audio - Node + Node + Node => AudioEngine -> Speaker

#### globalActor 만들기...
@globalActor 프로퍼티 래퍼 채택시, GlobalActor 프로퍼티를 채택함
- 싱글톤 패턴을 적용한다.

@globalActor
actor Aactor {
    static let shared = Aactor()
}

@MainActor // 개꿀...

1. Shared mutate state
2. 어떻게? 단일 쓰레드 접근을 보장해서
3. 그래서 어떤 문제들이..?
- isolate/nonisolated, hoping, reenterency, atomicity, globalActor...

> 흘러들어가다 발견
> https://github.com/swiftlang/swift-evolution/blob/main/proposals/0306-actors.md

# Combine

(쬐금 봄)

- 강의: https://www.inflearn.com/course/combine-reactive-programming

### 다음주

?

Concurrency 마무리 -> iOS 질문 답변 재개
일요일 오전 9시