Ver3.0 ๐ 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 ์ ๋ฐ์ดํธ ํจํด
- โ ์ค๋ฌด์์ ์์ฃผ ๋ง์ฃผ์น๋ ํจ์ ๊ณผ ํด๊ฒฐ์ฑ
๐ 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๋ฅผ ๋ง๋ค ๋ ์ฐ์ ์์๋ฅผ ์ง์ ํ ์ ์์ด:
โข .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๋ฅผ ์ฌ์ฉํด์ผ ํด.
๐ก๏ธ 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์ ์ฅ์ :
โข ๋ฐ์ดํฐ ๋ ์ด์ค ์๋ ๋ฐฉ์ง
โข ์ปดํ์ผ ํ์์ ์์ ์ฑ ์ฒดํฌ
โข ๋ช ์์ ์ธ ๋์์ฑ ์ ์ด (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 ์
๋ฐ์ดํธ๋ง ๋ฉ์ธ ์ค๋ ๋์์ ํ ์ ์์ด. ์๋ฒฝํ ์กฐํฉ์ด์ง! โจ
๐ฆ Sendable: ์์ ํ ๋ฐ์ดํฐ ์ ๋ฌ์ ๋น๋ฐ
Task๋ Actor ์ฌ์ด์์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ์ ๋, ์ค์ํ ๊ฒ ํ๋ ์์ด.
๋ฐ๋ก ๊ทธ ๋ฐ์ดํฐ๊ฐ ๋์์ฑ ํ๊ฒฝ์์ ์์ ํ๊ฐ?์ผ. ๐
Swift๋ ์ด๊ฑธ Sendable ํ๋กํ ์ฝ๋ก ํํํด.
Sendable์ ์ฑํํ ํ์
์ "๋๋ ์ฌ๋ฌ Task ์ฌ์ด์์ ์์ ํ๊ฒ ์ ๋ฌ๋ ์ ์์ด์!"๋ผ๊ณ ๋ณด์ฅํ๋ ๊ฑฐ์ง.
โ ์๋์ผ๋ก 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 ๊ธฐ๋ณธ ๊ธฐ๋ฅ๋ง์ผ๋ก๋ ์ถฉ๋ถํด! ๐
โ ๏ธ ํํ ์ค์์ ํด๊ฒฐ์ฑ
์, ์ด์ ์ค์ ์์ ์์ฃผ ๋ง์ฃผ์น๋ ํจ์ ๋ค์ ์์๋ณด์!
๋๋ ์ฒ์์ ์ด๋ฐ ์ค์ ์์ฒญ ๋ง์ด ํ์ด. ๐
๋ฏธ๋ฆฌ ์์๋๋ฉด ์๊ฐ ์์ฒญ ์ ์ฝํ ์ ์์ด!
๐จ ์ค์ 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๏ธโฃ ์ ์ง์ ์ ์ฉ: ํ ๋ฒ์ ๋ค ๋ฐ๊พธ๋ ค ํ์ง ๋ง๊ณ ์กฐ๊ธ์ฉ
ํ๋ณตํ ์ฝ๋ฉ ๋๊ธธ! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.