07 · RunLoop와 이벤트 처리

// ❌ 메인 콜백 안에서 동기 블로킹 → 런루프로 못 돌아감
@objc func didTapLoad() {
    let data = try? Data(contentsOf: bigRemoteURL)  // 동기 네트워크: 메인 정지
    render(data)                                    // 그동안 터치·스크롤·프레임 전부 멈춤
}
// 이 사이 도착한 터치는 큐에 쌓이고, 화면은 마지막 프레임에 얼어붙는다

import UIKit

// 메인이 런루프로 돌아가지 못하면 터치·스크롤·프레임이 전부 멈춘다.
// 아래 네 가지가 메인에서 자주 발견되는 범인이다.

@MainActor
final class FeedViewController: UIViewController {
    private var items: [Item] = []
    private let tableView = UITableView()

    // ❌ ① 동기 I/O  ② 큰 Codable 디코딩  ③ 이미지 디코드  ④ 정규식 대량 처리
    func loadBad() {
        let data = try! Data(contentsOf: bigURL)                 // ①
        items = try! JSONDecoder().decode([Item].self, from: data)  // ②
        let image = UIImage(contentsOfFile: path)!               // ③
        _ = items.filter { $0.title.range(of: pattern,
                                          options: .regularExpression) != nil }  // ④
        _ = image
    }

    // ✅ 무거운 일은 전부 메인 밖으로, 반영만 메인에서
    func load() async {
        let url = self.bigURL                      // self 캡처를 피해 값만 넘긴다
        let decoded: [Item] = await Task.detached(priority: .userInitiated) {
            // ⚠️ Task.detached도 같은 협력 스레드 풀에서 돈다 — 동기 I/O로 블로킹하면
        //    풀 스레드를 잠식한다. 실제 코드에서는 전용 큐나 async API로 읽어야 한다.
        guard let data = try? Data(contentsOf: url) else { return [] }
            return (try? JSONDecoder().decode([Item].self, from: data)) ?? []
        }.value

        items = decoded                    // ✅ 메인에서는 대입과 reload만
        tableView.reloadData()
    }

    private let bigURL = URL(fileURLWithPath: "/big.json")
    private let path = "/img.jpg"
    private let pattern = "[a-z]+"
}

// ✅ 개발 중 방어선 — 메인에서 부르면 즉시 크래시로 잡는다
func loadFromDisk(_ url: URL) throws -> Data {
    dispatchPrecondition(condition: .notOnQueue(.main))
    return try Data(contentsOf: url)
}

struct Item: Decodable { let title: String }

import UIKit

// 메인에서만 할 수 있는 작업(대량 뷰 삽입, 스냅샷 적용)은 옮길 수 없다.
// 대신 중간중간 런루프로 돌려보내면 터치와 렌더가 처리된다.

@MainActor
final class BulkImporter {
    private let progressView = UIProgressView()

    // ❌ 한 번에 전부 — 진행률 UI도 안 움직이고 터치도 안 먹는다
    func importAllBad(_ rows: [Row]) {
        for row in rows {
            insert(row)
            progressView.progress += 1 / Float(rows.count)   // 화면엔 반영 안 된다
        }
    }

    // ✅ 청크마다 양보 — 진행률이 실제로 그려지고 취소 버튼도 눌린다
    func importAll(_ rows: [Row]) async {
        let chunkSize = 200
        var index = 0

        while index < rows.count {
            let end = min(index + chunkSize, rows.count)
            for i in index..<end { insert(rows[i]) }
            index = end

            progressView.progress = Float(index) / Float(rows.count)
            await Task.yield()          // ✅ 런루프로 돌아가 이벤트·렌더를 처리시킨다

            if Task.isCancelled { return }
        }
    }

    // ✅ 청크 크기는 '한 프레임 예산' 기준으로 잡는다
    func importAdaptive(_ rows: [Row]) async {
        let budget = Duration.milliseconds(8)      // 120Hz 기준
        var index = 0
        while index < rows.count {
            let start = ContinuousClock.now
            while index < rows.count, ContinuousClock.now - start < budget {
                insert(rows[index]); index += 1
            }
            await Task.yield()
        }
    }

    private func insert(_ r: Row) {}
}

struct Row {}

import UIKit

// 워치독(0x8badf00d)은 특정 구간에서 더 짧은 시간만 허용한다.
// 여기서의 동기 작업은 '느림'이 아니라 '강제 종료'로 끝난다.

@main
final class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(
        _ app: UIApplication,
        didFinishLaunchingWithOptions o: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        // ❌ 여기서 하면 안 되는 것들
        //   · 동기 네트워크 호출
        //   · Core Data 무거운 마이그레이션
        //   · 큰 파일 읽기·파싱
        //   · 서드파티 SDK의 동기 초기화 여러 개

        // ✅ 첫 화면에 꼭 필요한 것만 동기로
        setupWindow()

        // ✅ 나머지는 전부 뒤로 미룬다
        Task.detached(priority: .utility) {
            await Analytics.configure()
            await RemoteConfig.fetch()
            await CrashReporter.start()
        }
        return true
    }

    private func setupWindow() {}
}

// ✅ 마이그레이션처럼 오래 걸리는 건 스플래시를 띄우고 백그라운드에서
@MainActor
final class LaunchCoordinator {
    func start() async {
        showSplash()
        await Task.detached(priority: .userInitiated) {
            try? await Store.migrateIfNeeded()      // 메인을 막지 않는다
        }.value
        showMainScreen()
    }
    private func showSplash() {}
    private func showMainScreen() {}
}

// ✅ 감시 구간을 계측해 회귀를 잡는다
func measureLaunchPhase(_ name: String, _ body: () -> Void) {
    let elapsed = ContinuousClock().measure(body)
    if elapsed > .milliseconds(200) {
        assertionFailure("\(name)이 \(elapsed) 소요 — 워치독 위험")
    }
}

enum Analytics { static func configure() async {} }
enum RemoteConfig { static func fetch() async {} }
enum CrashReporter { static func start() async {} }
enum Store { static func migrateIfNeeded() async throws {} }

Thread.detachNewThread {
    let t = Timer(timeInterval: 1, repeats: true) { _ in print("tick") }
    RunLoop.current.add(t, forMode: .default)
    // 여기서 클로저가 끝나면 스레드 종료 → 타이머는 한 번도 안 울린다
    RunLoop.current.run()   // 이 줄이 있어야 런루프가 돌며 타이머가 fire된다
}

import Foundation

// 런루프 객체는 스레드마다 있지만, '돌고 있는' 건 메인뿐이다.
// 보조 스레드에서 Timer·포트 소스를 쓰려면 직접 run()을 불러야 한다.

// ❌ 타이머가 한 번도 안 울린다 — 클로저가 끝나며 스레드가 종료된다
func brokenTimerThread() {
    Thread.detachNewThread {
        let t = Timer(timeInterval: 1, repeats: true) { _ in print("tick") }
        RunLoop.current.add(t, forMode: .default)
        // run()이 없다 → 여기서 스레드 끝
    }
}

// ✅ 명시적으로 런루프를 돌린다
final class TimerThread {
    private var thread: Thread?
    private var timer: Timer?

    func start() {
        let t = Thread { [weak self] in
            guard let self else { return }
            let timer = Timer(timeInterval: 1, repeats: true) { _ in self.tick() }
            RunLoop.current.add(timer, forMode: .default)
            self.timer = timer

            // ⚠️ 종료 조건을 직접 관리해야 한다
            while !Thread.current.isCancelled {
                RunLoop.current.run(mode: .default, before: .distantFuture)
            }
        }
        t.name = "com.app.timer"
        t.start()
        thread = t
    }

    func stop() {
        // ⚠️ invalidate()는 타이머를 '설치한 그 스레드'에서 불러야 한다(Apple 문서 명시).
        //    다른 스레드에서 부르면 런루프에서 입력 소스가 제거되지 않아 스레드가 안 끝난다.
        if let thread {
            perform(#selector(invalidateOnTimerThread), on: thread, with: nil, waitUntilDone: false)
        }
        thread?.cancel()          // ⚠️ run()이 블로킹 중이면 즉시 깨어나지 않는다
        thread = nil
    }

    @objc private func invalidateOnTimerThread() { timer?.invalidate(); timer = nil }

    private func tick() {}
}

// ⚠️ 위 종료 처리가 까다롭다는 게 핵심이다. before: .distantFuture로 자면
//    cancel()해도 다음 이벤트가 올 때까지 깨어나지 않는다.
//    짧은 타임아웃을 주거나, 깨우기용 포트 소스를 하나 더 달아야 한다.

import Foundation

// 커스텀 스레드 + 런루프는 종료 조건·수명 관리가 까다롭다.
// 앱 코드에서 필요한 경우는 드물고, 대부분 더 단순한 대안이 있다.

// ✅ 주기 작업 → DispatchSourceTimer (런루프 비의존)
final class Poller {
    private var timer: DispatchSourceTimer?

    func start(interval: TimeInterval) {
        let t = DispatchSource.makeTimerSource(queue: .global(qos: .utility))
        t.schedule(deadline: .now() + interval,
                   repeating: interval,
                   leeway: .milliseconds(200))   // 전력 절약 여지를 준다
        t.setEventHandler { [weak self] in self?.poll() }
        t.resume()
        timer = t                                 // ⚠️ 반드시 강참조로 보관
    }

    func stop() {
        timer?.cancel()                           // 즉시 확실하게 멈춘다
        timer = nil
    }

    private func poll() {}
}

// ✅ 주기 작업 → Swift Concurrency (취소가 구조적으로 따라온다)
func startPolling(interval: Duration) -> Task<Void, Never> {
    Task {
        while !Task.isCancelled {
            await poll()
            try? await Task.sleep(for: interval)
        }
    }
}

// ✅ 직렬 실행 컨텍스트 → serial queue 또는 actor
actor Worker {
    func perform(_ job: Job) { }
}

// ✅ 파일·포트 감시 → DispatchSource
func watchFile(at url: URL) -> DispatchSourceFileSystemObject? {
    let fd = open(url.path, O_EVTONLY)
    guard fd >= 0 else { return nil }
    let source = DispatchSource.makeFileSystemObjectSource(
        fileDescriptor: fd, eventMask: .write, queue: .main)
    source.setEventHandler { print("파일 변경됨") }
    source.setCancelHandler { close(fd) }
    source.resume()
    return source
}

// 런루프가 정말 필요한 경우: 스레드에 묶인 레거시 API(일부 C 라이브러리,
// CFRunLoop 기반 서드파티)를 감쌀 때뿐이다.

struct Job {}
func poll() async {}

import UIKit

// 런루프는 한 번에 한 모드로만 돈다. 스크롤 중에는 tracking 모드로 바뀌므로
// .default에만 등록한 항목은 '늦게' 처리되는 게 아니라 아예 처리되지 않는다.

final class CountdownView: UIView {
    private var timer: Timer?

    // ❌ scheduledTimer는 .default 모드 — 스크롤을 시작하면 멈춘다
    func startBroken() {
        timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
            self?.tick()
        }
    }

    // ✅ .common에 등록하면 default와 tracking 양쪽 목록에 들어간다
    func start() {
        let t = Timer(timeInterval: 1, repeats: true) { [weak self] _ in
            self?.tick()
        }
        RunLoop.main.add(t, forMode: .common)
        timer = t
    }

    // ✅ scheduledTimer를 쓰고 싶다면 만든 뒤에 모드를 추가한다
    func startAlternative() {
        let t = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
            self?.tick()
        }
        RunLoop.main.add(t, forMode: .common)
        timer = t
    }

    func stop() { timer?.invalidate(); timer = nil }
    private func tick() {}
}

// ✅ CADisplayLink도 동일하다
final class Animator {
    private var link: CADisplayLink?
    func start() {
        let l = CADisplayLink(target: self, selector: #selector(step))
        l.add(to: .main, forMode: .common)      // ✅ 스크롤 중에도 애니메이션 유지
        link = l
    }
    @objc private func step() {}
}

// ⚠️ .common은 '제3의 모드'가 아니다. "common 집합에 속한 모든 모드에 등록"이라는
//    표시일 뿐이고, 런루프는 여전히 한 번에 한 모드로만 돈다.

import UIKit

// libdispatch가 메인 큐 배수 소스를 common 모드에 심어 두기 때문에,
// main.async로 넣은 블록은 스크롤 중에도 실행된다.

final class BadgeUpdater {
    // ✅ 모드를 신경 쓸 필요가 없다
    func refresh() {
        DispatchQueue.main.async {
            self.updateBadge()          // 스크롤 중에도 실행된다
        }
    }

    // ✅ Swift Concurrency도 마찬가지
    func refreshModern() {
        Task { @MainActor in
            self.updateBadge()
        }
    }

    // ❌ Timer로 같은 걸 하려면 모드를 챙겨야 한다
    func refreshWithTimer() {
        let t = Timer(timeInterval: 0, repeats: false) { _ in self.updateBadge() }
        RunLoop.main.add(t, forMode: .common)   // 이걸 빠뜨리면 스크롤 중 안 돈다
    }

    private func updateBadge() {}
}

// ✅ 지연 실행도 asyncAfter가 Timer보다 단순하다
func delayed(_ seconds: TimeInterval, _ work: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds, execute: work)
}

// ⚠️ 단, asyncAfter도 '최소 지연'만 보장한다. 런루프가 바쁘면 더 늦게 실행된다.
//    정확한 시각이 필요하면 목표 시각과의 차이를 매번 다시 계산해야 한다(Q6).

// 정리: "모드 때문에 헤맬 바에는 main.async / @MainActor 쪽이 단순하다."
//       Timer가 필요한 진짜 이유(런루프 통합, tolerance 제어)가 없다면 이쪽을 쓴다.

import UIKit

// 메인 런루프의 autorelease pool은 '순회 단위'로 push/pop된다.
// 한 순회 안에서 임시 객체를 수만 개 만들면 순회가 끝날 때까지 전부 살아 있다.

// ❌ 1만 개 이미지를 한 순회에서 로드 — pop 시점까지 메모리가 계속 쌓인다
func loadAllBad(_ paths: [String]) -> [CGSize] {
    paths.map { path in
        let image = UIImage(contentsOfFile: path)!     // 내부에서 NSData·ImageIO 임시 객체가 autorelease된다
        return image.size
    }
    // 여기서 메모리 피크 → 최악의 경우 jetsam
}

// ✅ 청크마다 pool 경계를 앞당긴다
func loadAll(_ paths: [String]) -> [CGSize] {
    var sizes: [CGSize] = []
    sizes.reserveCapacity(paths.count)

    for chunk in stride(from: 0, to: paths.count, by: 100) {
        let end = min(chunk + 100, paths.count)
        autoreleasepool {                              // ✅ 이 블록 끝에서 해제
            for i in chunk..<end {
                if let image = UIImage(contentsOfFile: paths[i]) {
                    sizes.append(image.size)
                }
            }
        }
    }
    return sizes
}

// ✅ 매 반복이 무거우면 반복마다 감싼다
func processHeavy(_ urls: [URL]) {
    for url in urls {
        autoreleasepool {
            let data = try? Data(contentsOf: url)
            _ = data.map { transform($0) }
        }
    }
}

// ⚠️ 순수 Swift 값 타입·ARC 객체는 대부분 autorelease를 타지 않는다.
//    효과가 있는 건 ObjC/CoreFoundation 경계를 넘는 API다:
//    UIImage(contentsOfFile:), NSString 계열, ImageIO, Core Graphics 등.

// 확인: Instruments의 Allocations에서 순회 중 "Persistent Bytes"가
//       계속 오르다가 순회 끝에 뚝 떨어지면 이 패턴이다.

func transform(_ d: Data) -> Data { d }

import Foundation

// source0/source1 구분은 CFRunLoop 수준의 내부 개념이다.
// "터치는 왜 앱이 자고 있어도 도착하는가"를 설명할 때는 유용하지만,
// 앱 코드에서 직접 다루면 취약하고 이식성이 없다.

// ❌ CFRunLoopSource를 직접 만들어 앱 로직을 얹는 코드
func createCustomSourceBad() {
    var context = CFRunLoopSourceContext()
    context.perform = { _ in print("source0 fired") }
    let source = CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context)
    CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .defaultMode)
    // 깨우기·모드·수명을 전부 직접 관리해야 하고, 상위 API로 다 되는 일이다
}

// ✅ 같은 목적을 상위 API로 — 훨씬 단순하고 안전하다
//    "다른 스레드에서 메인에 작업을 넘긴다"
func postToMain(_ work: @escaping () -> Void) {
    DispatchQueue.main.async(execute: work)
}

//    "이벤트가 생기면 깨어나 처리한다"
final class EventPump {
    private let stream: AsyncStream<Event>
    private let continuation: AsyncStream<Event>.Continuation

    init() {
        var c: AsyncStream<Event>.Continuation!
        stream = AsyncStream { c = $0 }
        continuation = c
    }

    func send(_ e: Event) { continuation.yield(e) }

    func run() async {
        for await event in stream { handle(event) }   // 이벤트가 없으면 자연히 대기
    }

    private func handle(_ e: Event) {}
}

//    "파일·포트·시그널 감시"
func watch(fd: Int32) -> DispatchSourceRead {
    let s = DispatchSource.makeReadSource(fileDescriptor: fd, queue: .main)
    s.setEventHandler { }
    s.resume()
    return s
}

struct Event {}

view.setNeedsLayout()      // 즉시 layout 아님 — '더럽다' 표시만
view.setNeedsLayout()      // 여러 번 불러도 표시만 반복
label.setNeedsDisplay()
// → 런루프 끝(Commit)에서 딱 한 번:
//   layoutSubviews(1회) → draw → 레이어 트리 인코딩 → 렌더 서버 전송

// 지금 당장 레이아웃 결과가 필요할 때만(예: 크기 즉시 측정):
view.layoutIfNeeded()      // Commit을 기다리지 않고 강제로 지금 layout

import UIKit

final class FeedCell: UICollectionViewCell {
    private let iconView = UIImageView()
    private let titleLabel = UILabel()

    // ❌ 여기서 하면 안 되는 것들 — 매 프레임, 셀마다 호출된다
    //    override func layoutSubviews() {
    //        super.layoutSubviews()
    //        let data = try? Data(contentsOf: iconURL)       // 동기 I/O
    //        iconView.image = UIImage(data: data!)           // 디코드
    //        let h = title.boundingRect(...)                 // 매번 텍스트 측정
    //        addSubview(UIView())                            // 뷰 재생성
    //    }

    // ✅ 가벼운 배치 계산만
    override func layoutSubviews() {
        super.layoutSubviews()
        let inset: CGFloat = 12
        iconView.frame = CGRect(x: inset, y: inset, width: 40, height: 40)
        titleLabel.frame = CGRect(x: iconView.frame.maxX + 8, y: inset,
                                  width: bounds.width - iconView.frame.maxX - 8 - inset,
                                  height: 40)
    }

    // ✅ 무거운 것은 configure 시점에 한 번, 그것도 비동기로
    func configure(_ item: Item) {
        titleLabel.text = item.title
        iconView.image = nil
        Task {
            let image = await ImagePipeline.shared.image(for: item.iconURL)
            guard self.currentID == item.id else { return }   // 재사용 검증
            self.iconView.image = image
        }
        currentID = item.id
    }

    private var currentID: UUID?
}

// ✅ 텍스트 높이 같은 계산은 캐시한다
final class HeightCache {
    private var cache: [UUID: CGFloat] = [:]
    func height(for item: Item, width: CGFloat, font: UIFont) -> CGFloat {
        // ⚠️ 높이는 width·font에도 의존한다 — id만 키로 쓰면 회전·Dynamic Type 변경 시
        //    낡은 값이 반환돼 레이아웃이 깨진다. 실제 코드에서는 복합 키를 써야 한다.
        //    struct Key: Hashable { let id: UUID; let width: CGFloat; let font: UIFont }
        if let h = cache[item.id] { return h }
        let h = (item.title as NSString).boundingRect(
            with: CGSize(width: width, height: .greatestFiniteMagnitude),
            options: .usesLineFragmentOrigin,
            attributes: [.font: font], context: nil).height.rounded(.up)
        cache[item.id] = h
        return h
    }
}

struct Item { let id: UUID; let title: String; let iconURL: URL }
enum ImagePipeline {
    static let shared = ImagePipelineImpl()
}
struct ImagePipelineImpl { func image(for url: URL) async -> UIImage? { nil } }

import UIKit

// setNeedsLayout은 '표시'만 하고 실제 실행은 런루프 끝 Commit에서 한 번에 모인다.
// layoutIfNeeded는 그 합치기를 깨고 지금 당장 강제한다.

final class PanelView: UIView {
    private let contentView = UIView()

    // ❌ 여러 번 강제하면 프레임당 layout이 여러 번 돈다
    func updateBad(_ items: [String]) {
        for item in items {
            addRow(item)
            layoutIfNeeded()          // 💥 항목 수만큼 전체 레이아웃
        }
    }

    // ✅ 표시만 하고 Commit에서 한 번에 처리되게 둔다
    func update(_ items: [String]) {
        for item in items { addRow(item) }
        setNeedsLayout()              // 한 번만 — 실제 실행은 런루프 끝
    }

    // ✅ layoutIfNeeded가 정당한 경우 ① 지금 당장 크기를 알아야 할 때
    func measuredHeight() -> CGFloat {
        layoutIfNeeded()
        return contentView.bounds.height
    }

    // ✅ ② 애니메이션 시작 전 '현재 상태'를 확정할 때
    func animateExpansion() {
        layoutIfNeeded()                       // 시작 상태 확정
        heightConstraint.constant = 300
        UIView.animate(withDuration: 0.3) {
            self.layoutIfNeeded()              // 종료 상태로 보간
        }
    }

    private func addRow(_ s: String) {}
    private let heightConstraint = NSLayoutConstraint()
}

// 확인: Instruments의 Time Profiler에서 layoutSubviews 호출 횟수를 본다.
//       한 프레임에 여러 번 나오면 어딘가에서 강제하고 있는 것이다.

import UIKit

// 오프스크린 렌더링은 GPU가 별도 버퍼에 그렸다가 합치는 것이다.
// 버퍼 전환 비용이 붙어 Render 단계가 비싸진다.

final class CardView: UIView {

    // ❌ 둥근 모서리 + 마스킹 + 그림자 조합
    func styleBad() {
        layer.cornerRadius = 12
        layer.masksToBounds = true        // 마스킹
        layer.shadowOpacity = 0.2         // 위 마스킹 때문에 이 그림자는 아예 잘려 안 보인다. 마스킹을 풀어도 shadowPath가 없으면 오프스크린 패스가 붙는다
    }

    // ✅ 그림자는 경로를 지정해 알파 계산을 없앤다
    func style() {
        layer.cornerRadius = 12
        layer.shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: 12).cgPath
        layer.shadowOpacity = 0.2
        layer.shadowRadius = 8
        layer.shadowOffset = CGSize(width: 0, height: 2)
        // masksToBounds는 켜지 않는다
    }

    // ✅ 모서리와 그림자를 둘 다 원하면 뷰를 나눈다
    //    바깥 뷰: 그림자 (masksToBounds = false)
    //    안쪽 뷰: 모서리 + 클리핑 (masksToBounds = true)
    func styleLayered(shadowHost: UIView, content: UIView) {
        shadowHost.layer.shadowPath = UIBezierPath(
            roundedRect: shadowHost.bounds, cornerRadius: 12).cgPath
        shadowHost.layer.shadowOpacity = 0.2
        shadowHost.layer.masksToBounds = false

        content.layer.cornerRadius = 12
        content.layer.masksToBounds = true
    }

    // ⚠️ shouldRasterize는 신중히 — 내용이 매 프레임 바뀌면 오히려 손해다
    func rasterizeIfStatic() {
        layer.shouldRasterize = true
        layer.rasterizationScale = traitCollection.displayScale   // ✅ 안 하면 흐려진다
        // 정적인 내용에만. 스크롤·애니메이션 중 내용이 바뀌면 매번 다시 그린다.
    }

    // ✅ 불투명하게 둘 수 있으면 블렌딩이 줄어든다
    func opaqueIfPossible() {
        isOpaque = true
        backgroundColor = .systemBackground
    }
}

// 확인: 시뮬레이터 → Debug → Color Offscreen-Rendered (노란색으로 표시)
//       실기기는 Instruments의 Core Animation / Animation Hitches

print("A")
DispatchQueue.main.async { print("C") }   // 런루프 다음 서비스 지점에 예약
print("B")
// 출력: A B C
// C는 지금 콜스택(A→예약→B)이 런루프로 풀린 뒤 실행된다.

// 흔한 활용: 지금 순회의 layout이 끝난 다음 프레임에서 후속 작업
DispatchQueue.main.async { self.scrollToBottom() }

import UIKit

// 이미 메인 스레드인데 async로 감싸면 한 순회가 늦어진다.
// 그 사이에 프레임이 한 번 그려지면 깜빡임이나 한 박자 늦은 반응으로 보인다.

final class BadgeView: UIView {
    private let label = UILabel()

    // ❌ 이미 메인 콜백 안인데 또 async
    @objc func didTapBad() {
        DispatchQueue.main.async {
            self.label.text = "1"       // 한 순회 뒤에 반영된다
        }
    }

    // ✅ 그냥 실행한다
    @objc func didTap() {
        label.text = "1"                 // 이번 순회의 Commit에 포함된다
    }

    // ✅ 어느 스레드인지 모르는 콜백이면 분기한다
    func update(_ text: String) {
        if Thread.isMainThread {
            label.text = text
        } else {
            DispatchQueue.main.async { self.label.text = text }
        }
    }
}

// ✅ 더 나은 방법: 타입을 @MainActor로 격리해 분기 자체를 없앤다
@MainActor
final class CleanBadgeView {
    private let label = UILabel()

    func update(_ text: String) {
        label.text = text                // 컴파일러가 메인임을 보장한다
    }
}

// 호출부에서 필요할 때만 hop한다
func fromBackground(_ view: CleanBadgeView) async {
    let text = await fetchText()
    await view.update(text)              // ✅ 필요한 곳에서만 경계를 넘는다
}

func fetchText() async -> String { "" }

import UIKit

// 한 틱 미루기가 정당한 경우는 "이번 순회의 Commit이 끝난 뒤"가 필요할 때다.

final class ChatViewController: UIViewController {
    private let tableView = UITableView()
    private var messages: [Message] = []

    // ✅ 새 메시지를 추가한 뒤 맨 아래로 스크롤
    func append(_ message: Message) {
        messages.append(message)
        tableView.insertRows(at: [IndexPath(row: messages.count - 1, section: 0)],
                             with: .automatic)

        // 이 시점엔 아직 contentSize가 갱신되지 않았다
        DispatchQueue.main.async {
            self.scrollToBottom()        // ✅ layout이 반영된 뒤 실행된다
        }
    }

    // ✅ 대안: layoutIfNeeded로 지금 확정한다 (더 명시적)
    func appendExplicit(_ message: Message) {
        messages.append(message)
        tableView.insertRows(at: [IndexPath(row: messages.count - 1, section: 0)],
                             with: .automatic)
        tableView.layoutIfNeeded()       // 지금 layout을 강제하고
        scrollToBottom()                 // 확정된 크기로 스크롤
    }

    // ✅ 셀 크기가 확정된 뒤 무언가 해야 할 때
    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        // ✅ 여기가 'layout 직후'를 표현하는 정식 지점이다 — async 트릭보다 낫다
        adjustInsets()
    }

    private func scrollToBottom() {}
    private func adjustInsets() {}
}

// ⚠️ async 한 틱 트릭은 타이밍 의존이다. 남용하면
//    "왜 이게 여기 있는지 아무도 모르는 코드"가 되고, 프레임워크 동작이
//    바뀌면 조용히 깨진다. 가능하면 viewDidLayoutSubviews·layoutIfNeeded처럼
//    의도가 드러나는 지점을 쓴다.

struct Message {}

import UIKit

// DispatchQueue.main.async는 "메인으로 보낸다"만 말한다.
// @MainActor는 "이건 메인에서만 유효하다"를 타입에 새긴다.

// ❌ 런타임 규약 — 지키지 않아도 컴파일은 된다
final class OldViewModel {
    var onChange: ((String) -> Void)?

    func load() {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            DispatchQueue.main.async {         // 부르는 사람이 기억해야 한다
                self.onChange?("완료")
            }
        }.resume()
    }
    private let url = URL(string: "https://x")!
}

// ✅ 컴파일러가 강제 — 잘못 부르면 컴파일 에러
@MainActor
final class ViewModel: ObservableObject {
    @Published private(set) var status = ""

    func load() async {
        status = "로딩 중"                       // 메인에서 실행
        let result = await fetch()               // 여기서 메인을 반납
        status = result                          // 재개 시 다시 메인
    }

    private nonisolated func fetch() async -> String { "완료" }
}

// ✅ 일부만 격리할 수도 있다
final class ImageService {
    nonisolated func download(_ url: URL) async throws -> Data {
        try await URLSession.shared.data(from: url).0      // 어느 스레드든 OK
    }

    @MainActor
    func apply(_ data: Data, to view: UIImageView) {       // 여기만 메인
        view.image = UIImage(data: data)
    }
}

// ✅ 클로저·프로토콜에도 붙일 수 있다
@MainActor protocol ViewUpdating {
    func refresh()
}

func schedule(_ work: @MainActor @escaping () -> Void) {
    Task { @MainActor in work() }
}

let t = Timer(timeInterval: 1.0, repeats: true) { _ in tick() }
t.tolerance = 0.1                       // 10% 여유 → 시스템이 묶어서 전력 절약
RunLoop.main.add(t, forMode: .common)   // 스크롤(tracking) 중에도 fire

// scheduledTimer 는 .default 모드로 등록 → 스크롤 중 멈춘다(주의)
let s = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in tick() }

import UIKit

// Timer는 런루프 예약이라 프레임과 어긋난다.
// CADisplayLink는 vsync에 동기화된다. 단 ProMotion 아이폰에서 60Hz를 넘기려면
// Info.plist에 CADisableMinimumFrameDurationOnPhone = YES가 있어야 한다(iPad Pro는 불필요).

final class GaugeView: UIView {
    private var link: CADisplayLink?
    private var progress: CGFloat = 0

    func start() {
        let l = CADisplayLink(target: self, selector: #selector(step(_:)))
        l.add(to: .main, forMode: .common)      // ✅ 스크롤 중에도 유지
        link = l
    }

    // ⚠️ CADisplayLink는 target을 강하게 붙든다 — self → link → self 순환이라 deinit은 절대
    //    안 불린다. 아래 DisplayLinkProxy로 약참조를 끼우거나, viewDidDisappear 등에서
    //    소유자가 직접 stop()을 불러야 한다.
    func stop() {
        link?.invalidate()
        link = nil
    }
    deinit { stop() }

    @objc private func step(_ link: CADisplayLink) {
        // ✅ delta time 기반 — 60Hz든 120Hz든 같은 속도로 움직인다
        let dt = link.targetTimestamp - link.timestamp
        progress += CGFloat(dt) * 0.5           // 초당 0.5씩
        if progress >= 1 { progress = 1; stop() }
        setNeedsDisplay()
    }

    // ✅ 필요한 주사율을 명시하면 시스템이 전력을 아낀다
    func setLowPowerMode() {
        link?.preferredFrameRateRange = CAFrameRateRange(
            minimum: 20, maximum: 30, preferred: 30)
    }
}

// ✅ target-action의 순환을 피하려면 프록시를 둔다
final class DisplayLinkProxy {
    weak var target: AnyObject?
    let action: Selector
    init(target: AnyObject, action: Selector) {
        self.target = target; self.action = action
    }
    @objc func fire(_ link: CADisplayLink) {
        _ = target?.perform(action, with: link)
    }
}

import Foundation

// 런루프에 의존하지 않고, leeway로 전력·정밀도 트레이드오프를 명시할 수 있다.

final class SyncScheduler {
    private var timer: DispatchSourceTimer?
    private let queue = DispatchQueue(label: "com.app.sync", qos: .utility)

    func start(interval: TimeInterval) {
        let t = DispatchSource.makeTimerSource(queue: queue)

        // leeway = "이만큼 늦어도 된다" → 시스템이 다른 타이머와 묶어 깨우기를 줄인다
        t.schedule(deadline: .now() + interval,
                   repeating: interval,
                   leeway: .milliseconds(Int(interval * 100)))   // 10% 여유

        t.setEventHandler { [weak self] in
            self?.performSync()
        }
        t.resume()
        timer = t                    // ⚠️ 강참조로 보관하지 않으면 즉시 취소된다
    }

    func stop() {
        timer?.cancel()              // ✅ 확실하게 멈춘다
        timer = nil
    }

    private func performSync() {}
}

// ⚠️ suspend/resume 균형을 맞춰야 한다 — suspend 상태로 해제하면 크래시
final class Careful {
    private var timer: DispatchSourceTimer?
    private var isSuspended = false

    func pause() {
        guard !isSuspended else { return }
        timer?.suspend(); isSuspended = true
    }
    func resume() {
        guard isSuspended else { return }
        timer?.resume(); isSuspended = false
    }
    deinit {
        if isSuspended { timer?.resume() }   // ✅ suspend 상태로 버리면 안 된다
        timer?.cancel()
    }
}

// ✅ Swift Concurrency 버전 — 취소가 구조적으로 따라온다
func periodic(interval: Duration, _ work: @escaping () async -> Void) -> Task<Void, Never> {
    Task {
        while !Task.isCancelled {
            await work()
            try? await Task.sleep(for: interval)
        }
    }
}

import Foundation

// 타이머 발화는 밀린다. "1초마다 1씩 빼기"로 카운트다운을 만들면
// 발화가 밀린 만큼 실제 시간과 어긋난다.

// ❌ 발화 횟수에 의존 — 앱이 바쁘면 카운트다운이 느려진다
final class BrokenCountdown {
    private var remaining = 300
    private var timer: Timer?

    func start() {
        timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in
            self?.remaining -= 1        // 💥 발화가 3번 밀리면 3초가 사라진다
        }
    }
}

// ✅ 목표 시각을 고정하고 매번 차이를 다시 계산한다
@MainActor
final class Countdown {
    private var deadline: Date?
    private var timer: Timer?
    var onTick: ((TimeInterval) -> Void)?

    func start(duration: TimeInterval) {
        deadline = Date().addingTimeInterval(duration)
        let t = Timer(timeInterval: 0.1, repeats: true) { [weak self] _ in
            self?.tick()
        }
        RunLoop.main.add(t, forMode: .common)    // ✅ 스크롤 중에도
        timer = t
        tick()
    }

    private func tick() {
        guard let deadline else { return }
        let remaining = max(0, deadline.timeIntervalSinceNow)   // ✅ 항상 정확
        onTick?(remaining)
        if remaining == 0 { stop() }
    }

    func stop() { timer?.invalidate(); timer = nil; deadline = nil }
}

// ⚠️ 벽시계(Date)는 사용자가 바꾸거나 NTP 보정으로 점프할 수 있다.
//    경과 시간 측정에는 단조 시계를 쓴다.
final class MonotonicCountdown {
    private var start: ContinuousClock.Instant?
    private let duration: Duration

    init(duration: Duration) { self.duration = duration }

    func begin() { start = ContinuousClock.now }

    var remaining: Duration {
        guard let start else { return duration }
        let elapsed = ContinuousClock.now - start
        return elapsed >= duration ? .zero : duration - elapsed
    }
}

// ⚠️ 백그라운드 동안 타이머는 멈춘다 — 복귀 시 deadline과 현재 시각의 차이로
//    한 번에 따라잡아야 한다. 위 구조는 그게 자동으로 된다.