Ver3.0 전체 열람

Ver3.0 🚀 Grand Central Dispatch와 OperationQueue로 멀티스레딩 정복하기

2025.10.01

재능넷

댓글 0 전체 27 페이지

🚀 Grand Central Dispatch와 OperationQueue로 멀티스레딩 정복하기

안녕! 오늘은 iOS와 macOS 개발에서 빼놓을 수 없는 멀티스레딩 이야기를 해볼까 해. 🎯
혹시 앱을 만들다가 화면이 버벅거리거나, 데이터를 다운로드하는 동안 앱이 멈춰버린 경험 있어?
그럴 때 필요한 게 바로 멀티스레딩이야. 여러 작업을 동시에 처리해서 앱을 부드럽게 만드는 마법 같은 기술이지.

Apple은 개발자들에게 두 가지 강력한 도구를 제공해. 바로 Grand Central Dispatch(GCD)와 OperationQueue야.
이 둘은 멀티스레딩을 쉽게 구현할 수 있게 도와주는데, 각각 특징이 달라서 상황에 맞게 선택해야 해.
재능넷에서 프로그래밍 지식을 공유하는 많은 개발자들도 이 주제에 대해 자주 질문하고 답변을 나누곤 하지. 😊

멀티스레딩이 뭐길래? 🤔

먼저 기본부터 짚고 넘어가자. 멀티스레딩은 말 그대로 여러 개의 스레드를 사용하는 거야.
스레드는 프로그램이 작업을 실행하는 가장 작은 단위라고 생각하면 돼.
우리가 만드는 앱은 기본적으로 메인 스레드(Main Thread)에서 실행되는데, 이 친구가 UI를 담당해.

메인 스레드의 역할 🎨
메인 스레드는 화면에 보이는 모든 것을 관리해. 버튼을 누르면 반응하고, 스크롤하면 화면이 움직이고,
애니메이션이 부드럽게 실행되는 것도 다 메인 스레드 덕분이야.
그런데 만약 메인 스레드에서 시간이 오래 걸리는 작업(네트워크 요청, 대용량 파일 처리 등)을 하면 어떻게 될까?
앱이 멈춘 것처럼 보이고, 사용자는 답답함을 느끼게 돼. 😰

그래서 우리는 무거운 작업을 백그라운드 스레드로 보내야 해.
메인 스레드는 UI만 신경 쓰게 하고, 다른 작업들은 별도의 스레드에서 처리하는 거지.
이렇게 하면 앱이 항상 부드럽게 동작할 수 있어.

Grand Central Dispatch(GCD) 파헤치기 🔍

GCD는 Apple이 2009년에 도입한 멀티스레딩 기술이야.
C 언어 기반으로 만들어졌지만, Swift에서도 아주 편하게 사용할 수 있어.
GCD의 핵심 개념은 Dispatch Queue야. 작업을 큐에 넣으면 시스템이 알아서 적절한 스레드에 배정해서 실행해줘.

Dispatch Queue의 종류 📦

GCD에는 크게 두 가지 타입의 큐가 있어.

Serial Queue (직렬 큐)

한 번에 하나의 작업만 실행해. 마치 은행 창구에서 한 명씩 순서대로 업무를 보는 것과 같아.
먼저 들어온 작업이 끝나야 다음 작업이 시작돼.
특징: 순서 보장, 동기화 문제 없음 ✅

Concurrent Queue (동시 큐)

여러 작업을 동시에 실행할 수 있어. 여러 은행 창구가 동시에 열려있는 것과 비슷해.
작업들이 동시에 시작되지만, 끝나는 순서는 보장되지 않아.
특징: 빠른 처리, 순서 보장 안 됨 ⚡

GCD 사용법 - 기본편 💻

자, 이제 실제 코드를 볼까? Swift에서 GCD를 사용하는 건 정말 간단해.

// 메인 큐에서 UI 업데이트
DispatchQueue.main.async {
    self.label.text = "작업 완료!"
    self.activityIndicator.stopAnimating()
}

// 글로벌 큐에서 백그라운드 작업
DispatchQueue.global(qos: .background).async {
    // 시간이 오래 걸리는 작업
    let result = self.processHeavyData()
    
    // 결과를 메인 스레드에서 처리
    DispatchQueue.main.async {
        self.displayResult(result)
    }
}

위 코드를 보면 DispatchQueue.main과 DispatchQueue.global이 보이지?
main은 메인 스레드를 의미하고, global은 시스템이 관리하는 글로벌 큐를 의미해.

💡 QoS(Quality of Service)란?
작업의 우선순위를 지정하는 거야. 종류는 다음과 같아:
• userInteractive: 사용자와 직접 상호작용 (최고 우선순위) 🔴
• userInitiated: 사용자가 시작한 작업 (높은 우선순위) 🟠
• default: 기본값 🟡
• utility: 시간이 좀 걸려도 되는 작업 🟢
• background: 백그라운드 작업 (낮은 우선순위) 🔵
시스템은 이 우선순위를 보고 CPU 자원을 배분해.

커스텀 큐 만들기 🛠️

시스템 제공 큐 말고 직접 큐를 만들 수도 있어. 특정 작업을 위한 전용 큐가 필요할 때 유용하지.

// Serial Queue 생성
let serialQueue = DispatchQueue(label: "com.myapp.serialQueue")

// Concurrent Queue 생성
let concurrentQueue = DispatchQueue(label: "com.myapp.concurrentQueue", 
                                    attributes: .concurrent)

// 사용 예시
serialQueue.async {
    print("작업 1 시작")
    Thread.sleep(forTimeInterval: 2)
    print("작업 1 완료")
}

serialQueue.async {
    print("작업 2 시작")
    Thread.sleep(forTimeInterval: 1)
    print("작업 2 완료")
}

// 출력 순서: 작업 1 시작 → 작업 1 완료 → 작업 2 시작 → 작업 2 완료

Serial Queue는 순서가 보장되니까 데이터베이스 접근이나 파일 쓰기 같은 작업에 적합해.
여러 스레드가 동시에 같은 자원에 접근하면 문제가 생길 수 있거든. 🔒

동기 vs 비동기 실행 ⏱️

GCD에서는 작업을 동기(sync) 또는 비동기(async)로 실행할 수 있어.

async (비동기)
작업을 큐에 넣고 바로 다음 코드로 넘어가. 작업이 끝날 때까지 기다리지 않아.
대부분의 경우 이걸 사용해. 앱이 멈추지 않으니까! 🏃‍♂️

sync (동기)
작업을 큐에 넣고 완료될 때까지 기다려. 다음 코드는 작업이 끝난 후에 실행돼.
주의할 점: 메인 스레드에서 메인 큐에 sync를 호출하면 데드락이 발생해! ⚠️

// 비동기 실행 (일반적인 사용)
DispatchQueue.global().async {
    print("비동기 작업 시작")
    // 무거운 작업
    print("비동기 작업 완료")
}
print("이 코드는 바로 실행됨")

// 동기 실행 (신중하게 사용)
DispatchQueue.global().sync {
    print("동기 작업 시작")
    // 작업
    print("동기 작업 완료")
}
print("이 코드는 위 작업이 끝난 후 실행됨")

Dispatch Group으로 여러 작업 관리하기 👥

여러 개의 비동기 작업이 모두 끝났을 때 뭔가를 하고 싶다면? DispatchGroup을 사용하면 돼!

let group = DispatchGroup()

// 첫 번째 작업
group.enter()
DispatchQueue.global().async {
    print("이미지 1 다운로드 중...")
    Thread.sleep(forTimeInterval: 2)
    print("이미지 1 완료")
    group.leave()
}

// 두 번째 작업
group.enter()
DispatchQueue.global().async {
    print("이미지 2 다운로드 중...")
    Thread.sleep(forTimeInterval: 3)
    print("이미지 2 완료")
    group.leave()
}

// 세 번째 작업
group.enter()
DispatchQueue.global().async {
    print("이미지 3 다운로드 중...")
    Thread.sleep(forTimeInterval: 1)
    print("이미지 3 완료")
    group.leave()
}

// 모든 작업이 완료되면 실행
group.notify(queue: .main) {
    print("모든 이미지 다운로드 완료! 🎉")
    // UI 업데이트
}

enter()로 작업을 시작하고, leave()로 완료를 알려줘.
모든 작업이 끝나면 notify에 등록한 클로저가 실행돼. 정말 편리하지? 😊

⚠️ 주의사항
enter()와 leave()의 호출 횟수는 반드시 같아야 해!
enter()를 3번 했으면 leave()도 3번 해야 notify가 실행돼.
만약 균형이 안 맞으면 notify가 영원히 실행되지 않거나, 앱이 크래시될 수 있어.

Dispatch Barrier로 동기화하기 🚧

Concurrent Queue에서 특정 작업만 독점적으로 실행하고 싶을 때가 있어.
예를 들어, 여러 스레드가 데이터를 읽는 건 괜찮지만, 쓰기 작업은 혼자 해야 할 때 말이야.

let concurrentQueue = DispatchQueue(label: "com.myapp.dataQueue", 
                                    attributes: .concurrent)
var data: [String] = []

// 읽기 작업 (동시 실행 가능)
func readData() {
    concurrentQueue.async {
        print("데이터 읽기: \(data)")
    }
}

// 쓰기 작업 (독점 실행)
func writeData(_ value: String) {
    concurrentQueue.async(flags: .barrier) {
        print("데이터 쓰기: \(value)")
        data.append(value)
    }
}

// 사용
readData()  // 동시 실행 가능
readData()  // 동시 실행 가능
writeData("새 데이터")  // 다른 작업이 끝날 때까지 대기
readData()  // writeData가 끝난 후 실행

barrier 플래그를 사용하면 해당 작업이 실행될 때 다른 작업들이 모두 끝날 때까지 기다려.
그리고 barrier 작업이 끝나면 다시 동시 실행이 가능해져. 데이터 무결성을 지키는 좋은 방법이야! 🛡️

OperationQueue 깊이 알아보기 🎯

이제 OperationQueue로 넘어가볼까? GCD가 간단하고 빠르다면, OperationQueue는 좀 더 고급 기능을 제공해.
객체 지향적인 접근 방식이라 복잡한 작업 흐름을 관리하기에 좋아.

Operation의 기본 개념 📚

OperationQueue는 Operation 객체를 사용해. Operation은 실행할 작업을 캡슐화한 객체야.
두 가지 방법으로 만들 수 있어:

BlockOperation

클로저를 사용해서 간단하게 만드는 방법이야.
GCD의 클로저 방식과 비슷하지만, Operation의 기능을 사용할 수 있어.

let operation = BlockOperation {
    print("작업 실행")
}

Custom Operation

Operation 클래스를 상속받아서 만드는 방법이야.
복잡한 로직이나 재사용 가능한 작업에 적합해.

class MyOperation: Operation {
    override func main() {
        print("커스텀 작업")
    }
}

OperationQueue 사용하기 🚀

// OperationQueue 생성
let operationQueue = OperationQueue()

// 동시 실행 개수 설정 (기본값은 시스템이 결정)
operationQueue.maxConcurrentOperationCount = 3

// BlockOperation 추가
let operation1 = BlockOperation {
    print("Operation 1 시작")
    Thread.sleep(forTimeInterval: 2)
    print("Operation 1 완료")
}

let operation2 = BlockOperation {
    print("Operation 2 시작")
    Thread.sleep(forTimeInterval: 1)
    print("Operation 2 완료")
}

// 큐에 추가
operationQueue.addOperation(operation1)
operationQueue.addOperation(operation2)

// 또는 클로저로 바로 추가
operationQueue.addOperation {
    print("간단한 작업")
}

maxConcurrentOperationCount를 설정하면 동시에 실행되는 작업 수를 제한할 수 있어.
1로 설정하면 Serial Queue처럼 동작하고, 기본값(-1)은 시스템이 알아서 결정해.

의존성 관리 - OperationQueue의 강력한 무기 🔗

OperationQueue의 가장 큰 장점 중 하나가 바로 의존성 관리야.
"A 작업이 끝나야 B 작업을 시작한다"는 식의 순서를 쉽게 지정할 수 있어.

let downloadOperation = BlockOperation {
    print("이미지 다운로드 중...")
    Thread.sleep(forTimeInterval: 2)
    print("다운로드 완료")
}

let filterOperation = BlockOperation {
    print("필터 적용 중...")
    Thread.sleep(forTimeInterval: 1)
    print("필터 적용 완료")
}

let uploadOperation = BlockOperation {
    print("업로드 중...")
    Thread.sleep(forTimeInterval: 1)
    print("업로드 완료")
}

// 의존성 설정
filterOperation.addDependency(downloadOperation)  // 다운로드 후 필터
uploadOperation.addDependency(filterOperation)    // 필터 후 업로드

let queue = OperationQueue()
queue.addOperations([uploadOperation, filterOperation, downloadOperation], 
                    waitUntilFinished: false)

// 실행 순서: 다운로드 → 필터 → 업로드 (의존성에 따라 자동 정렬!)

큐에 추가하는 순서는 상관없어. 의존성만 제대로 설정하면 시스템이 알아서 올바른 순서로 실행해줘! 🎯
이건 GCD로는 구현하기 까다로운 기능이야. 재능넷의 개발자 커뮤니티에서도 이 기능 때문에 OperationQueue를 선호하는 사람들이 많아.

작업 취소하기 ❌

OperationQueue의 또 다른 장점은 작업을 취소할 수 있다는 거야.
사용자가 다운로드를 중단하거나, 화면을 벗어났을 때 불필요한 작업을 멈출 수 있어.

class DownloadOperation: Operation {
    override func main() {
        // 취소 확인
        guard !isCancelled else {
            print("작업이 취소되었습니다")
            return
        }
        
        print("다운로드 시작")
        
        for i in 1...10 {
            // 주기적으로 취소 확인
            if isCancelled {
                print("다운로드 중단됨 (진행률: \(i * 10)%)")
                return
            }
            
            Thread.sleep(forTimeInterval: 0.5)
            print("진행률: \(i * 10)%")
        }
        
        print("다운로드 완료")
    }
}

let operation = DownloadOperation()
let queue = OperationQueue()
queue.addOperation(operation)

// 2초 후 취소
DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
    operation.cancel()
    print("취소 요청 전송")
}

isCancelled 프로퍼티를 주기적으로 확인해서 취소 요청이 있으면 작업을 중단해.
GCD에서는 이런 취소 기능을 직접 구현해야 하는데, Operation은 기본으로 제공해줘서 편리해! 👍

💡 취소 시 주의사항
cancel()을 호출한다고 작업이 즉시 멈추는 건 아니야.
Operation 내부에서 isCancelled를 확인하고 직접 종료 처리를 해줘야 해.
특히 긴 작업의 경우, 중간중간 취소 여부를 확인하는 게 좋아.

우선순위 설정하기 ⭐

Operation에는 우선순위를 설정할 수 있어. 중요한 작업을 먼저 처리하고 싶을 때 유용하지.

let highPriorityOp = BlockOperation {
    print("중요한 작업")
}
highPriorityOp.queuePriority = .veryHigh

let normalOp = BlockOperation {
    print("일반 작업")
}
normalOp.queuePriority = .normal

let lowPriorityOp = BlockOperation {
    print("낮은 우선순위 작업")
}
lowPriorityOp.queuePriority = .veryLow

let queue = OperationQueue()
queue.addOperations([lowPriorityOp, normalOp, highPriorityOp], 
                    waitUntilFinished: false)

// 우선순위에 따라 실행 순서가 조정됨

우선순위는 다음과 같아:
• veryHigh: 가장 높음
• high: 높음
• normal: 보통 (기본값)
• low: 낮음
• veryLow: 가장 낮음

KVO로 작업 상태 관찰하기 👀

Operation은 KVO(Key-Value Observing)를 지원해서 작업의 상태 변화를 관찰할 수 있어.

let operation = BlockOperation {
    print("작업 실행 중...")
    Thread.sleep(forTimeInterval: 2)
    print("작업 완료")
}

// 완료 상태 관찰
operation.completionBlock = {
    print("✅ Operation 완료됨!")
}

// isFinished 프로퍼티 관찰
var observer: NSKeyValueObservation?
observer = operation.observe(\.isFinished, options: [.new]) { op, change in
    if change.newValue == true {
        print("작업이 종료되었습니다")
    }
}

let queue = OperationQueue()
queue.addOperation(operation)

completionBlock은 작업이 끝나면 자동으로 실행돼.
UI 업데이트나 후속 작업을 처리하기 좋아. 단, 이 블록은 작업이 실행된 스레드에서 실행되니까
UI 업데이트가 필요하면 메인 스레드로 전환해야 해!

GCD vs OperationQueue: 언제 뭘 써야 할까? 🤷‍♂️

자, 이제 두 가지 방법을 다 배웠으니 선택의 기로에 섰어.
"도대체 언제 GCD를 쓰고, 언제 OperationQueue를 써야 하지?" 🤔
각각의 장단점을 정리해볼게.

GCD를 선택해야 할 때 ⚡

✅ 간단하고 빠른 비동기 작업
✅ 코드가 짧고 명확할 때
✅ 성능이 중요한 경우
✅ 클로저 기반으로 충분할 때
✅ 시스템 레벨의 최적화가 필요할 때

예시:
• API 호출 후 UI 업데이트
• 이미지 다운로드
• 간단한 백그라운드 계산
• 타이머 기반 작업

OperationQueue를 선택해야 할 때 🎯

✅ 복잡한 작업 흐름 관리
✅ 작업 간 의존성이 있을 때
✅ 작업 취소가 필요할 때
✅ 우선순위 관리가 필요할 때
✅ 재사용 가능한 작업 단위

예시:
• 여러 단계의 데이터 처리
• 대용량 파일 다운로드 (취소 가능)
• 복잡한 이미지 처리 파이프라인
• 배치 작업 관리

🎓 실무 팁
대부분의 경우 GCD로 시작하는 게 좋아. 간단하고 빠르거든.
그러다가 작업이 복잡해지거나, 의존성 관리가 필요하거나, 취소 기능이 필요하면 OperationQueue로 전환해.
두 가지를 섞어 쓰는 것도 전혀 문제없어! 상황에 맞게 선택하면 돼. 😊

실전 예제: 이미지 다운로드 앱 만들기 📱

이론만 배우면 재미없으니까, 실제로 동작하는 예제를 만들어볼까?
여러 이미지를 동시에 다운로드하고, 진행 상황을 보여주고, 취소도 가능한 앱이야.

GCD 버전 🚀

class ImageDownloaderGCD {
    func downloadImages(urls: [URL], completion: @escaping ([UIImage]) -> Void) {
        var images: [UIImage] = []
        let group = DispatchGroup()
        let queue = DispatchQueue(label: "com.myapp.imageDownload", 
                                  attributes: .concurrent)
        
        for url in urls {
            group.enter()
            queue.async {
                if let data = try? Data(contentsOf: url),
                   let image = UIImage(data: data) {
                    // 스레드 안전하게 배열에 추가
                    DispatchQueue.main.async {
                        images.append(image)
                        group.leave()
                    }
                } else {
                    group.leave()
                }
            }
        }
        
        group.notify(queue: .main) {
            completion(images)
        }
    }
}

// 사용 예시
let downloader = ImageDownloaderGCD()
let urls = [
    URL(string: "https://example.com/image1.jpg")!,
    URL(string: "https://example.com/image2.jpg")!,
    URL(string: "https://example.com/image3.jpg")!
]

downloader.downloadImages(urls: urls) { images in
    print("다운로드 완료: \(images.count)개의 이미지")
    // UI 업데이트
}

OperationQueue 버전 🎯

class ImageDownloadOperation: Operation {
    let url: URL
    var downloadedImage: UIImage?
    
    init(url: URL) {
        self.url = url
        super.init()
    }
    
    override func main() {
        guard !isCancelled else { return }
        
        if let data = try? Data(contentsOf: url),
           let image = UIImage(data: data) {
            guard !isCancelled else { return }
            downloadedImage = image
        }
    }
}

class ImageDownloaderOperation {
    private let queue = OperationQueue()
    
    init() {
        queue.maxConcurrentOperationCount = 3  // 동시에 3개까지
    }
    
    func downloadImages(urls: [URL], completion: @escaping ([UIImage]) -> Void) {
        var operations: [ImageDownloadOperation] = []
        
        for url in urls {
            let operation = ImageDownloadOperation(url: url)
            operations.append(operation)
        }
        
        // 완료 블록 설정
        let completionOperation = BlockOperation {
            let images = operations.compactMap { $0.downloadedImage }
            DispatchQueue.main.async {
                completion(images)
            }
        }
        
        // 모든 다운로드 작업에 의존성 추가
        for operation in operations {
            completionOperation.addDependency(operation)
        }
        
        queue.addOperations(operations, waitUntilFinished: false)
        queue.addOperation(completionOperation)
    }
    
    func cancelAll() {
        queue.cancelAllOperations()
    }
}

// 사용 예시
let downloader = ImageDownloaderOperation()
let urls = [
    URL(string: "https://example.com/image1.jpg")!,
    URL(string: "https://example.com/image2.jpg")!,
    URL(string: "https://example.com/image3.jpg")!
]

downloader.downloadImages(urls: urls) { images in
    print("다운로드 완료: \(images.count)개의 이미지")
}

// 필요하면 취소
// downloader.cancelAll()

두 버전 모두 같은 기능을 하지만, OperationQueue 버전은 취소 기능이 있고 동시 실행 개수를 제한할 수 있어.
상황에 따라 선택하면 돼! 🎨

성능 최적화 팁 ⚡

멀티스레딩을 사용할 때 성능을 최대로 끌어올리는 몇 가지 팁을 알려줄게.

1. 스레드를 너무 많이 만들지 마 🚫
스레드를 무한정 만들면 오히려 성능이 떨어져. 스레드 간 전환(Context Switching)에도 비용이 들거든.
GCD는 시스템이 알아서 관리하지만, OperationQueue는 maxConcurrentOperationCount를 적절히 설정해줘.

2. 메인 스레드는 UI만 🎨
메인 스레드에서는 절대 무거운 작업을 하지 마. 0.1초만 블로킹되어도 사용자는 버벅임을 느껴.
네트워크 요청, 파일 I/O, 복잡한 계산은 모두 백그라운드로!

3. 적절한 QoS 선택 🎯
작업의 중요도에 맞는 QoS를 선택해. 모든 걸 userInteractive로 하면 시스템이 혼란스러워해.
• 사용자가 기다리는 작업: userInitiated
• 백그라운드 동기화: utility 또는 background

4. Race Condition 조심 ⚠️
여러 스레드가 같은 데이터에 접근하면 문제가 생길 수 있어.
Serial Queue, Dispatch Barrier, 또는 Lock을 사용해서 동기화해줘.

Race Condition 예방하기 🔒

// 문제가 있는 코드 ❌
class Counter {
    var count = 0
    
    func increment() {
        DispatchQueue.global().async {
            self.count += 1  // 여러 스레드에서 동시 접근!
        }
    }
}

// 해결 방법 1: Serial Queue ✅
class SafeCounter1 {
    private var count = 0
    private let queue = DispatchQueue(label: "com.myapp.counter")
    
    func increment() {
        queue.async {
            self.count += 1
        }
    }
    
    func getCount() -> Int {
        return queue.sync {
            return count
        }
    }
}

// 해결 방법 2: Dispatch Barrier ✅
class SafeCounter2 {
    private var count = 0
    private let queue = DispatchQueue(label: "com.myapp.counter", 
                                      attributes: .concurrent)
    
    func increment() {
        queue.async(flags: .barrier) {
            self.count += 1
        }
    }
    
    func getCount() -> Int {
        return queue.sync {
            return count
        }
    }
}

데이터 무결성은 정말 중요해. 버그를 찾기도 어렵고, 재현하기도 힘들거든.
처음부터 스레드 안전하게 코드를 작성하는 습관을 들이자! 🛡️

디버깅과 테스트 🐛

멀티스레딩 코드는 디버깅이 까다로워. 타이밍에 따라 결과가 달라질 수 있거든.
몇 가지 유용한 디버깅 팁을 알려줄게.

💡 Thread Sanitizer 사용하기
Xcode의 Thread Sanitizer는 Race Condition을 자동으로 찾아줘.
Scheme 설정에서 "Thread Sanitizer"를 활성화하고 앱을 실행하면 돼.
문제가 발견되면 정확한 위치를 알려주니까 정말 유용해!

// 현재 스레드 확인하기
func printCurrentThread() {
    if Thread.isMainThread {
        print("🎨 메인 스레드에서 실행 중")
    } else {
        print("⚙️ 백그라운드 스레드에서 실행 중")
        print("스레드 이름: \(Thread.current.name ?? "이름 없음")")
    }
}

// 사용 예시
DispatchQueue.main.async {
    printCurrentThread()  // 메인 스레드
}

DispatchQueue.global().async {
    printCurrentThread()  // 백그라운드 스레드
}

성능 측정하기 ⏱️

// 실행 시간 측정
func measureTime(label: String, block: () -> Void) {
    let start = CFAbsoluteTimeGetCurrent()
    block()
    let end = CFAbsoluteTimeGetCurrent()
    print("\(label) 실행 시간: \(String(format: "%.4f", end - start))초")
}

// 사용 예시
measureTime(label: "이미지 처리") {
    // 무거운 작업
    processImages()
}

// 비동기 작업 측정
let start = CFAbsoluteTimeGetCurrent()
DispatchQueue.global().async {
    // 작업
    let end = CFAbsoluteTimeGetCurrent()
    print("실행 시간: \(end - start)초")
}

실무에서 자주 하는 실수들 ⚠️

경험 많은 개발자들도 가끔 실수하는 것들을 정리해봤어. 미리 알고 있으면 시간을 많이 절약할 수 있어!

실수 1: 메인 스레드에서 sync 호출 💥

// 데드락 발생! ❌
DispatchQueue.main.sync {
    print("이 코드는 실행되지 않음")
}

메인 스레드에서 메인 큐에 sync를 호출하면 데드락이 발생해.
메인 스레드는 자기 자신이 끝나기를 기다리게 되거든. 절대 하지 마!

실수 2: 백그라운드에서 UI 업데이트 🎨

// 크래시 위험! ❌
DispatchQueue.global().async {
    self.label.text = "완료"  // UI는 메인 스레드에서만!
}

UIKit은 스레드 안전하지 않아. 모든 UI 업데이트는 메인 스레드에서 해야 해.

// 올바른 방법 ✅
DispatchQueue.global().async {
    let result = self.heavyCalculation()
    DispatchQueue.main.async {
        self.label.text = result
    }
}

실수 3: Strong Reference Cycle 🔄

// 메모리 누수! ❌
DispatchQueue.global().async {
    self.processData()  // self를 강하게 참조
}

클로저에서 self를 캡처하면 순환 참조가 발생할 수 있어.

// 올바른 방법 ✅
DispatchQueue.global().async { [weak self] in
    guard let self = self else { return }
    self.processData()
}

실수 4: DispatchGroup의 enter/leave 불균형 ⚖️

// notify가 실행 안 됨! ❌
let group = DispatchGroup()
group.enter()
DispatchQueue.global().async {
    // 작업
    // leave()를 깜빡함!
}
group.notify(queue: .main) {
    print("영원히 실행 안 됨")
}

enter()와 leave()는 반드시 쌍을 이뤄야 해. 하나라도 빠지면 notify가 실행 안 돼!

고급 패턴: async/await와의 조합 🚀

iOS 13부터 Swift에 async/await가 도입되면서 비동기 프로그래밍이 훨씬 쉬워졌어.
GCD, OperationQueue와 함께 사용하면 더욱 강력해져!

// GCD를 async/await로 감싸기
func downloadImage(from url: URL) async throws -> UIImage {
    return try await withCheckedThrowingContinuation { continuation in
        DispatchQueue.global().async {
            do {
                let data = try Data(contentsOf: url)
                if let image = UIImage(data: data) {
                    continuation.resume(returning: image)
                } else {
                    continuation.resume(throwing: ImageError.invalidData)
                }
            } catch {
                continuation.resume(throwing: error)
            }
        }
    }
}

// 사용
Task {
    do {
        let image = try await downloadImage(from: url)
        imageView.image = image
    } catch {
        print("에러: \(error)")
    }
}

async/await는 코드를 순차적으로 읽을 수 있게 해줘서 가독성이 훨씬 좋아.
하지만 GCD와 OperationQueue의 강력한 기능들(QoS, 의존성 관리 등)은 여전히 유용하니까
상황에 맞게 조합해서 사용하면 최고야! 🎯

실전 프로젝트 아이디어 💡

배운 내용을 실습해볼 수 있는 프로젝트 아이디어를 몇 가지 제안할게.

프로젝트 1: 이미지 필터 앱

여러 필터를 동시에 적용해서 미리보기를 보여주는 앱.
사용 기술:
• OperationQueue로 필터 작업 관리
• 의존성으로 순차 처리
• 취소 기능으로 불필요한 작업 중단

프로젝트 2: 파일 다운로더

여러 파일을 동시에 다운로드하고 진행률을 표시하는 앱.
사용 기술:
• GCD로 동시 다운로드
• DispatchGroup으로 완료 감지
• 메인 스레드에서 UI 업데이트

프로젝트 3: 데이터 동기화 앱

로컬 데이터베이스와 서버를 동기화하는 앱.
사용 기술:
• Serial Queue로 데이터 무결성 보장
• OperationQueue로 복잡한 동기화 로직
• 우선순위로 중요한 데이터 먼저 처리

마무리하며 🎓

와, 여기까지 오느라 수고했어! 멀티스레딩은 처음엔 어렵게 느껴질 수 있지만,
계속 연습하다 보면 자연스럽게 손에 익게 돼. 🎯

핵심 정리 📝

GCD (Grand Central Dispatch)
• 간단하고 빠른 비동기 처리
• 클로저 기반의 직관적인 API
• 시스템 레벨 최적화
• 가벼운 작업에 최적

OperationQueue
• 객체 지향적 접근
• 의존성 관리 기능
• 작업 취소 및 우선순위 설정
• 복잡한 작업 흐름에 최적

공통 주의사항
• UI는 항상 메인 스레드에서
• Race Condition 조심
• Strong Reference Cycle 방지
• 적절한 QoS 선택

멀티스레딩은 현대 앱 개발에서 필수적인 기술이야.
사용자들은 부드럽고 반응성 좋은 앱을 원하거든. 📱
오늘 배운 내용을 바탕으로 멋진 앱을 만들어봐!

재능넷 같은 플랫폼에서 다른 개발자들과 지식을 나누는 것도 좋은 학습 방법이야.
질문하고, 답변하고, 코드를 공유하면서 함께 성장할 수 있거든. 🌱
혹시 막히는 부분이 있으면 주저하지 말고 커뮤니티에 물어봐. 다들 기꺼이 도와줄 거야!

멀티스레딩 마스터가 되는 그날까지, 화이팅! 💪✨
버그 없는 코드, 부드러운 앱을 만드는 개발자가 되길 응원할게! 🚀

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.