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

// 동기적으로 실행 (주의: 메인 스레드에서 호출하면 데드락!)
DispatchQueue.main.sync {
    // 이 코드는 위험해! 메인 스레드에서 호출하면 앱이 멈춰버려
}

// QoS 우선순위별 글로벌 큐 사용
// 1. User Interactive - 가장 높은 우선순위 (UI 애니메이션 등)
DispatchQueue.global(qos: .userInteractive).async {
    // 즉각적인 반응이 필요한 작업
}

// 2. User Initiated - 높은 우선순위 (사용자가 시작한 작업)
DispatchQueue.global(qos: .userInitiated).async {
    // 사용자가 기다리는 작업 (검색, 파일 열기 등)
}

// 3. Default - 기본 우선순위
DispatchQueue.global(qos: .default).async {
    // 일반적인 작업
}

// 4. Utility - 낮은 우선순위 (진행 표시가 있는 긴 작업)
DispatchQueue.global(qos: .utility).async {
    // 다운로드, 데이터 가져오기 등
}

// 5. Background - 가장 낮은 우선순위 (사용자가 인지하지 못하는 작업)
DispatchQueue.global(qos: .background).async {
    // 백업, 동기화, 인덱싱 등
}

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

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

// QoS와 함께 생성
let customQueue = DispatchQueue(label: "com.myapp.customQueue",
                                qos: .userInitiated,
                                attributes: .concurrent)

// 사용 예시
serialQueue.async {
    print("순차적으로 실행되는 작업 1")
}

serialQueue.async {
    print("순차적으로 실행되는 작업 2")
}

concurrentQueue.async {
    print("동시에 실행될 수 있는 작업 1")
}

concurrentQueue.async {
    print("동시에 실행될 수 있는 작업 2")
}

// async 예시 - 논블로킹
print("1. 시작")
DispatchQueue.global().async {
    print("2. 백그라운드 작업 중...")
    sleep(2)
    print("3. 백그라운드 작업 완료")
}
print("4. 계속 진행")

// 출력 순서: 1 -> 4 -> 2 -> 3 (4가 2보다 먼저!)

// sync 예시 - 블로킹
print("1. 시작")
DispatchQueue.global().sync {
    print("2. 백그라운드 작업 중...")
    sleep(2)
    print("3. 백그라운드 작업 완료")
}
print("4. 작업 완료 후 진행")

// 출력 순서: 1 -> 2 -> 3 -> 4 (순서대로!)

// ⚠️ 데드락 주의!
DispatchQueue.main.async {
    // 메인 스레드에서 실행 중
    DispatchQueue.main.sync {
        // 이건 데드락! 메인 큐가 자기 자신을 기다리게 됨
        print("실행되지 않아!")
    }
}

// 패턴 1: 기본 형태
func loadUserData() {
    // 로딩 표시
    activityIndicator.startAnimating()
    
    // 백그라운드에서 데이터 로드
    DispatchQueue.global(qos: .userInitiated).async {
        // 네트워크 요청이나 무거운 작업
        let userData = self.fetchUserDataFromServer()
        
        // 메인 스레드에서 UI 업데이트
        DispatchQueue.main.async {
            self.nameLabel.text = userData.name
            self.emailLabel.text = userData.email
            self.activityIndicator.stopAnimating()
        }
    }
}

// 패턴 2: 여러 이미지 동시 다운로드
func downloadImages(urls: [URL]) {
    let group = DispatchGroup()
    var images: [UIImage] = []
    
    for url in urls {
        group.enter()
        DispatchQueue.global(qos: .userInitiated).async {
            if let data = try? Data(contentsOf: url),
               let image = UIImage(data: data) {
                images.append(image)
            }
            group.leave()
        }
    }
    
    group.notify(queue: .main) {
        // 모든 이미지 다운로드 완료
        self.displayImages(images)
    }
}

// 패턴 3: 에러 처리 포함
func processData() {
    DispatchQueue.global(qos: .userInitiated).async {
        do {
            let result = try self.heavyComputation()
            
            DispatchQueue.main.async {
                self.showResult(result)
            }
        } catch {
            DispatchQueue.main.async {
                self.showError(error)
            }
        }
    }
}

// 방법 1: enter/leave 사용
let group = DispatchGroup()

group.enter()
DispatchQueue.global().async {
    print("작업 1 시작")
    sleep(2)
    print("작업 1 완료")
    group.leave()
}

group.enter()
DispatchQueue.global().async {
    print("작업 2 시작")
    sleep(1)
    print("작업 2 완료")
    group.leave()
}

group.enter()
DispatchQueue.global().async {
    print("작업 3 시작")
    sleep(3)
    print("작업 3 완료")
    group.leave()
}

// 모든 작업이 완료되면 실행
group.notify(queue: .main) {
    print("🎉 모든 작업 완료!")
}

// 방법 2: async(group:) 사용
let group2 = DispatchGroup()
let queue = DispatchQueue.global(qos: .userInitiated)

queue.async(group: group2) {
    print("그룹 작업 1")
}

queue.async(group: group2) {
    print("그룹 작업 2")
}

group2.notify(queue: .main) {
    print("그룹 작업 모두 완료!")
}

// 방법 3: wait으로 동기적으로 기다리기 (주의해서 사용!)
let group3 = DispatchGroup()

group3.enter()
DispatchQueue.global().async {
    sleep(2)
    print("작업 완료")
    group3.leave()
}

// 최대 5초 대기
let result = group3.wait(timeout: .now() + 5)
if result == .success {
    print("시간 내에 완료됨")
} else {
    print("타임아웃!")
}

class ThreadSafeArray<T> {
    private var array: [T] = []
    private let queue = DispatchQueue(label: "com.myapp.arrayQueue", 
                                      attributes: .concurrent)
    
    // 읽기는 동시에 가능
    func get(at index: Int) -> T? {
        var result: T?
        queue.sync {
            guard index < array.count else { return }
            result = array[index]
        }
        return result
    }
    
    // 쓰기는 배리어로 독점
    func append(_ element: T) {
        queue.async(flags: .barrier) {
            self.array.append(element)
        }
    }
    
    // 전체 배열 읽기
    var allElements: [T] {
        var result: [T] = []
        queue.sync {
            result = array
        }
        return result
    }
    
    // 쓰기 작업
    func removeAll() {
        queue.async(flags: .barrier) {
            self.array.removeAll()
        }
    }
}

// 사용 예시
let safeArray = ThreadSafeArray<Int>()

// 여러 스레드에서 동시에 추가해도 안전!
DispatchQueue.concurrentPerform(iterations: 100) { index in
    safeArray.append(index)
}

print("총 개수: \(safeArray.allElements.count)")

// 3초 후 실행
DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
    print("3초가 지났어!")
    self.showMessage("시간 초과")
}

// 밀리초 단위로도 가능
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(500)) {
    print("0.5초 후 실행")
}

// 실전 예시: 스플래시 화면
func showSplashScreen() {
    splashView.isHidden = false
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
        UIView.animate(withDuration: 0.5) {
            self.splashView.alpha = 0
        } completion: { _ in
            self.splashView.isHidden = true
            self.splashView.alpha = 1
        }
    }
}

// 여러 단계 지연 실행
func showSequentialMessages() {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
        print("1초 후: 첫 번째 메시지")
    }
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
        print("2초 후: 두 번째 메시지")
    }
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
        print("3초 후: 세 번째 메시지")
    }
}

// 동시에 3개까지만 실행
let semaphore = DispatchSemaphore(value: 3)

func downloadFile(url: URL) {
    DispatchQueue.global().async {
        semaphore.wait() // 세마포어 획득 (카운트 -1)
        
        print("다운로드 시작: \(url)")
        // 실제 다운로드 작업
        sleep(2)
        print("다운로드 완료: \(url)")
        
        semaphore.signal() // 세마포어 반환 (카운트 +1)
    }
}

// 10개 파일 다운로드 시도 (하지만 동시에는 3개만)
let urls = (1...10).map { URL(string: "https://example.com/file\($0)")! }
urls.forEach { downloadFile(url: $0) }

// 실전 예시: API 요청 제한
class APIManager {
    private let semaphore = DispatchSemaphore(value: 5) // 동시 5개 제한
    
    func request(endpoint: String, completion: @escaping (Data?) -> Void) {
        DispatchQueue.global(qos: .userInitiated).async {
            self.semaphore.wait()
            
            // API 요청
            let data = self.performRequest(endpoint)
            
            DispatchQueue.main.async {
                completion(data)
            }
            
            self.semaphore.signal()
        }
    }
    
    private func performRequest(_ endpoint: String) -> Data? {
        // 실제 네트워크 요청 로직
        return nil
    }
}

// OperationQueue 생성
let operationQueue = OperationQueue()

// 큐 이름 설정 (디버깅에 유용)
operationQueue.name = "com.myapp.operationQueue"

// 동시 실행 개수 제한
operationQueue.maxConcurrentOperationCount = 3

// QoS 설정
operationQueue.qualityOfService = .userInitiated

// BlockOperation 추가
let operation1 = BlockOperation {
    print("작업 1 실행")
    sleep(2)
    print("작업 1 완료")
}

operationQueue.addOperation(operation1)

// 클로저로 직접 추가
operationQueue.addOperation {
    print("작업 2 실행")
}

// 여러 작업 한번에 추가
let operations = (1...5).map { index in
    BlockOperation {
        print("작업 \(index)")
    }
}
operationQueue.addOperations(operations, waitUntilFinished: false)

// 메인 큐 사용
OperationQueue.main.addOperation {
    // UI 업데이트
    self.label.text = "완료!"
}

// 작업 생성
let downloadOperation = BlockOperation {
    print("1. 이미지 다운로드 중...")
    sleep(2)
    print("1. 다운로드 완료!")
}

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

let uploadOperation = BlockOperation {
    print("3. 업로드 중...")
    sleep(1)
    print("3. 업로드 완료!")
}

// 의존성 설정: 다운로드 -> 필터 -> 업로드 순서
filterOperation.addDependency(downloadOperation)
uploadOperation.addDependency(filterOperation)

// 큐에 추가 (순서는 상관없어!)
let queue = OperationQueue()
queue.addOperations([uploadOperation, filterOperation, downloadOperation], 
                    waitUntilFinished: false)

// 실행 순서: downloadOperation -> filterOperation -> uploadOperation

// 복잡한 의존성 예시
let fetchDataOp = BlockOperation { print("데이터 가져오기") }
let parseDataOp = BlockOperation { print("데이터 파싱") }
let saveDataOp = BlockOperation { print("데이터 저장") }
let updateUIOp = BlockOperation { print("UI 업데이트") }

parseDataOp.addDependency(fetchDataOp)
saveDataOp.addDependency(parseDataOp)
updateUIOp.addDependency(saveDataOp)

let queue2 = OperationQueue()
queue2.addOperations([updateUIOp, saveDataOp, parseDataOp, fetchDataOp], 
                     waitUntilFinished: false)

// 취소 가능한 Operation 만들기
let cancellableOperation = BlockOperation {
    for i in 1...10 {
        // 취소 확인
        if BlockOperation.current()?.isCancelled == true {
            print("작업이 취소되었습니다!")
            return
        }
        
        print("진행 중: \(i * 10)%")
        sleep(1)
    }
    print("작업 완료!")
}

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

// 2초 후 취소
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
    cancellableOperation.cancel()
}

// 큐의 모든 작업 취소
queue.cancelAllOperations()

// Custom Operation에서 취소 처리
class DownloadOperation: Operation {
    let url: URL
    
    init(url: URL) {
        self.url = url
    }
    
    override func main() {
        guard !isCancelled else { return }
        
        print("다운로드 시작: \(url)")
        
        // 다운로드 작업을 여러 단계로 나눠서 취소 확인
        for i in 1...10 {
            if isCancelled {
                print("다운로드 취소됨")
                return
            }
            
            // 실제 다운로드 로직
            sleep(1)
            print("진행: \(i * 10)%")
        }
        
        print("다운로드 완료!")
    }
}

// 사용 예시
let downloadOp = DownloadOperation(url: URL(string: "https://example.com/file")!)
queue.addOperation(downloadOp)

// 필요시 취소
downloadOp.cancel()

// 이미지 다운로드 Operation
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) {
            downloadedImage = image
        }
    }
}

// 비동기 Operation (고급)
class AsyncOperation: Operation {
    enum State: String {
        case ready, executing, finished
        
        fileprivate var keyPath: String {
            return "is\(rawValue.capitalized)"
        }
    }
    
    var state = State.ready {
        willSet {
            willChangeValue(forKey: newValue.keyPath)
            willChangeValue(forKey: state.keyPath)
        }
        didSet {
            didChangeValue(forKey: oldValue.keyPath)
            didChangeValue(forKey: state.keyPath)
        }
    }
    
    override var isReady: Bool {
        return super.isReady && state == .ready
    }
    
    override var isExecuting: Bool {
        return state == .executing
    }
    
    override var isFinished: Bool {
        return state == .finished
    }
    
    override var isAsynchronous: Bool {
        return true
    }
    
    override func start() {
        if isCancelled {
            state = .finished
            return
        }
        
        main()
        state = .executing
    }
    
    override func cancel() {
        super.cancel()
        state = .finished
    }
}

// 비동기 네트워크 Operation
class NetworkOperation: AsyncOperation {
    let url: URL
    var data: Data?
    
    init(url: URL) {
        self.url = url
    }
    
    override func main() {
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            guard let self = self else { return }
            
            if !self.isCancelled {
                self.data = data
            }
            
            self.state = .finished
        }.resume()
    }
}

// 사용 예시
let queue = OperationQueue()

let imageOp = ImageDownloadOperation(url: URL(string: "https://example.com/image.jpg")!)
let networkOp = NetworkOperation(url: URL(string: "https://api.example.com/data")!)

// 완료 블록 설정
imageOp.completionBlock = {
    if let image = imageOp.downloadedImage {
        OperationQueue.main.addOperation {
            // UI 업데이트
            print("이미지 다운로드 완료!")
        }
    }
}

queue.addOperations([imageOp, networkOp], waitUntilFinished: false)

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

class GCDImageDownloader {
    private let downloadQueue = DispatchQueue(label: "com.myapp.imageDownload", 
                                              attributes: .concurrent)
    private let cacheQueue = DispatchQueue(label: "com.myapp.imageCache")
    private var imageCache: [URL: UIImage] = [:]
    
    func downloadImages(urls: [URL], 
                       progress: @escaping (Int, Int) -> Void,
                       completion: @escaping ([UIImage]) -> Void) {
        let group = DispatchGroup()
        var downloadedImages: [UIImage] = []
        var completedCount = 0
        
        for url in urls {
            group.enter()
            downloadQueue.async {
                // 캐시 확인
                var cachedImage: UIImage?
                self.cacheQueue.sync {
                    cachedImage = self.imageCache[url]
                }
                
                if let image = cachedImage {
                    // 캐시된 이미지 사용
                    downloadedImages.append(image)
                    completedCount += 1
                    
                    DispatchQueue.main.async {
                        progress(completedCount, urls.count)
                    }
                    
                    group.leave()
                } else {
                    // 다운로드
                    if let data = try? Data(contentsOf: url),
                       let image = UIImage(data: data) {
                        // 캐시에 저장
                        self.cacheQueue.async(flags: .barrier) {
                            self.imageCache[url] = image
                        }
                        
                        downloadedImages.append(image)
                        completedCount += 1
                        
                        DispatchQueue.main.async {
                            progress(completedCount, urls.count)
                        }
                    }
                    
                    group.leave()
                }
            }
        }
        
        group.notify(queue: .main) {
            completion(downloadedImages)
        }
    }
    
    func clearCache() {
        cacheQueue.async(flags: .barrier) {
            self.imageCache.removeAll()
        }
    }
}

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

downloader.downloadImages(urls: imageURLs) { completed, total in
    print("진행: \(completed)/\(total)")
    // 프로그레스 바 업데이트
} completion: { images in
    print("다운로드 완료! 총 \(images.count)개")
    // 이미지 표시
}

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) {
            guard !isCancelled else { return }
            downloadedImage = UIImage(data: data)
        }
    }
}

class OperationImageDownloader {
    private let downloadQueue = OperationQueue()
    private var imageCache: [URL: UIImage] = [:]
    private let cacheLock = NSLock()
    
    init() {
        downloadQueue.name = "com.myapp.imageDownloadQueue"
        downloadQueue.maxConcurrentOperationCount = 4
    }
    
    func downloadImages(urls: [URL],
                       progress: @escaping (Int, Int) -> Void,
                       completion: @escaping ([UIImage]) -> Void) {
        var operations: [ImageDownloadOperation] = []
        var downloadedImages: [UIImage] = []
        var completedCount = 0
        
        for url in urls {
            // 캐시 확인
            cacheLock.lock()
            if let cachedImage = imageCache[url] {
                cacheLock.unlock()
                downloadedImages.append(cachedImage)
                completedCount += 1
                DispatchQueue.main.async {
                    progress(completedCount, urls.count)
                }
                continue
            }
            cacheLock.unlock()
            
            // 다운로드 Operation 생성
            let operation = ImageDownloadOperation(url: url)
            
            operation.completionBlock = { [weak self, weak operation] in
                guard let self = self,
                      let operation = operation,
                      !operation.isCancelled,
                      let image = operation.downloadedImage else { return }
                
                // 캐시에 저장
                self.cacheLock.lock()
                self.imageCache[url] = image
                self.cacheLock.unlock()
                
                downloadedImages.append(image)
                completedCount += 1
                
                DispatchQueue.main.async {
                    progress(completedCount, urls.count)
                    
                    if completedCount == urls.count {
                        completion(downloadedImages)
                    }
                }
            }
            
            operations.append(operation)
        }
        
        downloadQueue.addOperations(operations, waitUntilFinished: false)
    }
    
    func cancelAll() {
        downloadQueue.cancelAllOperations()
    }
    
    func clearCache() {
        cacheLock.lock()
        imageCache.removeAll()
        cacheLock.unlock()
    }
}

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

downloader.downloadImages(urls: imageURLs) { completed, total in
    print("진행: \(completed)/\(total)")
} completion: { images in
    print("다운로드 완료! 총 \(images.count)개")
}

// 필요시 취소
// downloader.cancelAll()

// ❌ 데드락 발생 예시
DispatchQueue.main.async {
    // 메인 스레드에서 실행 중
    DispatchQueue.main.sync {
        // 메인 큐가 자기 자신을 기다림 -> 데드락!
        print("실행 안 됨")
    }
}

// ❌ 상호 데드락
let queue1 = DispatchQueue(label: "queue1")
let queue2 = DispatchQueue(label: "queue2")

queue1.async {
    queue2.sync {
        // queue2를 기다림
        queue1.sync {
            // queue1을 기다림 -> 데드락!
        }
    }
}

// ✅ 올바른 방법
DispatchQueue.main.async {
    // 메인 스레드에서 실행 중
    DispatchQueue.main.async {  // sync 대신 async 사용
        print("정상 실행!")
    }
}

// ✅ 다른 큐 사용
DispatchQueue.main.async {
    DispatchQueue.global().async {  // 다른 큐 사용
        print("정상 실행!")
    }
}

// ❌ 레이스 컨디션 발생
class UnsafeCounter {
    var count = 0
    
    func increment() {
        count += 1  // 여러 스레드에서 동시 접근 -> 문제!
    }
}

let counter = UnsafeCounter()
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
    counter.increment()
}
print(counter.count)  // 1000이 아닐 수 있음!

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

// ✅ Barrier로 해결
class BarrierCounter {
    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 { count }
    }
}

// ✅ NSLock으로 해결
class LockedCounter {
    private var count = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        count += 1
        lock.unlock()
    }
    
    func getCount() -> Int {
        lock.lock()
        defer { lock.unlock() }
        return count
    }
}

// ❌ 잘못된 예시
DispatchQueue.global().async {
    let data = self.fetchData()
    self.label.text = "완료"  // 백그라운드에서 UI 업데이트 -> 위험!
    self.tableView.reloadData()  // 크래시 가능성!
}

// ✅ 올바른 예시
DispatchQueue.global().async {
    let data = self.fetchData()
    
    DispatchQueue.main.async {
        self.label.text = "완료"
        self.tableView.reloadData()
    }
}

// ✅ 편리한 헬퍼 함수
extension DispatchQueue {
    static func mainAsync(_ block: @escaping () -> Void) {
        if Thread.isMainThread {
            block()
        } else {
            DispatchQueue.main.async(execute: block)
        }
    }
}

// 사용
DispatchQueue.global().async {
    let data = self.fetchData()
    
    DispatchQueue.mainAsync {
        self.updateUI(with: data)
    }
}

// ❌ 강한 참조 순환 (Retain Cycle)
class ViewController: UIViewController {
    var data: [String] = []
    
    func loadData() {
        DispatchQueue.global().async {
            // self를 강하게 캡처 -> 메모리 누수!
            let newData = self.fetchData()
            self.data = newData
        }
    }
}

// ✅ weak self 사용
class ViewController: UIViewController {
    var data: [String] = []
    
    func loadData() {
        DispatchQueue.global().async { [weak self] in
            guard let self = self else { return }
            let newData = self.fetchData()
            
            DispatchQueue.main.async { [weak self] in
                self?.data = newData
            }
        }
    }
}

// ✅ unowned 사용 (self가 nil이 될 수 없을 때)
func processData() {
    DispatchQueue.global().async { [unowned self] in
        let result = self.heavyComputation()
        DispatchQueue.main.async { [unowned self] in
            self.displayResult(result)
        }
    }
}

// OperationQueue에서도 동일
let operation = BlockOperation { [weak self] in
    guard let self = self else { return }
    self.doSomething()
}

// Debounce: 마지막 호출 후 일정 시간 대기
class Debouncer {
    private let delay: TimeInterval
    private var workItem: DispatchWorkItem?
    
    init(delay: TimeInterval) {
        self.delay = delay
    }
    
    func debounce(action: @escaping () -> Void) {
        workItem?.cancel()
        
        let newWorkItem = DispatchWorkItem(block: action)
        workItem = newWorkItem
        
        DispatchQueue.main.asyncAfter(deadline: .now() + delay, 
                                      execute: newWorkItem)
    }
}

// 사용 예시
class SearchViewController: UIViewController {
    let debouncer = Debouncer(delay: 0.5)
    
    func searchBarTextDidChange(_ searchBar: UISearchBar) {
        debouncer.debounce { [weak self] in
            self?.performSearch(query: searchBar.text ?? "")
        }
    }
}

// Throttle: 일정 시간마다 한 번만 실행
class Throttler {
    private let delay: TimeInterval
    private var lastExecutionTime: Date?
    private let queue = DispatchQueue(label: "com.myapp.throttler")
    
    init(delay: TimeInterval) {
        self.delay = delay
    }
    
    func throttle(action: @escaping () -> Void) {
        queue.async { [weak self] in
            guard let self = self else { return }
            
            let now = Date()
            if let lastTime = self.lastExecutionTime,
               now.timeIntervalSince(lastTime) < self.delay {
                return
            }
            
            self.lastExecutionTime = now
            DispatchQueue.main.async {
                action()
            }
        }
    }
}

// 사용 예시
class ScrollViewController: UIViewController {
    let throttler = Throttler(delay: 0.1)
    
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        throttler.throttle { [weak self] in
            self?.updateScrollIndicator()
        }
    }
}

// GCD 버전
class TaskChain {
    private let queue = DispatchQueue(label: "com.myapp.taskchain")
    
    func execute<T>(_ tasks: [(T) -> T], initialValue: T, 
                   completion: @escaping (T) -> Void) {
        queue.async {
            var result = initialValue
            
            for task in tasks {
                result = task(result)
            }
            
            DispatchQueue.main.async {
                completion(result)
            }
        }
    }
}

// 사용 예시
let chain = TaskChain()
let tasks: [(String) -> String] = [
    { text in
        print("1. 소문자로 변환")
        return text.lowercased()
    },
    { text in
        print("2. 공백 제거")
        return text.replacingOccurrences(of: " ", with: "")
    },
    { text in
        print("3. 역순으로")
        return String(text.reversed())
    }
]

chain.execute(tasks, initialValue: "Hello World") { result in
    print("최종 결과: \(result)")
}

// OperationQueue 버전
class ChainableOperation: Operation {
    var input: Any?
    var output: Any?
    
    override func main() {
        guard !isCancelled else { return }
        output = process(input: input)
    }
    
    func process(input: Any?) -> Any? {
        // 서브클래스에서 구현
        return input
    }
}

class LowercaseOperation: ChainableOperation {
    override func process(input: Any?) -> Any? {
        guard let text = input as? String else { return input }
        return text.lowercased()
    }
}

class ReverseOperation: ChainableOperation {
    override func process(input: Any?) -> Any? {
        guard let text = input as? String else { return input }
        return String(text.reversed())
    }
}

// 사용
let queue = OperationQueue()
let op1 = LowercaseOperation()
let op2 = ReverseOperation()

op1.input = "Hello World"
op2.addDependency(op1)

op2.completionBlock = {
    if let result = op2.output as? String {
        print("결과: \(result)")
    }
}

queue.addOperations([op1, op2], waitUntilFinished: false)

class RetryableTask {
    private let maxRetries: Int
    private let retryDelay: TimeInterval
    private let queue: DispatchQueue
    
    init(maxRetries: Int = 3, 
         retryDelay: TimeInterval = 2.0,
         queue: DispatchQueue = .global()) {
        self.maxRetries = maxRetries
        self.retryDelay = retryDelay
        self.queue = queue
    }
    
    func execute<T>(_ task: @escaping () throws -> T,
                   completion: @escaping (Result<T, Error>) -> Void) {
        executeWithRetry(task, attemptsLeft: maxRetries, completion: completion)
    }
    
    private func executeWithRetry<T>(_ task: @escaping () throws -> T,
                                    attemptsLeft: Int,
                                    completion: @escaping (Result<T, Error>) -> Void) {
        queue.async {
            do {
                let result = try task()
                DispatchQueue.main.async {
                    completion(.success(result))
                }
            } catch {
                if attemptsLeft > 0 {
                    print("실패! \(attemptsLeft)번 재시도...")
                    
                    DispatchQueue.global().asyncAfter(deadline: .now() + self.retryDelay) {
                        self.executeWithRetry(task, 
                                            attemptsLeft: attemptsLeft - 1, 
                                            completion: completion)
                    }
                } else {
                    DispatchQueue.main.async {
                        completion(.failure(error))
                    }
                }
            }
        }
    }
}

// 사용 예시
let retryTask = RetryableTask(maxRetries: 3, retryDelay: 1.0)

retryTask.execute({
    // 실패할 수 있는 작업
    try self.fetchDataFromServer()
}) { result in
    switch result {
    case .success(let data):
        print("성공: \(data)")
    case .failure(let error):
        print("최종 실패: \(error)")
    }
}

// OperationQueue 버전
class RetryableOperation: Operation {
    private let maxRetries: Int
    private var currentRetry = 0
    private let task: () throws -> Void
    
    init(maxRetries: Int = 3, task: @escaping () throws -> Void) {
        self.maxRetries = maxRetries
        self.task = task
        super.init()
    }
    
    override func main() {
        while currentRetry <= maxRetries && !isCancelled {
            do {
                try task()
                return
            } catch {
                currentRetry += 1
                if currentRetry <= maxRetries {
                    print("재시도 \(currentRetry)/\(maxRetries)")
                    sleep(2)
                } else {
                    print("최종 실패")
                }
            }
        }
    }
}

// 피드 아이템 모델
struct FeedItem {
    let id: String
    let text: String
    let imageURL: URL?
    let authorName: String
    let timestamp: Date
}

// 피드 로더 (GCD + OperationQueue 혼합)
class FeedLoader {
    private let networkQueue = DispatchQueue(label: "com.myapp.network", 
                                             attributes: .concurrent)
    private let imageQueue = OperationQueue()
    private let processingQueue = DispatchQueue(label: "com.myapp.processing")
    
    init() {
        imageQueue.name = "com.myapp.imageQueue"
        imageQueue.maxConcurrentOperationCount = 4
    }
    
    func loadFeed(completion: @escaping (Result<[FeedItem], Error>) -> Void) {
        // 1단계: 피드 데이터 가져오기
        networkQueue.async {
            do {
                let feedData = try self.fetchFeedData()
                
                // 2단계: 데이터 파싱
                self.processingQueue.async {
                    let items = self.parseFeedData(feedData)
                    
                    // 3단계: 이미지 다운로드
                    self.downloadImages(for: items) { itemsWithImages in
                        DispatchQueue.main.async {
                            completion(.success(itemsWithImages))
                        }
                    }
                }
            } catch {
                DispatchQueue.main.async {
                    completion(.failure(error))
                }
            }
        }
    }
    
    private func fetchFeedData() throws -> Data {
        // 네트워크 요청 시뮬레이션
        sleep(1)
        return Data()
    }
    
    private func parseFeedData(_ data: Data) -> [FeedItem] {
        // 파싱 로직
        return []
    }
    
    private func downloadImages(for items: [FeedItem], 
                               completion: @escaping ([FeedItem]) -> Void) {
        let group = DispatchGroup()
        var processedItems = items
        
        for (index, item) in items.enumerated() {
            guard let imageURL = item.imageURL else { continue }
            
            group.enter()
            let operation = ImageDownloadOperation(url: imageURL)
            
            operation.completionBlock = { [weak operation] in
                if let image = operation?.downloadedImage {
                    // 이미지 캐싱 또는 처리
                    print("이미지 다운로드 완료: \(item.id)")
                }
                group.leave()
            }
            
            imageQueue.addOperation(operation)
        }
        
        group.notify(queue: .main) {
            completion(processedItems)
        }
    }
    
    func cancelAll() {
        imageQueue.cancelAllOperations()
    }
}

// ViewController에서 사용
class FeedViewController: UIViewController {
    private let feedLoader = FeedLoader()
    private var feedItems: [FeedItem] = []
    
    func refreshFeed() {
        showLoadingIndicator()
        
        feedLoader.loadFeed { [weak self] result in
            guard let self = self else { return }
            
            self.hideLoadingIndicator()
            
            switch result {
            case .success(let items):
                self.feedItems = items
                self.tableView.reloadData()
                print("✅ 피드 로드 완료: \(items.count)개")
                
            case .failure(let error):
                self.showError(error)
                print("❌ 피드 로드 실패: \(error)")
            }
        }
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        feedLoader.cancelAll()
    }
    
    private func showLoadingIndicator() {
        // 로딩 표시
    }
    
    private func hideLoadingIndicator() {
        // 로딩 숨김
    }
    
    private func showError(_ error: Error) {
        // 에러 표시
    }
}