✅ 해결 방법 1: weak 참조 사용

class Apartment {
    var unit: String
    weak var tenant: Person?  // ✨ weak으로 변경!
    
    init(unit: String) {
        self.unit = unit
    }
    
    deinit {
        print("아파트 \(unit) 해제됨")
    }
}

// 이제 정상적으로 해제됨!
var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4A
unit4A?.tenant = john

john = nil  // "John 해제됨" 출력
unit4A = nil  // "아파트 4A 해제됨" 출력

✅ 해결 방법: Capture List 사용

class NetworkManager {
    var name: String
    var completionHandler: (() -> Void)?
    
    init(name: String) {
        self.name = name
    }
    
    func fetchData() {
        // 방법 1: weak self 사용
        completionHandler = { [weak self] in
            guard let self = self else { return }
            print(self.name)
        }
        
        // 방법 2: unowned self 사용 (self가 절대 nil이 안 될 경우)
        completionHandler = { [unowned self] in
            print(self.name)
        }
    }
    
    deinit {
        print("\(name) 해제됨")
    }
}

var manager: NetworkManager? = NetworkManager(name: "API Manager")
manager?.fetchData()
manager = nil  // "API Manager 해제됨" 정상 출력! ✨

✅ 런타임 이슈 활성화

// Scheme 설정
1. Product → Scheme → Edit Scheme
2. Run → Diagnostics 탭
3. 다음 옵션들 체크:

☑️ Malloc Stack Logging
   - Live Allocations Only 선택 (성능 최적화)

☑️ Malloc Scribble
   - 해제된 메모리 접근 감지

☑️ Zombie Objects
   - 해제된 객체 접근 감지

☑️ Address Sanitizer (선택적)
   - 메모리 오류 상세 감지 (속도 느려짐 주의)

✅ 올바른 Delegate 구현

protocol DataManagerDelegate: AnyObject {  // ✨ AnyObject 프로토콜
    func didReceiveData(_ data: String)
}

class DataManager {
    weak var delegate: DataManagerDelegate?  // ✨ weak 참조!
    
    func fetchData() {
        delegate?.didReceiveData("Some data")
    }
}

class ViewController: UIViewController, DataManagerDelegate {
    var dataManager: DataManager?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        dataManager = DataManager()
        dataManager?.delegate = self  // 이제 안전!
    }
    
    func didReceiveData(_ data: String) {
        print(data)
    }
    
    deinit {
        print("ViewController 해제됨")  // 정상 출력!
    }
}

✅ 해결 방법 1: Timer 명시적 해제

class TimerViewController: UIViewController {
    var timer: Timer?
    var count = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        startTimer()
    }
    
    func startTimer() {
        timer = Timer.scheduledTimer(
            timeInterval: 1.0,
            target: self,
            selector: #selector(updateCount),
            userInfo: nil,
            repeats: true
        )
    }
    
    @objc func updateCount() {
        count += 1
        print("Count: \(count)")
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        timer?.invalidate()  // ✨ Timer 해제!
        timer = nil
    }
    
    deinit {
        timer?.invalidate()  // ✨ 안전장치
        print("TimerViewController 해제됨")  // 정상 출력!
    }
}

✅ 해결 방법 2: 클로저 기반 Timer (iOS 10+)

class TimerViewController: UIViewController {
    var timer: Timer?
    var count = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        startTimer()
    }
    
    func startTimer() {
        // ✨ 클로저 기반 Timer + weak self
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            guard let self = self else { return }
            self.count += 1
            print("Count: \(self.count)")
        }
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        timer?.invalidate()
        timer = nil
    }
    
    deinit {
        print("TimerViewController 해제됨")  // 정상 출력!
    }
}

✅ 안전한 NotificationCenter 사용

class NotificationViewController: UIViewController {
    var observer: NSObjectProtocol?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupNotification()
    }
    
    func setupNotification() {
        // 방법 1: 클로저 기반 (권장)
        observer = NotificationCenter.default.addObserver(
            forName: .dataUpdated,
            object: nil,
            queue: .main
        ) { [weak self] notification in
            guard let self = self else { return }
            self.handleDataUpdate(notification)
        }
        
        // 방법 2: Selector 기반
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleDataUpdate),
            name: .dataUpdated,
            object: nil
        )
    }
    
    @objc func handleDataUpdate(_ notification: Notification) {
        print("데이터 업데이트됨")
    }
    
    deinit {
        // ✨ 명시적으로 옵저버 제거
        if let observer = observer {
            NotificationCenter.default.removeObserver(observer)
        }
        NotificationCenter.default.removeObserver(self)
        print("NotificationViewController 해제됨")
    }
}

extension Notification.Name {
    static let dataUpdated = Notification.Name("dataUpdated")
}

✅ 안전한 비동기 작업 처리

class AsyncViewController: UIViewController {
    var data: [String] = []
    
    func fetchDataFromServer() {
        // ✨ weak self 사용
        DispatchQueue.global().async { [weak self] in
            // 시간이 오래 걸리는 작업
            let result = self?.performHeavyTask()
            
            DispatchQueue.main.async { [weak self] in
                guard let self = self else { return }
                self.data = result ?? []
                self.updateUI()
            }
        }
    }
    
    func performHeavyTask() -> [String] {
        // 무거운 작업 시뮬레이션
        Thread.sleep(forTimeInterval: 2.0)
        return ["Data 1", "Data 2", "Data 3"]
    }
    
    func updateUI() {
        print("UI 업데이트: \(data)")
    }
    
    deinit {
        print("AsyncViewController 해제됨")
    }
}

// 사용 예제
let vc = AsyncViewController()
vc.fetchDataFromServer()
// vc가 해제되어도 크래시 없이 안전하게 처리됨!

✅ Weak Wrapper 구현

// Weak 참조를 감싸는 래퍼 클래스
class WeakRef<T: AnyObject> {
    weak var value: T?
    
    init(_ value: T) {
        self.value = value
    }
}

// 사용 예제
class Observer {
    let name: String
    
    init(name: String) {
        self.name = name
    }
    
    func notify() {
        print("\(name) notified")
    }
    
    deinit {
        print("\(name) 해제됨")
    }
}

class ObserverManager {
    private var observers: [WeakRef<Observer>] = []
    
    func addObserver(_ observer: Observer) {
        // ✨ weak 참조로 저장
        observers.append(WeakRef(observer))
    }
    
    func notifyAll() {
        // nil이 아닌 옵저버들만 필터링
        observers = observers.filter { $0.value != nil }
        
        observers.forEach { weakRef in
            weakRef.value?.notify()
        }
    }
    
    func removeNilObservers() {
        // ✨ 해제된 옵저버 정리
        observers = observers.filter { $0.value != nil }
    }
}

// 테스트
let manager = ObserverManager()

var observer1: Observer? = Observer(name: "Observer 1")
var observer2: Observer? = Observer(name: "Observer 2")

manager.addObserver(observer1!)
manager.addObserver(observer2!)

manager.notifyAll()  // 둘 다 알림 받음

observer1 = nil  // "Observer 1 해제됨" 출력
manager.notifyAll()  // Observer 2만 알림 받음

✅ 안전한 Associated Objects 사용

import ObjectiveC

// Associated Object Key
private var closureKey: UInt8 = 0

extension UIButton {
    // ✨ 클로저를 Associated Object로 저장
    var tapHandler: (() -> Void)? {
        get {
            return objc_getAssociatedObject(self, &closureKey) as? (() -> Void)
        }
        set {
            // OBJC_ASSOCIATION_COPY_NONATOMIC 사용
            // 클로저를 복사해서 저장 (안전)
            objc_setAssociatedObject(
                self,
                &closureKey,
                newValue,
                .OBJC_ASSOCIATION_COPY_NONATOMIC
            )
            
            if newValue != nil {
                addTarget(self, action: #selector(handleTap), for: .touchUpInside)
            }
        }
    }
    
    @objc private func handleTap() {
        tapHandler?()
    }
}

// 사용 예제
class ButtonViewController: UIViewController {
    let button = UIButton()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // ✨ weak self 사용
        button.tapHandler = { [weak self] in
            guard let self = self else { return }
            self.handleButtonTap()
        }
    }
    
    func handleButtonTap() {
        print("버튼 탭됨")
    }
    
    deinit {
        print("ButtonViewController 해제됨")
    }
}

✅ 메모리 경고 처리

class ImageCacheManager {
    static let shared = ImageCacheManager()
    
    private var imageCache: [String: UIImage] = [:]
    private let cacheQueue = DispatchQueue(label: "com.app.imageCache")
    
    private init() {
        // ✨ 메모리 경고 감지
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }
    
    @objc private func handleMemoryWarning() {
        print("⚠️ 메모리 경고 수신!")
        clearCache()
    }
    
    func cacheImage(_ image: UIImage, forKey key: String) {
        cacheQueue.async { [weak self] in
            self?.imageCache[key] = image
        }
    }
    
    func getImage(forKey key: String) -> UIImage? {
        return cacheQueue.sync {
            return imageCache[key]
        }
    }
    
    func clearCache() {
        cacheQueue.async { [weak self] in
            self?.imageCache.removeAll()
            print("✅ 캐시 정리 완료")
        }
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

// ViewController에서 메모리 경고 처리
class MyViewController: UIViewController {
    var largeDataArray: [Data] = []
    
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        
        print("⚠️ ViewController 메모리 경고")
        
        // ✨ 불필요한 데이터 정리
        largeDataArray.removeAll()
        
        // ✨ 이미지 캐시 정리
        ImageCacheManager.shared.clearCache()
        
        // ✨ 뷰가 화면에 없으면 해제
        if !isViewLoaded || view.window == nil {
            view = nil
        }
    }
}

✅ Autorelease Pool 사용

class DataProcessor {
    func processLargeDataSet() {
        let dataCount = 100000
        
        // ❌ 비효율적인 방법
        func inefficientWay() {
            var results: [String] = []
            for i in 0..<dataCount {
                let data = createLargeObject(index: i)
                results.append(data.description)
            }
            // 모든 임시 객체가 루프 끝까지 메모리에 남음
        }
        
        // ✅ 효율적인 방법
        func efficientWay() {
            var results: [String] = []
            for i in 0..<dataCount {
                autoreleasepool {
                    // ✨ 각 반복마다 임시 객체 해제
                    let data = createLargeObject(index: i)
                    results.append(data.description)
                    // autoreleasepool 블록이 끝나면 즉시 해제됨
                }
            }
        }
        
        efficientWay()
    }
    
    func createLargeObject(index: Int) -> NSData {
        // 큰 데이터 객체 생성
        let size = 1024 * 1024  // 1MB
        return NSData(bytes: malloc(size), length: size)
    }
}

// 실전 예제: 이미지 처리
class ImageProcessor {
    func processImages(_ imageURLs: [URL]) {
        for url in imageURLs {
            autoreleasepool {
                // ✨ 각 이미지 처리 후 즉시 메모리 해제
                if let image = UIImage(contentsOfFile: url.path) {
                    let processedImage = applyFilters(to: image)
                    saveImage(processedImage, to: url)
                }
                // 여기서 임시 이미지 객체들이 해제됨
            }
        }
    }
    
    func applyFilters(to image: UIImage) -> UIImage {
        // 필터 적용 로직
        return image
    }
    
    func saveImage(_ image: UIImage, to url: URL) {
        // 이미지 저장 로직
    }
}

✅ 화면 전환 테스트 방법

class TestViewController: UIViewController {
    // ✨ 테스트용 식별자
    let identifier = UUID().uuidString
    
    override func viewDidLoad() {
        super.viewDidLoad()
        print("[\(identifier)] viewDidLoad")
        setupUI()
    }
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        print("[\(identifier)] viewWillAppear")
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        print("[\(identifier)] viewDidDisappear")
    }
    
    deinit {
        // ✨ 이게 출력되면 정상!
        print("[\(identifier)] deinit - 메모리 해제됨 ✅")
    }
    
    func setupUI() {
        view.backgroundColor = .white
        
        let closeButton = UIButton(frame: CGRect(x: 100, y: 100, width: 200, height: 50))
        closeButton.setTitle("닫기", for: .normal)
        closeButton.backgroundColor = .systemBlue
        
        // ✨ weak self 사용
        closeButton.tapHandler = { [weak self] in
            self?.dismiss(animated: true)
        }
        
        view.addSubview(closeButton)
    }
}

// 테스트 실행
class MainViewController: UIViewController {
    @IBAction func showTestVC() {
        let testVC = TestViewController()
        present(testVC, animated: true)
        
        // 5초 후 자동으로 닫기 (테스트용)
        DispatchQueue.main.asyncAfter(deadline: .now() + 5) { [weak testVC] in
            testVC?.dismiss(animated: true)
            
            // 1초 후 deinit 확인
            DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
                print("테스트 완료 - 콘솔에서 deinit 확인")
            }
        }
    }
}

✅ 장시간 실행 테스트 코드

class LongRunningTestViewController: UIViewController {
    var testCount = 0
    var timer: Timer?
    var startMemory: UInt64 = 0
    
    override func viewDidLoad() {
        super.viewDidLoad()
        startMemory = getMemoryUsage()
        startTest()
    }
    
    func startTest() {
        print("=== 장시간 실행 테스트 시작 ===")
        print("시작 메모리: \(formatBytes(startMemory))")
        
        // 1초마다 화면 생성/해제 반복
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            guard let self = self else { return }
            self.performTestCycle()
        }
    }
    
    func performTestCycle() {
        testCount += 1
        
        // 테스트 ViewController 생성
        let testVC = TestViewController()
        addChild(testVC)
        view.addSubview(testVC.view)
        testVC.didMove(toParent: self)
        
        // 즉시 제거
        testVC.willMove(toParent: nil)
        testVC.view.removeFromSuperview()
        testVC.removeFromParent()
        
        // 10회마다 메모리 체크
        if testCount % 10 == 0 {
            let currentMemory = getMemoryUsage()
            let increase = currentMemory - startMemory
            
            print("""
            
            --- 테스트 \(testCount)회 ---
            현재 메모리: \(formatBytes(currentMemory))
            증가량: \(formatBytes(increase))
            """)
            
            // 메모리가 50MB 이상 증가하면 경고
            if increase > 50 * 1024 * 1024 {
                print("⚠️ 메모리 누수 의심!")
                stopTest()
            }
        }
        
        // 100회 테스트 후 종료
        if testCount >= 100 {
            stopTest()
        }
    }
    
    func stopTest() {
        timer?.invalidate()
        timer = nil
        
        let finalMemory = getMemoryUsage()
        let totalIncrease = finalMemory - startMemory
        
        print("""
        
        === 테스트 완료 ===
        총 실행 횟수: \(testCount)
        시작 메모리: \(formatBytes(startMemory))
        최종 메모리: \(formatBytes(finalMemory))
        총 증가량: \(formatBytes(totalIncrease))
        
        판정: \(totalIncrease < 10 * 1024 * 1024 ? "✅ 정상" : "🚨 메모리 누수 의심")
        """)
    }
    
    func getMemoryUsage() -> UInt64 {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        return kerr == KERN_SUCCESS ? info.resident_size : 0
    }
    
    func formatBytes(_ bytes: UInt64) -> String {
        let formatter = ByteCountFormatter()
        formatter.allowedUnits = [.useMB]
        formatter.countStyle = .memory
        return formatter.string(fromByteCount: Int64(bytes))
    }
    
    deinit {
        timer?.invalidate()
    }
}

✅ 메모리 안전 코딩 규칙

규칙 1: Delegate는 항상 weak

// ✅ 올바른 방법
protocol MyDelegate: AnyObject {
    func didSomething()
}

class MyClass {
    weak var delegate: MyDelegate?
}

// ❌ 잘못된 방법
protocol MyDelegate {  // AnyObject 없음
    func didSomething()
}

class MyClass {
    var delegate: MyDelegate?  // weak 없음
}

규칙 2: 클로저에서 self 사용 시 항상 캡처 리스트

// ✅ 올바른 방법
someAsyncFunction { [weak self] in
    guard let self = self else { return }
    self.doSomething()
}

// ❌ 잘못된 방법
someAsyncFunction {
    self.doSomething()  // 순환 참조 위험!
}

규칙 3: deinit에서 리소스 정리

// ✅ 올바른 방법
class MyViewController: UIViewController {
    var timer: Timer?
    var observer: NSObjectProtocol?
    
    deinit {
        timer?.invalidate()
        if let observer = observer {
            NotificationCenter.default.removeObserver(observer)
        }
        print("MyViewController 해제됨")
    }
}

규칙 4: 큰 데이터는 lazy 초기화

// ✅ 올바른 방법
class DataManager {
    lazy var largeDataSet: [Data] = {
        // 실제로 필요할 때만 로드
        return loadLargeData()
    }()
    
    private func loadLargeData() -> [Data] {
        // 무거운 데이터 로딩
        return []
    }
}

✅ 방어적 코딩 패턴

패턴 1: Optional Chaining 적극 활용

// ✅ 안전한 방법
class SafeViewController: UIViewController {
    weak var delegate: MyDelegate?
    
    func notifyDelegate() {
        // Optional chaining으로 안전하게 호출
        delegate?.didSomething()
        
        // guard let으로 안전하게 처리
        guard let delegate = delegate else {
            print("Delegate가 없음")
            return
        }
        delegate.didSomething()
    }
}

패턴 2: 명시적 nil 할당

// ✅ 명확한 리소스 해제
class ResourceManager {
    var heavyResource: HeavyObject?
    
    func cleanup() {
        // 명시적으로 nil 할당
        heavyResource = nil
        print("리소스 해제됨")
    }
    
    deinit {
        cleanup()
    }
}

패턴 3: 조건부 컴파일로 디버그 코드 추가

class DebugViewController: UIViewController {
    #if DEBUG
    private var allocationTime = Date()
    #endif
    
    init() {
        super.init(nibName: nil, bundle: nil)
        #if DEBUG
        print("[\(type(of: self))] 생성됨 at \(allocationTime)")
        #endif
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
    }
    
    deinit {
        #if DEBUG
        let lifetime = Date().timeIntervalSince(allocationTime)
        print("[\(type(of: self))] 해제됨 (생존시간: \(lifetime)초)")
        #endif
    }
}

✅ 메모리 모니터링 유틸리티

class MemoryMonitor {
    static let shared = MemoryMonitor()
    
    private var timer: Timer?
    private var isMonitoring = false
    
    private init() {}
    
    func startMonitoring(interval: TimeInterval = 1.0) {
        guard !isMonitoring else { return }
        
        isMonitoring = true
        timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
            self?.logMemoryUsage()
        }
    }
    
    func stopMonitoring() {
        timer?.invalidate()
        timer = nil
        isMonitoring = false
    }
    
    private func logMemoryUsage() {
        let usage = getMemoryUsage()
        let formatted = formatBytes(usage)
        
        #if DEBUG
        print("💾 메모리 사용량: \(formatted)")
        
        // 임계값 체크 (예: 200MB)
        if usage > 200 * 1024 * 1024 {
            print("⚠️ 메모리 사용량이 높습니다!")
        }
        #endif
    }
    
    func getMemoryUsage() -> UInt64 {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
        
        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }
        
        return kerr == KERN_SUCCESS ? info.resident_size : 0
    }
    
    func formatBytes(_ bytes: UInt64) -> String {
        let formatter = ByteCountFormatter()
        formatter.allowedUnits = [.useMB, .useGB]
        formatter.countStyle = .memory
        return formatter.string(fromByteCount: Int64(bytes))
    }
    
    deinit {
        stopMonitoring()
    }
}

// AppDelegate에서 사용
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication, 
                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        #if DEBUG
        // 디버그 모드에서만 모니터링 시작
        MemoryMonitor.shared.startMonitoring()
        #endif
        
        return true
    }
}