์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ Swift ๋™์‹œ์„ฑ ์™„์ „์ •๋ณต: async/await & Actor๋กœ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ

๐Ÿš€ Swift ๋™์‹œ์„ฑ ์™„์ „์ •๋ณต: async/await & Actor๋กœ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋งˆ์Šคํ„ฐํ•˜๊ธฐ

์นœ๊ตฌ์ฒ˜๋Ÿผ ์‰ฝ๊ฒŒ ๋ฐฐ์šฐ๋Š” ํ˜„๋Œ€์  ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋ชจ๋“  ๊ฒƒ โœจ

๐ŸŽฏ ์™œ ๊ฐ‘์ž๊ธฐ async/await๊ฐ€ ํ•„์š”ํ•ด์กŒ์„๊นŒ?

์•ผ, ์†”์งํžˆ ๋งํ•ด์„œ ์˜ˆ์ „ Swift๋กœ ๋น„๋™๊ธฐ ์ฝ”๋“œ ์งค ๋•Œ ์ง„์งœ ๋จธ๋ฆฌ ์•„ํŒ ์ž–์•„? ๐Ÿ˜…
์ฝœ๋ฐฑ ์ง€์˜ฅ(Callback Hell)์— ๋น ์ ธ์„œ ์ฝ”๋“œ๊ฐ€ ํ”ผ๋ผ๋ฏธ๋“œ์ฒ˜๋Ÿผ ์Œ“์ด๊ณ , DispatchQueue ์ด๊ฒƒ์ €๊ฒƒ ์‹ ๊ฒฝ ์“ฐ๋А๋ผ ์ •์ž‘ ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง์€ ๋’ท์ „์ด์—ˆ๋˜ ๊ทธ ์‹œ์ ˆ...

Swift 5.5๋ถ€ํ„ฐ ๋“ฑ์žฅํ•œ async/await์™€ Actor๋Š” ๊ทธ์•ผ๋ง๋กœ ๊ฒŒ์ž„ ์ฒด์ธ์ €์•ผ.
์• ํ”Œ์ด "์ด์ œ ๋น„๋™๊ธฐ ์ฝ”๋“œ๋„ ๋™๊ธฐ ์ฝ”๋“œ์ฒ˜๋Ÿผ ์‰ฝ๊ฒŒ ์“ฐ์ž!"๋ผ๊ณ  ์„ ์–ธํ•œ ๊ฑฐ์ง€.

์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ Swift ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ฑฐ๋‚˜ ๋ฐฐ์šธ ๋•Œ๋„, ์ด ๋™์‹œ์„ฑ ๋ชจ๋ธ์€ ์ด์ œ ํ•„์ˆ˜ ์Šคํ‚ฌ์ด ๋์–ด.
์™œ๋ƒ๋ฉด ํ˜„๋Œ€ ์•ฑ์€ ๋„คํŠธ์›Œํฌ ํ†ต์‹ , ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ ‘๊ทผ, ์ด๋ฏธ์ง€ ์ฒ˜๋ฆฌ ๋“ฑ ๋น„๋™๊ธฐ ์ž‘์—… ์—†์ด๋Š” ์ ˆ๋Œ€ ๋งŒ๋“ค ์ˆ˜ ์—†๊ฑฐ๋“ ! ๐Ÿ’ช

๐Ÿ” ์ด ๊ธ€์—์„œ ๋ฐฐ์šธ ํ•ต์‹ฌ ๋‚ด์šฉ
  • โœ… async/await์˜ ๊ธฐ๋ณธ ๊ฐœ๋…๊ณผ ์‹ค์ „ ํ™œ์šฉ๋ฒ•
  • โœ… Task์™€ TaskGroup์œผ๋กœ ๋™์‹œ์„ฑ ์ œ์–ดํ•˜๊ธฐ
  • โœ… Actor๋ฅผ ํ†ตํ•œ ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค ๋ฐฉ์ง€
  • โœ… Sendable ํ”„๋กœํ† ์ฝœ๊ณผ ์•ˆ์ „ํ•œ ๋ฐ์ดํ„ฐ ์ „๋‹ฌ
  • โœ… MainActor์™€ UI ์—…๋ฐ์ดํŠธ ํŒจํ„ด
  • โœ… ์‹ค๋ฌด์—์„œ ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ํ•จ์ •๊ณผ ํ•ด๊ฒฐ์ฑ…
๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์ง„ํ™” ๊ณผ๊ฑฐ: ์ฝœ๋ฐฑ ์ง€์˜ฅ fetchData { result in processData(result) { data in saveData(data) { success in updateUI { _ in // ํ”ผ๋ผ๋ฏธ๋“œ ํ˜•์„ฑ } } } } ๐Ÿ˜ฑ ๋ณต์žกํ•˜๊ณ  ์—๋Ÿฌ์ฒ˜๋ฆฌ ์–ด๋ ค์›€ ํ˜„์žฌ: async/await let result = await fetchData() let data = await processData(result) let success = await saveData(data) await updateUI() โœจ ๊น”๋”ํ•˜๊ณ  ์ง๊ด€์  ๋™๊ธฐ ์ฝ”๋“œ์ฒ˜๋Ÿผ ์ฝํž˜ ์—๋Ÿฌ ์ฒ˜๋ฆฌ๋„ try-catch๋กœ ๊ฐ„๋‹จ ์ง„ํ™”!

๐ŸŒŸ async/await ๊ธฐ๋ณธ๊ธฐ ๋‹ค์ง€๊ธฐ

์ž, ์ด์ œ ๋ณธ๊ฒฉ์ ์œผ๋กœ ๋“ค์–ด๊ฐ€๋ณด์ž!
async/await๋Š” ์‚ฌ์‹ค ๋‘ ๊ฐœ์˜ ํ‚ค์›Œ๋“œ๊ฐ€ ์ง๊ฟ์ฒ˜๋Ÿผ ์›€์ง์ด๋Š” ๊ฑฐ์•ผ.

async๋Š” "์ด ํ•จ์ˆ˜๋Š” ๋น„๋™๊ธฐ๋กœ ๋™์ž‘ํ•ด์š”!"๋ผ๊ณ  ์„ ์–ธํ•˜๋Š” ๊ฑฐ๊ณ ,
await๋Š” "์—ฌ๊ธฐ์„œ ๊ฒฐ๊ณผ๊ฐ€ ์˜ฌ ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ฆด๊ฒŒ์š”!"๋ผ๊ณ  ๋งํ•˜๋Š” ๊ฑฐ์ง€.

๊ทผ๋ฐ ์ค‘์š”ํ•œ ๊ฑด, await๋ฅผ ์“ด๋‹ค๊ณ  ํ•ด์„œ ์Šค๋ ˆ๋“œ๊ฐ€ ๋ธ”๋กœํ‚น๋˜๋Š” ๊ฒŒ ์•„๋‹ˆ๋ผ๋Š” ์ ! ๐ŸŽฏ
์‹œ์Šคํ…œ์ด ์•Œ์•„์„œ ๋‹ค๋ฅธ ์ž‘์—…์„ ์ฒ˜๋ฆฌํ•˜๋‹ค๊ฐ€, ๊ฒฐ๊ณผ๊ฐ€ ์ค€๋น„๋˜๋ฉด ๋‹ค์‹œ ๋Œ์•„์™€์„œ ์ด์–ด์„œ ์‹คํ–‰ํ•ด์ค˜.

๐Ÿ“ ๊ธฐ๋ณธ ๋ฌธ๋ฒ• ๊ตฌ์กฐ

// async ํ•จ์ˆ˜ ์„ ์–ธ
func fetchUserData(id: String) async throws -> User {
    // ๋„คํŠธ์›Œํฌ ์š”์ฒญ ๋“ฑ ๋น„๋™๊ธฐ ์ž‘์—…
    let response = await URLSession.shared.data(from: url)
    let user = try JSONDecoder().decode(User.self, from: response.0)
    return user
}

// async ํ•จ์ˆ˜ ํ˜ธ์ถœ
Task {
    do {
        let user = await fetchUserData(id: "12345")
        print("์‚ฌ์šฉ์ž ์ด๋ฆ„: \(user.name)")
    } catch {
        print("์—๋Ÿฌ ๋ฐœ์ƒ: \(error)")
    }
}
๐Ÿ’ก ์ดˆ๋ณด์ž ํŒ
async ํ•จ์ˆ˜๋Š” ๋ฐ˜๋“œ์‹œ async ์ปจํ…์ŠคํŠธ ์•ˆ์—์„œ๋งŒ ํ˜ธ์ถœํ•  ์ˆ˜ ์žˆ์–ด!
์ผ๋ฐ˜ ๋™๊ธฐ ํ•จ์ˆ˜์—์„œ ๋ฐ”๋กœ ํ˜ธ์ถœํ•˜๋ ค๊ณ  ํ•˜๋ฉด ์ปดํŒŒ์ผ ์—๋Ÿฌ๊ฐ€ ๋‚˜.
๊ทธ๋ž˜์„œ Task { } ๋ธ”๋ก์œผ๋กœ ๊ฐ์‹ธ๊ฑฐ๋‚˜, ๋‹ค๋ฅธ async ํ•จ์ˆ˜ ์•ˆ์—์„œ ํ˜ธ์ถœํ•ด์•ผ ํ•ด.

๐Ÿ”„ async let์œผ๋กœ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌํ•˜๊ธฐ

์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋น„๋™๊ธฐ ์ž‘์—…์„ ๋™์‹œ์— ์‹คํ–‰ํ•˜๊ณ  ์‹ถ์„ ๋•Œ๊ฐ€ ์žˆ์ž–์•„?
์˜ˆ๋ฅผ ๋“ค์–ด, ์‚ฌ์šฉ์ž ์ •๋ณด๋ž‘ ๊ฒŒ์‹œ๊ธ€ ๋ชฉ๋ก์„ ๋™์‹œ์— ๊ฐ€์ ธ์˜จ๋‹ค๋“ ์ง€...

์ด๋Ÿด ๋•Œ async let์„ ์“ฐ๋ฉด ์ง„์งœ ํŽธํ•ด! ๐Ÿš€

func loadDashboard() async throws -> Dashboard {
    // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰๋จ (๋А๋ฆผ!)
    let user = await fetchUser()
    let posts = await fetchPosts()
    let notifications = await fetchNotifications()
    
    // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋ณ‘๋ ฌ๋กœ ์‹คํ–‰๋จ (๋น ๋ฆ„!)
    async let user = fetchUser()
    async let posts = fetchPosts()
    async let notifications = fetchNotifications()
    
    // ๋ชจ๋“  ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋‹ค๋ฆผ
    return try await Dashboard(
        user: user,
        posts: posts,
        notifications: notifications
    )
}

์œ„ ์ฝ”๋“œ์—์„œ async let์„ ์“ด ๋ฒ„์ „์€ ์„ธ ๊ฐœ์˜ ์š”์ฒญ์ด ๊ฑฐ์˜ ๋™์‹œ์— ๋‚ ์•„๊ฐ€.
๊ทธ๋ž˜์„œ ์ „์ฒด ์‹คํ–‰ ์‹œ๊ฐ„์ด ๊ฐ€์žฅ ์˜ค๋ž˜ ๊ฑธ๋ฆฌ๋Š” ํ•˜๋‚˜์˜ ์š”์ฒญ ์‹œ๊ฐ„๋งŒํผ๋งŒ ๊ฑธ๋ฆฌ๋Š” ๊ฑฐ์ง€!
์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰ํ•˜๋ฉด ์„ธ ๊ฐœ์˜ ์‹œ๊ฐ„์„ ๋‹ค ๋”ํ•œ ๋งŒํผ ๊ฑธ๋ฆฌ๊ณ  ๋ง์ด์•ผ. โฑ๏ธ

๐ŸŽญ Task: ๋น„๋™๊ธฐ ์ž‘์—…์˜ ๊ธฐ๋ณธ ๋‹จ์œ„

Task๋Š” Swift ๋™์‹œ์„ฑ ๋ชจ๋ธ์˜ ํ•ต์‹ฌ์ด์•ผ.
๋น„๋™๊ธฐ ์ž‘์—…์„ ์‹คํ–‰ํ•˜๋Š” ๋…๋ฆฝ์ ์ธ ๋‹จ์œ„๋ผ๊ณ  ๋ณด๋ฉด ๋ผ.

Task๋ฅผ ๋งŒ๋“ค๋ฉด ์‹œ์Šคํ…œ์ด ์•Œ์•„์„œ ์ ์ ˆํ•œ ์Šค๋ ˆ๋“œ์—์„œ ์‹คํ–‰์‹œ์ผœ์ฃผ๊ณ ,
์šฐ๋ฆฌ๋Š” ๊ทธ๋ƒฅ ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง์—๋งŒ ์ง‘์ค‘ํ•˜๋ฉด ๋˜๋Š” ๊ฑฐ์ง€! ๐ŸŽฏ

๐Ÿƒ Task ์ƒ์„ฑ๊ณผ ์‹คํ–‰

// ๊ธฐ๋ณธ Task ์ƒ์„ฑ
let task = Task {
    let result = await someAsyncFunction()
    return result
}

// Task ๊ฒฐ๊ณผ ๊ธฐ๋‹ค๋ฆฌ๊ธฐ
let value = await task.value

// Task ์ทจ์†Œํ•˜๊ธฐ
task.cancel()

// Task๊ฐ€ ์ทจ์†Œ๋๋Š”์ง€ ํ™•์ธ
if Task.isCancelled {
    print("์ž‘์—…์ด ์ทจ์†Œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค")
    return
}
๐ŸŽช Task์˜ ์šฐ์„ ์ˆœ์œ„
Task๋ฅผ ๋งŒ๋“ค ๋•Œ ์šฐ์„ ์ˆœ์œ„๋ฅผ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์–ด:

โ€ข .high: ์‚ฌ์šฉ์ž ์ธํ„ฐ๋ž™์…˜ ๊ด€๋ จ (๋ฒ„ํŠผ ํด๋ฆญ ๋“ฑ)
โ€ข .medium: ์ผ๋ฐ˜์ ์ธ ์ž‘์—… (๊ธฐ๋ณธ๊ฐ’)
โ€ข .low: ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—… (๋กœ๊ทธ ์ €์žฅ ๋“ฑ)
โ€ข .background: ๊ธ‰ํ•˜์ง€ ์•Š์€ ์ž‘์—… (์บ์‹œ ์ •๋ฆฌ ๋“ฑ)
// ์šฐ์„ ์ˆœ์œ„๊ฐ€ ๋†’์€ Task
Task(priority: .high) {
    await updateUserInterface()
}

// ๋ฐฑ๊ทธ๋ผ์šด๋“œ Task
Task(priority: .background) {
    await cleanupOldCache()
}

๐Ÿ‘ฅ TaskGroup์œผ๋กœ ์—ฌ๋Ÿฌ ์ž‘์—… ๊ด€๋ฆฌํ•˜๊ธฐ

๋™์ ์œผ๋กœ ์—ฌ๋Ÿฌ ๊ฐœ์˜ Task๋ฅผ ๋งŒ๋“ค์–ด์•ผ ํ•  ๋•Œ๊ฐ€ ์žˆ์–ด.
์˜ˆ๋ฅผ ๋“ค์–ด, ์ด๋ฏธ์ง€ ๋ฐฐ์—ด์„ ๋ฐ›์•„์„œ ๊ฐ๊ฐ ๋‹ค์šด๋กœ๋“œํ•œ๋‹ค๋“ ์ง€...

์ด๋Ÿด ๋•Œ TaskGroup์„ ์“ฐ๋ฉด ์™„์ „ ํŽธํ•ด! ๐ŸŽจ

func downloadImages(urls: [URL]) async throws -> [UIImage] {
    try await withThrowingTaskGroup(of: UIImage.self) { group in
        // ๊ฐ URL๋งˆ๋‹ค Task ์ถ”๊ฐ€
        for url in urls {
            group.addTask {
                let (data, _) = try await URLSession.shared.data(from: url)
                guard let image = UIImage(data: data) else {
                    throw ImageError.invalidData
                }
                return image
            }
        }
        
        // ๋ชจ๋“  ๊ฒฐ๊ณผ ์ˆ˜์ง‘
        var images: [UIImage] = []
        for try await image in group {
            images.append(image)
        }
        return images
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
let imageURLs = [url1, url2, url3, url4, url5]
let images = try await downloadImages(urls: imageURLs)
print("๋‹ค์šด๋กœ๋“œ ์™„๋ฃŒ: \(images.count)๊ฐœ")

TaskGroup์˜ ์žฅ์ ์€ ๋ญ๋ƒ๋ฉด:

1๏ธโƒฃ ๋™์ ์œผ๋กœ Task ๊ฐœ์ˆ˜๋ฅผ ์กฐ์ ˆํ•  ์ˆ˜ ์žˆ์–ด
2๏ธโƒฃ ๊ฐ Task์˜ ๊ฒฐ๊ณผ๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ๋˜๋Š” ์™„๋ฃŒ๋˜๋Š” ๋Œ€๋กœ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด
3๏ธโƒฃ ์—๋Ÿฌ ์ฒ˜๋ฆฌ๊ฐ€ ๊น”๋”ํ•ด (withThrowingTaskGroup ์‚ฌ์šฉ ์‹œ)
4๏ธโƒฃ ์ทจ์†Œ๋„ ํ•œ ๋ฒˆ์— ๊ฐ€๋Šฅํ•ด โœจ

โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ
TaskGroup ์•ˆ์—์„œ group.addTask๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ,
ํด๋กœ์ € ์•ˆ์—์„œ ์™ธ๋ถ€ ๋ณ€์ˆ˜๋ฅผ ์บก์ฒ˜ํ•˜๋ฉด ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์–ด!
ํ•„์š”ํ•œ ๊ฐ’์€ ํŒŒ๋ผ๋ฏธํ„ฐ๋กœ ์ „๋‹ฌํ•˜๊ฑฐ๋‚˜, Actor๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ด.
Task ์‹คํ–‰ ํ๋ฆ„๋„ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ Task ์ƒ์„ฑ Task 1 await ๋„คํŠธ์›Œํฌ ์š”์ฒญ ์šฐ์„ ์ˆœ์œ„: high Task 2 await ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ์šฐ์„ ์ˆœ์œ„: medium Task 3 await ์ด๋ฏธ์ง€ ๋กœ๋“œ ์šฐ์„ ์ˆœ์œ„: low ์‹œ์Šคํ…œ์ด ์ž๋™์œผ๋กœ ์ ์ ˆํ•œ ์Šค๋ ˆ๋“œ์— ๋ฐฐ๋ถ„ ๊ฒฐ๊ณผ ์ˆ˜์ง‘ ๋ฐ ๋ฐ˜ํ™˜ ๋ชจ๋“  Task ์™„๋ฃŒ ํ›„ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๋กœ ๋ณต๊ท€ โšก ๋™์‹œ ์‹คํ–‰

๐Ÿ›ก๏ธ Actor: ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค์˜ ๊ตฌ์„ธ์ฃผ

์ž, ์ด์ œ ์ง„์งœ ์ค‘์š”ํ•œ ๋ถ€๋ถ„์ด์•ผ!
์—ฌ๋Ÿฌ Task๊ฐ€ ๋™์‹œ์— ๊ฐ™์€ ๋ฐ์ดํ„ฐ์— ์ ‘๊ทผํ•˜๋ฉด ์–ด๋–ป๊ฒŒ ๋ ๊นŒ? ๐Ÿค”

๋ฐ”๋กœ ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค(Data Race)๊ฐ€ ๋ฐœ์ƒํ•ด.
ํ•œ Task๊ฐ€ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๋Š” ๋™์•ˆ ๋‹ค๋ฅธ Task๊ฐ€ ์“ฐ๊ธฐ๋ฅผ ํ•˜๋ฉด, ์˜ˆ์ธก ๋ถˆ๊ฐ€๋Šฅํ•œ ๋ฒ„๊ทธ๊ฐ€ ์ƒ๊ธฐ๋Š” ๊ฑฐ์ง€.

์˜ˆ์ „์—๋Š” ์ด๊ฑธ ๋ง‰์œผ๋ ค๊ณ  DispatchQueue, NSLock, Semaphore ๊ฐ™์€ ๊ฑธ ์จ์•ผ ํ–ˆ๋Š”๋ฐ...
์†”์งํžˆ ๋ณต์žกํ•˜๊ณ  ์‹ค์ˆ˜ํ•˜๊ธฐ ์‰ฌ์› ์ž–์•„? ๐Ÿ˜ฐ

๊ทธ๋ž˜์„œ Swift๊ฐ€ ๋‚ด๋†“์€ ํ•ด๊ฒฐ์ฑ…์ด ๋ฐ”๋กœ Actor์•ผ!

๐ŸŽฌ Actor์˜ ๊ธฐ๋ณธ ๊ฐœ๋…

Actor๋Š” ํด๋ž˜์Šค๋ž‘ ๋น„์Šทํ•œ๋ฐ, ํ•œ ๊ฐ€์ง€ ํŠน๋ณ„ํ•œ ๋Šฅ๋ ฅ์ด ์žˆ์–ด:
ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ Task๋งŒ ์ž์‹ ์˜ ์ƒํƒœ์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋ณด์žฅํ•ด์ค˜.

์ด๊ฑธ "Actor Isolation"์ด๋ผ๊ณ  ํ•˜๋Š”๋ฐ, ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์ž๋™์œผ๋กœ ์ฒดํฌํ•ด์ค˜์„œ
๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋Š” ์ฝ”๋“œ๋Š” ์•„์˜ˆ ์ปดํŒŒ์ผ์ด ์•ˆ ๋ผ! ๐Ÿ”’

// ์ผ๋ฐ˜ ํด๋ž˜์Šค (๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค ์œ„ํ—˜!)
class Counter {
    var value = 0
    
    func increment() {
        value += 1  // ์—ฌ๋Ÿฌ ์Šค๋ ˆ๋“œ์—์„œ ๋™์‹œ ์ ‘๊ทผ ์‹œ ๋ฌธ์ œ!
    }
}

// Actor๋กœ ๋ณ€๊ฒฝ (์•ˆ์ „!)
actor SafeCounter {
    var value = 0
    
    func increment() {
        value += 1  // Actor๊ฐ€ ์ž๋™์œผ๋กœ ๋™๊ธฐํ™” ๋ณด์žฅ
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
let counter = SafeCounter()

Task {
    await counter.increment()  // await ํ•„์š”!
    let current = await counter.value  // ์ฝ๊ธฐ๋„ await
    print("ํ˜„์žฌ ๊ฐ’: \(current)")
}

๋ณด์ด์ง€? Actor์˜ ๋ฉ”์„œ๋“œ๋‚˜ ํ”„๋กœํผํ‹ฐ์— ์ ‘๊ทผํ•  ๋•Œ๋Š” await๋ฅผ ์จ์•ผ ํ•ด.
์™œ๋ƒ๋ฉด ๋‹ค๋ฅธ Task๊ฐ€ ์‚ฌ์šฉ ์ค‘์ผ ์ˆ˜๋„ ์žˆ์œผ๋‹ˆ๊นŒ, ์ฐจ๋ก€๋ฅผ ๊ธฐ๋‹ค๋ ค์•ผ ํ•˜๊ฑฐ๋“ !

์ด๊ฒŒ ์ฒ˜์Œ์—” ๊ท€์ฐฎ์•„ ๋ณด์ผ ์ˆ˜ ์žˆ๋Š”๋ฐ, ์‚ฌ์‹ค์€ ์—„์ฒญ๋‚œ ์•ˆ์ „์žฅ์น˜์•ผ.
์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ "์—ฌ๊ธฐ ๋™์‹œ์„ฑ ๋ฌธ์ œ ์ƒ๊ธธ ์ˆ˜ ์žˆ์–ด์š”!"๋ผ๊ณ  ๋ฏธ๋ฆฌ ์•Œ๋ ค์ฃผ๋Š” ๊ฑฐ๋‹ˆ๊นŒ. ๐Ÿšจ

๐ŸŽฏ ์‹ค์ „ Actor ํ™œ์šฉ ์˜ˆ์‹œ

actor ImageCache {
    private var cache: [String: UIImage] = [:]
    private var downloadTasks: [String: Task<UIImage, Error>] = [:]
    
    func image(for url: String) async throws -> UIImage {
        // ์บ์‹œ์— ์žˆ์œผ๋ฉด ๋ฐ”๋กœ ๋ฐ˜ํ™˜
        if let cached = cache[url] {
            return cached
        }
        
        // ์ด๋ฏธ ๋‹ค์šด๋กœ๋“œ ์ค‘์ด๋ฉด ๊ทธ Task๋ฅผ ๊ธฐ๋‹ค๋ฆผ
        if let existingTask = downloadTasks[url] {
            return try await existingTask.value
        }
        
        // ์ƒˆ๋กœ์šด ๋‹ค์šด๋กœ๋“œ Task ์ƒ์„ฑ
        let task = Task<UIImage, Error> {
            guard let imageURL = URL(string: url) else {
                throw ImageError.invalidURL
            }
            
            let (data, _) = try await URLSession.shared.data(from: imageURL)
            guard let image = UIImage(data: data) else {
                throw ImageError.invalidData
            }
            
            return image
        }
        
        downloadTasks[url] = task
        
        do {
            let image = try await task.value
            cache[url] = image
            downloadTasks[url] = nil
            return image
        } catch {
            downloadTasks[url] = nil
            throw error
        }
    }
    
    func clearCache() {
        cache.removeAll()
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
let imageCache = ImageCache()

Task {
    do {
        let image = try await imageCache.image(for: "https://example.com/photo.jpg")
        // UI ์—…๋ฐ์ดํŠธ
    } catch {
        print("์ด๋ฏธ์ง€ ๋กœ๋“œ ์‹คํŒจ: \(error)")
    }
}

์œ„ ์ฝ”๋“œ๋Š” ์‹ค๋ฌด์—์„œ ์ •๋ง ๋งŽ์ด ์“ฐ๋Š” ํŒจํ„ด์ด์•ผ!
์—ฌ๋Ÿฌ ๊ณณ์—์„œ ๋™์‹œ์— ๊ฐ™์€ ์ด๋ฏธ์ง€๋ฅผ ์š”์ฒญํ•ด๋„:

โœ… ์ค‘๋ณต ๋‹ค์šด๋กœ๋“œ ๋ฐฉ์ง€
โœ… ์บ์‹œ ์ถฉ๋Œ ๋ฐฉ์ง€
โœ… ๋ฉ”๋ชจ๋ฆฌ ์•ˆ์ „์„ฑ ๋ณด์žฅ

Actor๊ฐ€ ์ด ๋ชจ๋“  ๊ฑธ ์ž๋™์œผ๋กœ ์ฒ˜๋ฆฌํ•ด์ค˜. ์™„์ „ ํŽธํ•˜์ง€? ๐Ÿ˜Ž

๐Ÿ” Actor vs Class ๋น„๊ต
Actor์˜ ์žฅ์ :
โ€ข ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค ์ž๋™ ๋ฐฉ์ง€
โ€ข ์ปดํŒŒ์ผ ํƒ€์ž„์— ์•ˆ์ „์„ฑ ์ฒดํฌ
โ€ข ๋ช…์‹œ์ ์ธ ๋™์‹œ์„ฑ ์ œ์–ด (await ํ‚ค์›Œ๋“œ)

Actor์˜ ์ œ์•ฝ:
โ€ข ์ƒ์† ๋ถˆ๊ฐ€๋Šฅ (ํ”„๋กœํ† ์ฝœ์€ ์ฑ„ํƒ ๊ฐ€๋Šฅ)
โ€ข ์™ธ๋ถ€์—์„œ ์ ‘๊ทผ ์‹œ ํ•ญ์ƒ await ํ•„์š”
โ€ข ๋™๊ธฐ ํ•จ์ˆ˜์—์„œ ์ง์ ‘ ํ˜ธ์ถœ ๋ถˆ๊ฐ€

๐ŸŽจ MainActor: UI ์—…๋ฐ์ดํŠธ์˜ ๋ฒ ์ŠคํŠธ ํ”„๋ Œ๋“œ

iOS ๊ฐœ๋ฐœํ•˜๋ฉด์„œ ๊ฐ€์žฅ ๋งŽ์ด ๋“ฃ๋Š” ๊ฒฝ๊ณ ๊ฐ€ ๋ญ์•ผ?
๋ฐ”๋กœ "UI ์—…๋ฐ์ดํŠธ๋Š” ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค!" ์ด๊ฑฐ์ž–์•„. ๐Ÿ“ฑ

์˜ˆ์ „์—๋Š” DispatchQueue.main.async { } ์ด๋ ‡๊ฒŒ ๊ฐ์‹ธ์•ผ ํ–ˆ๋Š”๋ฐ,
์ด์ œ๋Š” @MainActor ํ•˜๋‚˜๋ฉด ๋์ด์•ผ!

โœจ @MainActor ๊ธฐ๋ณธ ์‚ฌ์šฉ๋ฒ•

// ViewModel์„ MainActor๋กœ ์„ ์–ธ
@MainActor
class UserViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    func loadUser(id: String) async {
        isLoading = true  // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ์ž๋™ ์‹คํ–‰
        errorMessage = nil
        
        do {
            // ๋„คํŠธ์›Œํฌ ์š”์ฒญ์€ ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ
            let fetchedUser = await UserService.shared.fetchUser(id: id)
            
            // UI ์—…๋ฐ์ดํŠธ๋Š” ์ž๋™์œผ๋กœ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ
            user = fetchedUser
            isLoading = false
        } catch {
            errorMessage = error.localizedDescription
            isLoading = false
        }
    }
}

// SwiftUI View์—์„œ ์‚ฌ์šฉ
struct UserProfileView: View {
    @StateObject private var viewModel = UserViewModel()
    
    var body: some View {
        VStack {
            if viewModel.isLoading {
                ProgressView()
            } else if let user = viewModel.user {
                Text(user.name)
                Text(user.email)
            }
        }
        .task {
            await viewModel.loadUser(id: "12345")
        }
    }
}

@MainActor๋ฅผ ํด๋ž˜์Šค์— ๋ถ™์ด๋ฉด, ๊ทธ ํด๋ž˜์Šค์˜ ๋ชจ๋“  ๋ฉ”์„œ๋“œ์™€ ํ”„๋กœํผํ‹ฐ๊ฐ€
์ž๋™์œผ๋กœ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ์‹คํ–‰๋ผ.

๋” ์ด์ƒ "์–ด? ์ด๊ฑฐ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ ๋งž๋‚˜?" ๊ฑฑ์ • ์•ˆ ํ•ด๋„ ๋ผ! ๐ŸŽ‰

๐ŸŽฏ ๋ถ€๋ถ„์ ์œผ๋กœ MainActor ์‚ฌ์šฉํ•˜๊ธฐ

์ „์ฒด ํด๋ž˜์Šค๊ฐ€ ์•„๋‹ˆ๋ผ ํŠน์ • ๋ฉ”์„œ๋“œ๋‚˜ ํ”„๋กœํผํ‹ฐ๋งŒ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ์‹คํ–‰ํ•˜๊ณ  ์‹ถ์„ ๋•Œ๋„ ์žˆ์–ด.
๊ทธ๋Ÿด ๋• ๊ฐœ๋ณ„์ ์œผ๋กœ @MainActor๋ฅผ ๋ถ™์ด๋ฉด ๋ผ!

class DataManager {
    // ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์‹คํ–‰๋˜๋Š” ๋ฌด๊ฑฐ์šด ์ž‘์—…
    func processLargeDataset() async -> [ProcessedData] {
        // ๋ณต์žกํ•œ ๊ณ„์‚ฐ...
        return processedData
    }
    
    // UI ์—…๋ฐ์ดํŠธ๋Š” ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ
    @MainActor
    func updateUI(with data: [ProcessedData]) {
        // UI ์ปดํฌ๋„ŒํŠธ ์—…๋ฐ์ดํŠธ
        tableView.reloadData()
        statusLabel.text = "์ฒ˜๋ฆฌ ์™„๋ฃŒ: \(data.count)๊ฐœ"
    }
    
    func performTask() async {
        let data = await processLargeDataset()  // ๋ฐฑ๊ทธ๋ผ์šด๋“œ
        await updateUI(with: data)  // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๋กœ ์ž๋™ ์ „ํ™˜
    }
}
๐Ÿ’ก ํ”„๋กœ ํŒ
@MainActor ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ await๋ฅผ ์“ฐ๋ฉด,
ํ˜„์žฌ ์ปจํ…์ŠคํŠธ๊ฐ€ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๊ฐ€ ์•„๋‹ ๊ฒฝ์šฐ ์ž๋™์œผ๋กœ ์ „ํ™˜ํ•ด์ค˜.
์ด๋ฏธ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๋ผ๋ฉด? ๊ทธ๋ƒฅ ๋ฐ”๋กœ ์‹คํ–‰๋ผ. ๋˜‘๋˜‘ํ•˜์ง€? ๐Ÿง 

๐Ÿš€ nonisolated ํ‚ค์›Œ๋“œ

@MainActor๋กœ ์„ ์–ธ๋œ ํƒ€์ž… ์•ˆ์—์„œ๋„, ํŠน์ • ๋ฉ”์„œ๋“œ๋Š” ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์‹คํ–‰ํ•˜๊ณ  ์‹ถ์„ ๋•Œ๊ฐ€ ์žˆ์–ด.
๊ทธ๋Ÿด ๋•Œ nonisolated ํ‚ค์›Œ๋“œ๋ฅผ ์จ!

@MainActor
class ImageProcessor {
    var processedImages: [UIImage] = []
    
    // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ์‹คํ–‰ (๊ธฐ๋ณธ)
    func displayImages() {
        // UI ์—…๋ฐ์ดํŠธ
    }
    
    // ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์‹คํ–‰
    nonisolated func heavyProcessing(image: UIImage) async -> UIImage {
        // ๋ฌด๊ฑฐ์šด ์ด๋ฏธ์ง€ ์ฒ˜๋ฆฌ ์ž‘์—…
        // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๋ฅผ ๋ธ”๋กœํ‚นํ•˜์ง€ ์•Š์Œ
        return processedImage
    }
    
    func processAndDisplay(image: UIImage) async {
        let processed = await heavyProcessing(image: image)  // ๋ฐฑ๊ทธ๋ผ์šด๋“œ
        processedImages.append(processed)  // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ
        displayImages()  // ๋ฉ”์ธ ์Šค๋ ˆ๋“œ
    }
}

์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ๋ฌด๊ฑฐ์šด ์ž‘์—…์€ ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์ฒ˜๋ฆฌํ•˜๊ณ ,
UI ์—…๋ฐ์ดํŠธ๋งŒ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ ํ•  ์ˆ˜ ์žˆ์–ด. ์™„๋ฒฝํ•œ ์กฐํ•ฉ์ด์ง€! โœจ

MainActor ๋™์ž‘ ์›๋ฆฌ ๋ฉ”์ธ ์Šค๋ ˆ๋“œ @MainActor ์˜์—ญ UI ์—…๋ฐ์ดํŠธ tableView.reloadData() Published ํ”„๋กœํผํ‹ฐ ๋ณ€๊ฒฝ isLoading = false ์• ๋‹ˆ๋ฉ”์ด์…˜ ์‹คํ–‰ UIView.animate { } ์‚ฌ์šฉ์ž ์ธํ„ฐ๋ž™์…˜ ์ฒ˜๋ฆฌ ๋ฒ„ํŠผ ํด๋ฆญ, ์ œ์Šค์ฒ˜ ๋“ฑ ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์Šค๋ ˆ๋“œ ์ผ๋ฐ˜ async ํ•จ์ˆ˜ ๋„คํŠธ์›Œํฌ ์š”์ฒญ URLSession.data(from:) ๋ฐ์ดํ„ฐ ํŒŒ์‹ฑ JSONDecoder.decode() ์ด๋ฏธ์ง€ ์ฒ˜๋ฆฌ ๋ฆฌ์‚ฌ์ด์ง•, ํ•„ํ„ฐ ์ ์šฉ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ž‘์—… CoreData, Realm ๋“ฑ ์ž‘์—… ์š”์ฒญ ๊ฒฐ๊ณผ ๋ฐ˜ํ™˜ (await ์ž๋™ ์ „ํ™˜)

๐Ÿ“ฆ Sendable: ์•ˆ์ „ํ•œ ๋ฐ์ดํ„ฐ ์ „๋‹ฌ์˜ ๋น„๋ฐ€

Task๋‚˜ Actor ์‚ฌ์ด์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฃผ๊ณ ๋ฐ›์„ ๋•Œ, ์ค‘์š”ํ•œ ๊ฒŒ ํ•˜๋‚˜ ์žˆ์–ด.
๋ฐ”๋กœ ๊ทธ ๋ฐ์ดํ„ฐ๊ฐ€ ๋™์‹œ์„ฑ ํ™˜๊ฒฝ์—์„œ ์•ˆ์ „ํ•œ๊ฐ€?์•ผ. ๐Ÿ”

Swift๋Š” ์ด๊ฑธ Sendable ํ”„๋กœํ† ์ฝœ๋กœ ํ‘œํ˜„ํ•ด.
Sendable์„ ์ฑ„ํƒํ•œ ํƒ€์ž…์€ "๋‚˜๋Š” ์—ฌ๋Ÿฌ Task ์‚ฌ์ด์—์„œ ์•ˆ์ „ํ•˜๊ฒŒ ์ „๋‹ฌ๋  ์ˆ˜ ์žˆ์–ด์š”!"๋ผ๊ณ  ๋ณด์žฅํ•˜๋Š” ๊ฑฐ์ง€.

โœ… ์ž๋™์œผ๋กœ Sendableํ•œ ํƒ€์ž…๋“ค

๋‹คํ–‰ํžˆ๋„ ๋Œ€๋ถ€๋ถ„์˜ ๊ธฐ๋ณธ ํƒ€์ž…๋“ค์€ ์ด๋ฏธ Sendable์ด์•ผ:

๐ŸŽฏ ์ž๋™ Sendable ํƒ€์ž…
โ€ข ๊ฐ’ ํƒ€์ž…: Int, String, Bool, Double ๋“ฑ ๋ชจ๋“  ๊ธฐ๋ณธ ํƒ€์ž…
โ€ข ๊ตฌ์กฐ์ฒด: ๋ชจ๋“  ํ”„๋กœํผํ‹ฐ๊ฐ€ Sendable์ด๋ฉด ์ž๋™์œผ๋กœ Sendable
โ€ข ์—ด๊ฑฐํ˜•: ์—ฐ๊ด€๊ฐ’์ด ๋ชจ๋‘ Sendable์ด๋ฉด ์ž๋™
โ€ข Actor: ๋ชจ๋“  Actor๋Š” ์ž๋™์œผ๋กœ Sendable
โ€ข @Sendable ํด๋กœ์ €: ๋ช…์‹œ์ ์œผ๋กœ ํ‘œ์‹œ๋œ ํด๋กœ์ €
// ์ž๋™์œผ๋กœ Sendable
struct User: Sendable {
    let id: String
    let name: String
    let age: Int
}

// ์ด๊ฒƒ๋„ ์ž๋™์œผ๋กœ Sendable
enum Result: Sendable {
    case success(String)
    case failure(Error)
}

// Actor๋Š” ํ•ญ์ƒ Sendable
actor UserManager: Sendable {
    var users: [User] = []
}

โš ๏ธ Sendableํ•˜์ง€ ์•Š์€ ํƒ€์ž…๋“ค

๋ฌธ์ œ๋Š” ํด๋ž˜์Šค์•ผ. ํด๋ž˜์Šค๋Š” ์ฐธ์กฐ ํƒ€์ž…์ด๋ผ์„œ ๊ธฐ๋ณธ์ ์œผ๋กœ Sendable์ด ์•„๋‹ˆ๊ฑฐ๋“ .
์—ฌ๋Ÿฌ Task๊ฐ€ ๊ฐ™์€ ์ธ์Šคํ„ด์Šค๋ฅผ ์ฐธ์กฐํ•˜๋ฉด ๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์œผ๋‹ˆ๊นŒ!

// โŒ ์ด๊ฑด Sendable์ด ์•„๋‹˜
class UserProfile {
    var name: String
    var email: String
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
    }
}

// โœ… ๋ถˆ๋ณ€ ํด๋ž˜์Šค๋Š” Sendable ๊ฐ€๋Šฅ
final class ImmutableUserProfile: @unchecked Sendable {
    let name: String
    let email: String
    
    init(name: String, email: String) {
        self.name = name
        self.email = email
    }
}

// โœ… ๋‚ด๋ถ€์ ์œผ๋กœ ๋™๊ธฐํ™”๋ฅผ ๋ณด์žฅํ•˜๋Š” ํด๋ž˜์Šค
final class ThreadSafeCounter: @unchecked Sendable {
    private let lock = NSLock()
    private var _value = 0
    
    var value: Int {
        lock.lock()
        defer { lock.unlock() }
        return _value
    }
    
    func increment() {
        lock.lock()
        defer { lock.unlock() }
        _value += 1
    }
}

@unchecked Sendable์€ "๋‚ด๊ฐ€ ์ง์ ‘ ์•ˆ์ „์„ฑ์„ ๋ณด์žฅํ• ๊ฒŒ!"๋ผ๊ณ  ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ๋งํ•˜๋Š” ๊ฑฐ์•ผ.
ํ•˜์ง€๋งŒ ์กฐ์‹ฌํ•ด์•ผ ํ•ด. ์ง„์งœ๋กœ ์•ˆ์ „ํ•˜์ง€ ์•Š์œผ๋ฉด ๋Ÿฐํƒ€์ž„ ํฌ๋ž˜์‹œ๊ฐ€ ๋‚  ์ˆ˜ ์žˆ๊ฑฐ๋“ ! ๐Ÿ’ฅ

๐ŸŽญ @Sendable ํด๋กœ์ €

Task์— ํด๋กœ์ €๋ฅผ ์ „๋‹ฌํ•  ๋•Œ๋„ Sendable์ด ์ค‘์š”ํ•ด.
ํŠนํžˆ ์™ธ๋ถ€ ๋ณ€์ˆ˜๋ฅผ ์บก์ฒ˜ํ•˜๋Š” ๊ฒฝ์šฐ์—๋Š” ๋”๋”์šฑ!

func processData() async {
    var counter = 0  // ๊ฐ€๋ณ€ ๋ณ€์ˆ˜
    
    // โŒ ์ด๊ฑด ์œ„ํ—˜! counter๋ฅผ ์—ฌ๋Ÿฌ Task๊ฐ€ ๊ณต์œ 
    Task {
        counter += 1  // ์ปดํŒŒ์ผ ์—๋Ÿฌ!
    }
    
    // โœ… ๊ฐ’์„ ๋ณต์‚ฌํ•ด์„œ ์ „๋‹ฌ
    let currentCount = counter
    Task {
        print("Count: \(currentCount)")  // ์•ˆ์ „
    }
    
    // โœ… Actor๋ฅผ ์‚ฌ์šฉ
    let safeCounter = SafeCounter()
    Task {
        await safeCounter.increment()  // ์•ˆ์ „
    }
}

// @Sendable ํด๋กœ์ € ๋ช…์‹œ
func performAsync(operation: @Sendable @escaping () async -> Void) {
    Task {
        await operation()
    }
}
๐Ÿ’ก ์‹ค์ „ ํŒ
Sendable ๊ด€๋ จ ์ปดํŒŒ์ผ ์—๋Ÿฌ๊ฐ€ ๋‚˜๋ฉด ๋‹นํ™ฉํ•˜์ง€ ๋งˆ!
๋Œ€๋ถ€๋ถ„์€ ๋‹ค์Œ ์ค‘ ํ•˜๋‚˜๋กœ ํ•ด๊ฒฐ๋ผ:

1๏ธโƒฃ ๊ฐ’ ํƒ€์ž…(struct)์œผ๋กœ ๋ณ€๊ฒฝ
2๏ธโƒฃ Actor๋กœ ๊ฐ์‹ธ๊ธฐ
3๏ธโƒฃ ๋ถˆ๋ณ€์œผ๋กœ ๋งŒ๋“ค๊ธฐ (let์œผ๋กœ ์„ ์–ธ)
4๏ธโƒฃ ํ•„์š”ํ•œ ๊ฐ’๋งŒ ๋ณต์‚ฌํ•ด์„œ ์ „๋‹ฌ

๐ŸŽช ์‹ค์ „ ํŒจํ„ด: ๋„คํŠธ์›Œํฌ ๋ ˆ์ด์–ด ๊ตฌ์ถ•ํ•˜๊ธฐ

์ด๋ก ์€ ์ด์ œ ์ถฉ๋ถ„ํ•ด! ์‹ค์ œ๋กœ ์–ด๋–ป๊ฒŒ ์“ฐ๋Š”์ง€ ๋ด๋ณด์ž.
์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ Swift ๊ฐœ๋ฐœ ์žฌ๋Šฅ์„ ๊ฑฐ๋ž˜ํ•  ๋•Œ,
์ด๋Ÿฐ ์‹ค์ „ ์˜ˆ์ œ๋“ค์ด ์ •๋ง ๋„์›€์ด ๋  ๊ฑฐ์•ผ. ๐Ÿš€

๐ŸŒ ํ˜„๋Œ€์ ์ธ ๋„คํŠธ์›Œํฌ ์„œ๋น„์Šค

// API ์—”๋“œํฌ์ธํŠธ ์ •์˜
enum APIEndpoint {
    case users
    case user(id: String)
    case posts
    case post(id: String)
    
    var url: URL {
        let base = "https://api.example.com"
        switch self {
        case .users:
            return URL(string: "\(base)/users")!
        case .user(let id):
            return URL(string: "\(base)/users/\(id)")!
        case .posts:
            return URL(string: "\(base)/posts")!
        case .post(let id):
            return URL(string: "\(base)/posts/\(id)")!
        }
    }
}

// ๋„คํŠธ์›Œํฌ ์—๋Ÿฌ ์ •์˜
enum NetworkError: Error {
    case invalidURL
    case invalidResponse
    case httpError(statusCode: Int)
    case decodingError
    case unknown
}

// ๋ฉ”์ธ ๋„คํŠธ์›Œํฌ ์„œ๋น„์Šค
actor NetworkService {
    static let shared = NetworkService()
    
    private let session: URLSession
    private var cache: [String: Any] = [:]
    
    private init() {
        let config = URLSessionConfiguration.default
        config.timeoutIntervalForRequest = 30
        config.waitsForConnectivity = true
        self.session = URLSession(configuration: config)
    }
    
    func fetch<T: Decodable>(
        _ endpoint: APIEndpoint,
        type: T.Type,
        useCache: Bool = true
    ) async throws -> T {
        let cacheKey = endpoint.url.absoluteString
        
        // ์บ์‹œ ํ™•์ธ
        if useCache, let cached = cache[cacheKey] as? T {
            return cached
        }
        
        // ๋„คํŠธ์›Œํฌ ์š”์ฒญ
        let (data, response) = try await session.data(from: endpoint.url)
        
        // ์‘๋‹ต ๊ฒ€์ฆ
        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.invalidResponse
        }
        
        guard (200...299).contains(httpResponse.statusCode) else {
            throw NetworkError.httpError(statusCode: httpResponse.statusCode)
        }
        
        // ๋””์ฝ”๋”ฉ
        do {
            let decoder = JSONDecoder()
            decoder.keyDecodingStrategy = .convertFromSnakeCase
            let decoded = try decoder.decode(T.self, from: data)
            
            // ์บ์‹œ ์ €์žฅ
            if useCache {
                cache[cacheKey] = decoded
            }
            
            return decoded
        } catch {
            throw NetworkError.decodingError
        }
    }
    
    func clearCache() {
        cache.removeAll()
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
struct User: Codable, Sendable {
    let id: String
    let name: String
    let email: String
}

@MainActor
class UserListViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    func loadUsers() async {
        isLoading = true
        errorMessage = nil
        
        do {
            let fetchedUsers = try await NetworkService.shared.fetch(
                .users,
                type: [User].self
            )
            users = fetchedUsers
        } catch {
            errorMessage = "์‚ฌ์šฉ์ž ๋ชฉ๋ก์„ ๋ถˆ๋Ÿฌ์˜ฌ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค: \(error.localizedDescription)"
        }
        
        isLoading = false
    }
    
    func refreshUsers() async {
        await NetworkService.shared.clearCache()
        await loadUsers()
    }
}

์ด ์ฝ”๋“œ์˜ ์žฅ์ ์ด ๋ญ๋ƒ๋ฉด:

โœ… Actor๋กœ ์บ์‹œ ๋™๊ธฐํ™” ์ž๋™ ๋ณด์žฅ
โœ… async/await๋กœ ๊น”๋”ํ•œ ์—๋Ÿฌ ์ฒ˜๋ฆฌ
โœ… @MainActor๋กœ UI ์—…๋ฐ์ดํŠธ ์•ˆ์ „
โœ… Sendable ํƒ€์ž…์œผ๋กœ ๋ฐ์ดํ„ฐ ์•ˆ์ „์„ฑ ํ™•๋ณด

์˜ˆ์ „ ๊ฐ™์•˜์œผ๋ฉด DispatchQueue, completion handler, ์ˆ˜๋™ ๋™๊ธฐํ™” ๋“ฑ๋“ฑ...
์ฝ”๋“œ๊ฐ€ ๋ช‡ ๋ฐฐ๋Š” ๋” ๋ณต์žกํ–ˆ์„ ๊ฑฐ์•ผ! ๐Ÿ˜…

๐ŸŽฏ ๊ณ ๊ธ‰ ํŒจํ„ด: AsyncSequence์™€ AsyncStream

์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰ ๊ธฐ๋Šฅ์„ ์•Œ์•„๋ณด์ž!
AsyncSequence๋Š” ๋น„๋™๊ธฐ์ ์œผ๋กœ ๊ฐ’์„ ํ•˜๋‚˜์”ฉ ์ƒ์„ฑํ•˜๋Š” ์‹œํ€€์Šค์•ผ.
์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ, ํŒŒ์ผ ์ฝ๊ธฐ, ์›น์†Œ์ผ“ ๋“ฑ์— ์™„๋ฒฝํ•ด! ๐ŸŒŠ

๐Ÿ“ก AsyncStream์œผ๋กœ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ

// ์‹ค์‹œ๊ฐ„ ์œ„์น˜ ์ถ”์ 
class LocationTracker {
    func startTracking() -> AsyncStream<Location> {
        AsyncStream { continuation in
            let locationManager = CLLocationManager()
            let delegate = LocationDelegate { location in
                continuation.yield(location)
            }
            
            locationManager.delegate = delegate
            locationManager.startUpdatingLocation()
            
            continuation.onTermination = { _ in
                locationManager.stopUpdatingLocation()
            }
        }
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
@MainActor
class MapViewModel: ObservableObject {
    @Published var currentLocation: Location?
    @Published var locationHistory: [Location] = []
    
    private var trackingTask: Task<Void, Never>?
    
    func startTracking() {
        trackingTask = Task {
            let tracker = LocationTracker()
            
            for await location in tracker.startTracking() {
                currentLocation = location
                locationHistory.append(location)
                
                // ์ตœ๊ทผ 100๊ฐœ๋งŒ ์œ ์ง€
                if locationHistory.count > 100 {
                    locationHistory.removeFirst()
                }
            }
        }
    }
    
    func stopTracking() {
        trackingTask?.cancel()
        trackingTask = nil
    }
}

// ์›น์†Œ์ผ“ ๋ฉ”์‹œ์ง€ ์ŠคํŠธ๋ฆผ
actor WebSocketManager {
    private var webSocket: URLSessionWebSocketTask?
    
    func connect(to url: URL) -> AsyncStream<String> {
        AsyncStream { continuation in
            let session = URLSession.shared
            let webSocket = session.webSocketTask(with: url)
            self.webSocket = webSocket
            
            webSocket.resume()
            
            Task {
                while !Task.isCancelled {
                    do {
                        let message = try await webSocket.receive()
                        
                        switch message {
                        case .string(let text):
                            continuation.yield(text)
                        case .data(let data):
                            if let text = String(data: data, encoding: .utf8) {
                                continuation.yield(text)
                            }
                        @unknown default:
                            break
                        }
                    } catch {
                        continuation.finish()
                        break
                    }
                }
            }
            
            continuation.onTermination = { _ in
                webSocket.cancel(with: .goingAway, reason: nil)
            }
        }
    }
    
    func disconnect() {
        webSocket?.cancel(with: .goingAway, reason: nil)
        webSocket = nil
    }
}

// ์ฑ„ํŒ… ์•ฑ์—์„œ ์‚ฌ์šฉ
@MainActor
class ChatViewModel: ObservableObject {
    @Published var messages: [ChatMessage] = []
    
    private let webSocketManager = WebSocketManager()
    private var messageTask: Task<Void, Never>?
    
    func connectToChat(roomId: String) async {
        let url = URL(string: "wss://chat.example.com/room/\(roomId)")!
        
        messageTask = Task {
            for await messageText in await webSocketManager.connect(to: url) {
                if let message = ChatMessage.parse(messageText) {
                    messages.append(message)
                }
            }
        }
    }
    
    func disconnect() {
        messageTask?.cancel()
        Task {
            await webSocketManager.disconnect()
        }
    }
}

AsyncStream์˜ ์ง„์งœ ํŒŒ์›Œ๋Š” ๋ญ๋ƒ๋ฉด:

๐ŸŽฏ ๋ฌดํ•œํ•œ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ์„ for-await-in์œผ๋กœ ๊น”๋”ํ•˜๊ฒŒ ์ฒ˜๋ฆฌ
๐ŸŽฏ ์ž๋™ ์ทจ์†Œ ์ฒ˜๋ฆฌ (Task๊ฐ€ ์ทจ์†Œ๋˜๋ฉด ์ŠคํŠธ๋ฆผ๋„ ์ข…๋ฃŒ)
๐ŸŽฏ ๋ฐฑํ”„๋ ˆ์…”(backpressure) ์ž๋™ ๊ด€๋ฆฌ
๐ŸŽฏ ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์  (ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์”ฉ๋งŒ ์ฒ˜๋ฆฌ)

์˜ˆ์ „ ๊ฐ™์•˜์œผ๋ฉด Combine์ด๋‚˜ RxSwift ์จ์•ผ ํ–ˆ๋Š”๋ฐ,
์ด์ œ๋Š” Swift ๊ธฐ๋ณธ ๊ธฐ๋Šฅ๋งŒ์œผ๋กœ๋„ ์ถฉ๋ถ„ํ•ด! ๐ŸŽ‰

AsyncStream ๋ฐ์ดํ„ฐ ํ๋ฆ„ ๋ฐ์ดํ„ฐ ์†Œ์Šค ์›น์†Œ์ผ“ AsyncStream continuation.yield() ๋ฐ์ดํ„ฐ ์ „๋‹ฌ for await ์ˆœ์ฐจ์  ์ฒ˜๋ฆฌ ํ•˜๋‚˜์”ฉ ์†Œ๋น„ UI ์—…๋ฐ์ดํŠธ @MainActor ํ™”๋ฉด ๊ฐฑ์‹  AsyncStream ์žฅ์  ๐ŸŽฏ ๋ฌดํ•œ ์ŠคํŠธ๋ฆผ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ โšก ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์  (ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์”ฉ) ๐Ÿ”„ ์ž๋™ ์ทจ์†Œ ๋ฐ ์ •๋ฆฌ โœจ ๋ฐฑํ”„๋ ˆ์…” ์ž๋™ ๊ด€๋ฆฌ ๐Ÿš€ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ์— ์ตœ์ ํ™” ๐ŸŽจ ๊น”๋”ํ•œ ๋ฌธ๋ฒ• (for await in) ๐Ÿ›ก๏ธ ํƒ€์ž… ์•ˆ์ „์„ฑ ๋ณด์žฅ ๐Ÿ’ช Combine ๋Œ€์ฒด ๊ฐ€๋Šฅ

โš ๏ธ ํ”ํ•œ ์‹ค์ˆ˜์™€ ํ•ด๊ฒฐ์ฑ…

์ž, ์ด์ œ ์‹ค์ „์—์„œ ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ํ•จ์ •๋“ค์„ ์•Œ์•„๋ณด์ž!
๋‚˜๋„ ์ฒ˜์Œ์—” ์ด๋Ÿฐ ์‹ค์ˆ˜ ์—„์ฒญ ๋งŽ์ด ํ–ˆ์–ด. ๐Ÿ˜…
๋ฏธ๋ฆฌ ์•Œ์•„๋‘๋ฉด ์‹œ๊ฐ„ ์—„์ฒญ ์ ˆ์•ฝํ•  ์ˆ˜ ์žˆ์–ด!

๐Ÿšจ ์‹ค์ˆ˜ 1: Task ๋ˆ„์ˆ˜

// โŒ ๋‚˜์œ ์˜ˆ: Task๊ฐ€ ๊ณ„์† ์Œ“์ž„
class BadViewModel: ObservableObject {
    @Published var data: [Item] = []
    
    func loadData() {
        Task {
            // ์ด์ „ Task๊ฐ€ ์ทจ์†Œ๋˜์ง€ ์•Š๊ณ  ๊ณ„์† ์‹คํ–‰๋จ!
            let items = await fetchItems()
            data = items
        }
    }
}

// โœ… ์ข‹์€ ์˜ˆ: ์ด์ „ Task ์ทจ์†Œ
class GoodViewModel: ObservableObject {
    @Published var data: [Item] = []
    private var loadTask: Task<Void, Never>?
    
    func loadData() {
        // ์ด์ „ ์ž‘์—… ์ทจ์†Œ
        loadTask?.cancel()
        
        loadTask = Task {
            do {
                let items = try await fetchItems()
                
                // ์ทจ์†Œ๋˜์ง€ ์•Š์•˜์„ ๋•Œ๋งŒ ์—…๋ฐ์ดํŠธ
                if !Task.isCancelled {
                    data = items
                }
            } catch {
                if !Task.isCancelled {
                    print("์—๋Ÿฌ: \(error)")
                }
            }
        }
    }
    
    deinit {
        loadTask?.cancel()
    }
}

๐Ÿšจ ์‹ค์ˆ˜ 2: MainActor ์—†์ด UI ์—…๋ฐ์ดํŠธ

// โŒ ๋‚˜์œ ์˜ˆ: ๋Ÿฐํƒ€์ž„ ํฌ๋ž˜์‹œ ๊ฐ€๋Šฅ
func updateUI() async {
    let data = await fetchData()
    // ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์Šค๋ ˆ๋“œ์—์„œ UI ์—…๋ฐ์ดํŠธ!
    self.label.text = data.title  // ๐Ÿ’ฅ ํฌ๋ž˜์‹œ!
}

// โœ… ์ข‹์€ ์˜ˆ 1: @MainActor ์‚ฌ์šฉ
@MainActor
func updateUI() async {
    let data = await fetchData()
    self.label.text = data.title  // ์•ˆ์ „!
}

// โœ… ์ข‹์€ ์˜ˆ 2: ๋ถ€๋ถ„์ ์œผ๋กœ MainActor
func updateUI() async {
    let data = await fetchData()
    
    await MainActor.run {
        self.label.text = data.title  // ์•ˆ์ „!
    }
}

๐Ÿšจ ์‹ค์ˆ˜ 3: Actor ๋‚ด๋ถ€์—์„œ ๋™๊ธฐ ํ•จ์ˆ˜ ํ˜ธ์ถœ

actor DataManager {
    var items: [Item] = []
    
    // โŒ ๋‚˜์œ ์˜ˆ: ๋™๊ธฐ ํ•จ์ˆ˜๊ฐ€ Actor ์ƒํƒœ ์ ‘๊ทผ
    func processItems() {
        items.forEach { item in
            // ์ด ํด๋กœ์ €๋Š” ๋™๊ธฐ์ ์œผ๋กœ ์‹คํ–‰๋จ
            // Actor isolation ์œ„๋ฐ˜ ๊ฐ€๋Šฅ!
            updateItem(item)
        }
    }
    
    // โœ… ์ข‹์€ ์˜ˆ: async ํ•จ์ˆ˜ ์‚ฌ์šฉ
    func processItems() async {
        for item in items {
            await updateItem(item)
        }
    }
    
    private func updateItem(_ item: Item) async {
        // ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ
    }
}

๐Ÿšจ ์‹ค์ˆ˜ 4: ๋ถˆํ•„์š”ํ•œ await ๋‚จ๋ฐœ

// โŒ ๋‚˜์œ ์˜ˆ: ์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰ (๋А๋ฆผ!)
func loadDashboard() async {
    let user = await fetchUser()
    let posts = await fetchPosts()
    let comments = await fetchComments()
    // ์ด ์‹œ๊ฐ„ = user + posts + comments
}

// โœ… ์ข‹์€ ์˜ˆ: ๋ณ‘๋ ฌ ์‹คํ–‰ (๋น ๋ฆ„!)
func loadDashboard() async {
    async let user = fetchUser()
    async let posts = fetchPosts()
    async let comments = fetchComments()
    
    let (userData, postsData, commentsData) = await (user, posts, comments)
    // ์ด ์‹œ๊ฐ„ = max(user, posts, comments)
}
๐ŸŽฏ ์„ฑ๋Šฅ ์ตœ์ ํ™” ํŒ
1. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ ํ™œ์šฉ
๋…๋ฆฝ์ ์ธ ์ž‘์—…๋“ค์€ async let์ด๋‚˜ TaskGroup์œผ๋กœ ๋™์‹œ ์‹คํ–‰

2. Task ์šฐ์„ ์ˆœ์œ„ ์„ค์ •
์‚ฌ์šฉ์ž ์ธํ„ฐ๋ž™์…˜์€ .high, ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—…์€ .low

3. ์ ์ ˆํ•œ ์ทจ์†Œ ์ฒ˜๋ฆฌ
Task.isCancelled๋ฅผ ์ฃผ๊ธฐ์ ์œผ๋กœ ์ฒดํฌํ•ด์„œ ๋ถˆํ•„์š”ํ•œ ์ž‘์—… ์ค‘๋‹จ

4. Actor ์„ธ๋ถ„ํ™”
๋„ˆ๋ฌด ํฐ Actor๋Š” ๋ณ‘๋ชฉ์ด ๋  ์ˆ˜ ์žˆ์œผ๋‹ˆ ์ ์ ˆํžˆ ๋ถ„๋ฆฌ

๐ŸŽ“ ์‹ค์ „ ํ”„๋กœ์ ํŠธ: ์ด๋ฏธ์ง€ ๋‹ค์šด๋กœ๋” ๋งŒ๋“ค๊ธฐ

์ด์ œ ๋ฐฐ์šด ๊ฑธ ๋‹ค ํ•ฉ์ณ์„œ ์‹ค์ „ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž!
์—ฌ๋Ÿฌ ์ด๋ฏธ์ง€๋ฅผ ๋™์‹œ์— ๋‹ค์šด๋กœ๋“œํ•˜๊ณ , ์บ์‹ฑํ•˜๊ณ , UI์— ํ‘œ์‹œํ•˜๋Š”
์™„์ „ํ•œ ์ด๋ฏธ์ง€ ๋‹ค์šด๋กœ๋”๋ฅผ ๊ตฌํ˜„ํ•  ๊ฑฐ์•ผ. ๐Ÿ–ผ๏ธ

// ์ด๋ฏธ์ง€ ๋‹ค์šด๋กœ๋“œ ์ƒํƒœ
enum DownloadState: Sendable {
    case idle
    case downloading(progress: Double)
    case completed(UIImage)
    case failed(Error)
}

// ๋ฉ”์ธ ์ด๋ฏธ์ง€ ๋‹ค์šด๋กœ๋” Actor
actor ImageDownloader {
    static let shared = ImageDownloader()
    
    private var cache: [URL: UIImage] = [:]
    private var ongoingDownloads: [URL: Task<UIImage, Error>] = [:]
    
    private init() {}
    
    func downloadImage(from url: URL) async throws -> UIImage {
        // 1. ์บ์‹œ ํ™•์ธ
        if let cached = cache[url] {
            print("โœ… ์บ์‹œ์—์„œ ๋กœ๋“œ: \(url.lastPathComponent)")
            return cached
        }
        
        // 2. ์ด๋ฏธ ๋‹ค์šด๋กœ๋“œ ์ค‘์ธ์ง€ ํ™•์ธ
        if let existingTask = ongoingDownloads[url] {
            print("โณ ์ง„ํ–‰ ์ค‘์ธ ๋‹ค์šด๋กœ๋“œ ๋Œ€๊ธฐ: \(url.lastPathComponent)")
            return try await existingTask.value
        }
        
        // 3. ์ƒˆ๋กœ์šด ๋‹ค์šด๋กœ๋“œ ์‹œ์ž‘
        let task = Task<UIImage, Error> {
            print("๐Ÿš€ ๋‹ค์šด๋กœ๋“œ ์‹œ์ž‘: \(url.lastPathComponent)")
            
            let (data, response) = try await URLSession.shared.data(from: url)
            
            guard let httpResponse = response as? HTTPURLResponse,
                  (200...299).contains(httpResponse.statusCode) else {
                throw URLError(.badServerResponse)
            }
            
            guard let image = UIImage(data: data) else {
                throw URLError(.cannotDecodeContentData)
            }
            
            print("โœจ ๋‹ค์šด๋กœ๋“œ ์™„๋ฃŒ: \(url.lastPathComponent)")
            return image
        }
        
        ongoingDownloads[url] = task
        
        do {
            let image = try await task.value
            cache[url] = image
            ongoingDownloads[url] = nil
            return image
        } catch {
            ongoingDownloads[url] = nil
            throw error
        }
    }
    
    func downloadImages(from urls: [URL]) async -> [URL: Result<UIImage, Error>] {
        await withTaskGroup(of: (URL, Result<UIImage, Error>).self) { group in
            for url in urls {
                group.addTask {
                    do {
                        let image = try await self.downloadImage(from: url)
                        return (url, .success(image))
                    } catch {
                        return (url, .failure(error))
                    }
                }
            }
            
            var results: [URL: Result<UIImage, Error>] = [:]
            for await (url, result) in group {
                results[url] = result
            }
            return results
        }
    }
    
    func clearCache() {
        cache.removeAll()
        print("๐Ÿ—‘๏ธ ์บ์‹œ ์‚ญ์ œ ์™„๋ฃŒ")
    }
    
    func cacheSize() -> Int {
        cache.count
    }
}

// SwiftUI ViewModel
@MainActor
class ImageGalleryViewModel: ObservableObject {
    @Published var images: [URL: UIImage] = [:]
    @Published var downloadStates: [URL: DownloadState] = [:]
    @Published var isLoading = false
    
    private let imageURLs: [URL] = [
        URL(string: "https://picsum.photos/400/300?random=1")!,
        URL(string: "https://picsum.photos/400/300?random=2")!,
        URL(string: "https://picsum.photos/400/300?random=3")!,
        URL(string: "https://picsum.photos/400/300?random=4")!,
        URL(string: "https://picsum.photos/400/300?random=5")!,
    ]
    
    func loadAllImages() async {
        isLoading = true
        
        // ๋ชจ๋“  URL์„ downloading ์ƒํƒœ๋กœ ์ดˆ๊ธฐํ™”
        for url in imageURLs {
            downloadStates[url] = .downloading(progress: 0)
        }
        
        // ๋ณ‘๋ ฌ ๋‹ค์šด๋กœ๋“œ
        let results = await ImageDownloader.shared.downloadImages(from: imageURLs)
        
        // ๊ฒฐ๊ณผ ์ฒ˜๋ฆฌ
        for (url, result) in results {
            switch result {
            case .success(let image):
                images[url] = image
                downloadStates[url] = .completed(image)
            case .failure(let error):
                downloadStates[url] = .failed(error)
            }
        }
        
        isLoading = false
    }
    
    func loadSingleImage(url: URL) async {
        downloadStates[url] = .downloading(progress: 0)
        
        do {
            let image = try await ImageDownloader.shared.downloadImage(from: url)
            images[url] = image
            downloadStates[url] = .completed(image)
        } catch {
            downloadStates[url] = .failed(error)
        }
    }
    
    func clearCache() async {
        await ImageDownloader.shared.clearCache()
        images.removeAll()
        downloadStates.removeAll()
    }
}

// SwiftUI View
struct ImageGalleryView: View {
    @StateObject private var viewModel = ImageGalleryViewModel()
    
    var body: some View {
        NavigationView {
            ScrollView {
                LazyVGrid(columns: [GridItem(.adaptive(minimum: 150))], spacing: 16) {
                    ForEach(Array(viewModel.downloadStates.keys), id: \.self) { url in
                        ImageCell(url: url, state: viewModel.downloadStates[url] ?? .idle)
                    }
                }
                .padding()
            }
            .navigationTitle("์ด๋ฏธ์ง€ ๊ฐค๋Ÿฌ๋ฆฌ")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("๋ชจ๋‘ ๋กœ๋“œ") {
                        Task {
                            await viewModel.loadAllImages()
                        }
                    }
                }
                
                ToolbarItem(placement: .navigationBarLeading) {
                    Button("์บ์‹œ ์‚ญ์ œ") {
                        Task {
                            await viewModel.clearCache()
                        }
                    }
                }
            }
        }
    }
}

struct ImageCell: View {
    let url: URL
    let state: DownloadState
    
    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 12)
                .fill(Color.gray.opacity(0.2))
                .frame(height: 150)
            
            switch state {
            case .idle:
                Text("๋Œ€๊ธฐ ์ค‘")
                    .foregroundColor(.gray)
            
            case .downloading(let progress):
                VStack {
                    ProgressView()
                    Text("\(Int(progress * 100))%")
                        .font(.caption)
                }
            
            case .completed(let image):
                Image(uiImage: image)
                    .resizable()
                    .aspectRatio(contentMode: .fill)
                    .frame(height: 150)
                    .clipped()
                    .cornerRadius(12)
            
            case .failed(let error):
                VStack {
                    Image(systemName: "exclamationmark.triangle")
                        .foregroundColor(.red)
                    Text("์‹คํŒจ")
                        .font(.caption)
                        .foregroundColor(.red)
                }
            }
        }
    }
}

์ด ํ”„๋กœ์ ํŠธ์—์„œ ์šฐ๋ฆฌ๊ฐ€ ์‚ฌ์šฉํ•œ ๋ชจ๋“  ๊ฐœ๋…๋“ค:

โœ… Actor๋กœ ์บ์‹œ ๋™๊ธฐํ™”
โœ… TaskGroup์œผ๋กœ ๋ณ‘๋ ฌ ๋‹ค์šด๋กœ๋“œ
โœ… @MainActor๋กœ UI ์—…๋ฐ์ดํŠธ
โœ… async/await๋กœ ๊น”๋”ํ•œ ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ
โœ… Sendable๋กœ ํƒ€์ž… ์•ˆ์ „์„ฑ

์ด ์ •๋„๋ฉด ์‹ค๋ฌด์—์„œ๋„ ๋ฐ”๋กœ ์“ธ ์ˆ˜ ์žˆ๋Š” ์ˆ˜์ค€์ด์•ผ! ๐Ÿš€

๐Ÿ”ฎ ๋ฏธ๋ž˜: Structured Concurrency์˜ ๋ฐœ์ „

Swift์˜ ๋™์‹œ์„ฑ ๋ชจ๋ธ์€ ๊ณ„์† ๋ฐœ์ „ํ•˜๊ณ  ์žˆ์–ด.
์•ž์œผ๋กœ ์–ด๋–ค ๊ธฐ๋Šฅ๋“ค์ด ์ถ”๊ฐ€๋ ์ง€ ๊ฐ„๋‹จํžˆ ์‚ดํŽด๋ณด์ž! ๐ŸŒŸ

๐ŸŽฏ Custom Executors

ํ˜„์žฌ๋Š” ์‹œ์Šคํ…œ์ด ์ž๋™์œผ๋กœ Task๋ฅผ ์Šค๋ ˆ๋“œ์— ๋ฐฐ๋ถ„ํ•˜๋Š”๋ฐ,
๋ฏธ๋ž˜์—๋Š” ๊ฐœ๋ฐœ์ž๊ฐ€ ์ง์ ‘ ์‹คํ–‰ ํ™˜๊ฒฝ์„ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋  ๊ฑฐ์•ผ.
ํŠน์ • Task๋ฅผ ํŠน์ • ์Šค๋ ˆ๋“œ๋‚˜ ํ์—์„œ ์‹คํ–‰ํ•˜๋„๋ก ๊ฐ•์ œํ•  ์ˆ˜ ์žˆ๋Š” ๊ฑฐ์ง€!

๐ŸŽฏ Task Local Values ๊ฐœ์„ 

Task ๋‚ด์—์„œ๋งŒ ์œ ํšจํ•œ ๊ฐ’์„ ์ €์žฅํ•˜๋Š” ๊ธฐ๋Šฅ์ด ๋” ๊ฐ•๋ ฅํ•ด์งˆ ์˜ˆ์ •์ด์•ผ.
๋กœ๊น…, ํŠธ๋ ˆ์ด์‹ฑ, ์ปจํ…์ŠคํŠธ ์ „๋‹ฌ ๋“ฑ์— ์œ ์šฉํ•˜๊ฒŒ ์“ฐ์ผ ๊ฑฐ์•ผ.

// Task Local Values ์˜ˆ์‹œ
enum RequestID {
    @TaskLocal static var current: String?
}

func handleRequest() async {
    await RequestID.$current.withValue(UUID().uuidString) {
        await processRequest()
        // ๋ชจ๋“  ํ•˜์œ„ Task์—์„œ RequestID.current ์ ‘๊ทผ ๊ฐ€๋Šฅ
    }
}

๐ŸŽฏ ๋” ๋‚˜์€ ๋””๋ฒ„๊น… ๋„๊ตฌ

Xcode์˜ ๋™์‹œ์„ฑ ๋””๋ฒ„๊น… ๋„๊ตฌ๊ฐ€ ๊ณ„์† ๊ฐœ์„ ๋˜๊ณ  ์žˆ์–ด.
Task ํŠธ๋ฆฌ ์‹œ๊ฐํ™”, Actor ์ƒํƒœ ๋ชจ๋‹ˆํ„ฐ๋ง, ๋ฐ๋“œ๋ฝ ๊ฐ์ง€ ๋“ฑ
๊ฐœ๋ฐœ์ž ๊ฒฝํ—˜์ด ํ›จ์”ฌ ์ข‹์•„์งˆ ๊ฑฐ์•ผ! ๐Ÿ› ๏ธ

๐Ÿ“š ํ•™์Šต ๋ฆฌ์†Œ์Šค์™€ ๋‹ค์Œ ๋‹จ๊ณ„

์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์—ˆ๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ๐Ÿ‘
Swift ๋™์‹œ์„ฑ์˜ ํ•ต์‹ฌ ๊ฐœ๋…๋“ค์„ ๋ชจ๋‘ ๋‹ค๋ค˜์–ด.

์ด์ œ ์‹ค์ „์—์„œ ์ง์ ‘ ์จ๋ณด๋ฉด์„œ ์ต์ˆ™ํ•ด์ง€๋Š” ๊ฒŒ ์ค‘์š”ํ•ด.
์ž‘์€ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ๊ฑธ ๋งŒ๋“ค์–ด๋ด!

๐ŸŽฏ ์ถ”์ฒœ ํ•™์Šต ๊ฒฝ๋กœ
1๋‹จ๊ณ„: ๊ธฐ์ดˆ ๋‹ค์ง€๊ธฐ
โ€ข ๊ฐ„๋‹จํ•œ ๋„คํŠธ์›Œํฌ ์š”์ฒญ์„ async/await๋กœ ๋ณ€ํ™˜
โ€ข Task ์ƒ์„ฑ๊ณผ ์ทจ์†Œ ์—ฐ์Šต
โ€ข @MainActor๋กœ UI ์—…๋ฐ์ดํŠธ ํŒจํ„ด ์ตํžˆ๊ธฐ

2๋‹จ๊ณ„: ์ค‘๊ธ‰ ํŒจํ„ด
โ€ข Actor๋กœ ์บ์‹œ ์‹œ์Šคํ…œ ๊ตฌํ˜„
โ€ข TaskGroup์œผ๋กœ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ
โ€ข AsyncSequence๋กœ ์ŠคํŠธ๋ฆผ ์ฒ˜๋ฆฌ

3๋‹จ๊ณ„: ๊ณ ๊ธ‰ ํ™œ์šฉ
โ€ข ๋ณต์žกํ•œ ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง์— ์ ์šฉ
โ€ข ์„ฑ๋Šฅ ์ตœ์ ํ™”
โ€ข ์—๋Ÿฌ ์ฒ˜๋ฆฌ ์ „๋žต ์ˆ˜๋ฆฝ
โ€ข ํ…Œ์ŠคํŠธ ์ฝ”๋“œ ์ž‘์„ฑ

๐Ÿ“– ์ถ”์ฒœ ์ž๋ฃŒ

๊ณต์‹ ๋ฌธ์„œ:
โ€ข Swift.org - Concurrency ๊ฐ€์ด๋“œ
โ€ข WWDC ์„ธ์…˜: "Meet async/await in Swift"
โ€ข WWDC ์„ธ์…˜: "Protect mutable state with Swift actors"

์ปค๋ฎค๋‹ˆํ‹ฐ:
โ€ข Swift Forums - Concurrency ์„น์…˜
โ€ข Stack Overflow - swift-concurrency ํƒœ๊ทธ
โ€ข GitHub - ์˜คํ”ˆ์†Œ์Šค ํ”„๋กœ์ ํŠธ ๋ถ„์„

๊ทธ๋ฆฌ๊ณ  ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ Swift ์ „๋ฌธ๊ฐ€๋“ค์˜ ๋ฉ˜ํ† ๋ง์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ!
์‹ค๋ฌด ๊ฒฝํ—˜์ด ํ’๋ถ€ํ•œ ๊ฐœ๋ฐœ์ž์—๊ฒŒ ์ง์ ‘ ๋ฐฐ์šฐ๋ฉด ํ›จ์”ฌ ๋น ๋ฅด๊ฒŒ ์„ฑ์žฅํ•  ์ˆ˜ ์žˆ๊ฑฐ๋“ . ๐ŸŽ“

๐ŸŽฌ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€, ์—ฌ๊ธฐ๊นŒ์ง€ ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์–ด! ๐ŸŽ‰

Swift์˜ ๋™์‹œ์„ฑ ๋ชจ๋ธ์€ ์ฒ˜์Œ์—” ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ,
ํ•œ ๋ฒˆ ์ต์ˆ™ํ•ด์ง€๋ฉด ์ •๋ง ๊ฐ•๋ ฅํ•œ ๋„๊ตฌ๊ฐ€ ๋ผ.

์˜ˆ์ „์ฒ˜๋Ÿผ ์ฝœ๋ฐฑ ์ง€์˜ฅ์— ๋น ์ง€๊ฑฐ๋‚˜, ์Šค๋ ˆ๋“œ ๊ด€๋ฆฌ๋กœ ๋จธ๋ฆฌ ์•„ํ”Œ ์ผ๋„ ์—†๊ณ ,
๋ฐ์ดํ„ฐ ๋ ˆ์ด์Šค ๊ฑฑ์ •๋„ ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ๋Œ€์‹  ํ•ด์ฃผ๋‹ˆ๊นŒ ๋ง์ด์•ผ!

async/await๋กœ ์ฝ”๋“œ๋Š” ๋” ์ฝ๊ธฐ ์‰ฝ๊ฒŒ,
Actor๋กœ ๋ฐ์ดํ„ฐ๋Š” ๋” ์•ˆ์ „ํ•˜๊ฒŒ,
Task๋กœ ์‹คํ–‰์€ ๋” ํšจ์œจ์ ์œผ๋กœ!

์ด์ œ ๋‹น์‹ ๋„ ํ˜„๋Œ€์ ์ธ Swift ๊ฐœ๋ฐœ์ž๋กœ ํ•œ ๊ฑธ์Œ ๋” ๋‚˜์•„๊ฐ”์–ด. ๐Ÿš€

์‹ค์ „์—์„œ ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ๋‹ค๋ฉด, ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์งˆ๋ฌธํ•˜๊ฑฐ๋‚˜
๊ฒฝํ—˜ ๋งŽ์€ ๊ฐœ๋ฐœ์ž์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ.

๊ณ„์† ์ฝ”๋”ฉํ•˜๊ณ , ๊ณ„์† ๋ฐฐ์šฐ๊ณ , ๊ณ„์† ์„ฑ์žฅํ•˜์ž!
ํ™”์ดํŒ…! ๐Ÿ’ชโœจ

๐Ÿ’ก ๋งˆ์ง€๋ง‰ ํŒ
๋™์‹œ์„ฑ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ๋•Œ๋Š” ํ•ญ์ƒ ์ด ์„ธ ๊ฐ€์ง€๋ฅผ ๊ธฐ์–ตํ•ด:

1๏ธโƒฃ ์•ˆ์ „์„ฑ ์šฐ์„ : ๋น ๋ฅธ ๊ฒƒ๋ณด๋‹ค ์•ˆ์ „ํ•œ ๊ฒŒ ๋จผ์ €
2๏ธโƒฃ ๋ช…ํ™•์„ฑ ์ค‘์‹œ: ๋ณต์žกํ•œ ์ตœ์ ํ™”๋ณด๋‹ค ์ฝ๊ธฐ ์‰ฌ์šด ์ฝ”๋“œ
3๏ธโƒฃ ์ ์ง„์  ์ ์šฉ: ํ•œ ๋ฒˆ์— ๋‹ค ๋ฐ”๊พธ๋ ค ํ•˜์ง€ ๋ง๊ณ  ์กฐ๊ธˆ์”ฉ

ํ–‰๋ณตํ•œ ์ฝ”๋”ฉ ๋˜๊ธธ! ๐Ÿ˜Š
๐ŸŽ“ Swift Concurrency Master! async await Actor Task Main Actor Happy Coding! ๐Ÿš€โœจ
๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.