Swift Concurrency에서 메모리 누수 주의하기 🧐

안녕하세요~ 메모리 누수 문제에 대해 더 자세히 알아볼게요! 이거 진짜 중요한 부분인데 많은 개발자들이 놓치는 함정이에요 ㅋㅋ

Task와 메모리 누수의 관계 💦

Task는 비동기 작업을 시작하는 방법인데, 문제는 Task가 강한 참조(strong reference)를 생성한다는 점이에요. 만약 클로저 내에서 self를 캡처하면 뷰나 객체가 사라져도 Task가 완료될 때까지 메모리에서 해제되지 않을 수 있어요!

func loadData() {
    Task {
        // 여기서 self를 강하게 캡처함
        let data = await self.fetchSomething()
        self.processData(data) // 만약 Task가 오래 걸리는데 객체가 해제되어야 한다면?
    }
}

이렇게 되면 뷰가 화면에서 사라져도 Task가 계속 실행되고, 그 Task가 self를 강하게 참조하고 있어서 메모리에서 해제되지 않는 문제가 생김ㅠㅠ

해결 방법 1: Task 취소하기 💪

첫 번째 방법은 뷰나 객체가 해제될 때 명시적으로 Task를 취소하는 거예요.

class SomeViewModel {
    private var dataTask: Task<Void, Never>?
    
    func loadData() {
        // 기존 작업 취소
        dataTask?.cancel()
        
        // 새 작업 시작
        dataTask = Task {
            do {
                let data = try await fetchSomething()
                await MainActor.run {
                    self.processData(data)
                }
            } catch {
                // 에러 처리
            }
        }
    }
    
    deinit {
        // 객체가 해제될 때 작업 취소
        dataTask?.cancel()
    }
}

SwiftUI에서는 .onDisappear나 .task 수정자를 활용할 수 있어요:

struct ContentView: View {
    @State private var dataTask: Task<Void, Never>?
    
    var body: some View {
        Text("Hello")
            .onAppear {
                dataTask = Task {
                    // 비동기 작업
                }
            }
            .onDisappear {
                // 뷰가 사라질 때 작업 취소
                dataTask?.cancel()
            }
    }
}

더 간단하게는 .task 수정자를 사용하면 뷰가 사라질 때 자동으로 취소해줘요:

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .task {
                // 이 작업은 뷰가 사라지면 자동으로 취소됨
                await fetchData()
            }
    }
}

해결 방법 2: 약한 참조 사용하기 🌱

다른 방법은 클로저 내에서 self를 약하게 참조하는 거예요:

func loadData() {
    Task { [weak self] in
        guard let self = self else { return }
        // 또는 
        // guard let strongSelf = self else { return }
        
        let data = await fetchSomething()
        
        // self가 이미 해제됐으면 여기서 nil이 됨
        await MainActor.run { [weak self] in
            self?.processData(data)
        }
    }
}

해결 방법 3: Task와 비동기 시퀀스 조합하기 💫

iOS 15부터는 AsyncSequence를 사용해 비동기 스트림을 처리할 수 있는데, 이걸 사용하면 자원 관리가 더 쉬워져요:

class ViewModel {
    private var cancellables: Set<AnyCancellable> = []
    
    func startStreaming() {
        let stream = AsyncStream<Data> { continuation in
            // 스트림 설정
            // 종료 시 호출할 수 있는 onTermination 핸들러 제공
        }
        
        Task {
            for await data in stream {
                // 데이터 처리
            }
        }
    }
    
    deinit {
        cancellables.forEach { $0.cancel() }
    }
}

실제 앱에서 자주 발생하는 메모리 누수 시나리오 🧨

1. 긴 다운로드 작업:

func downloadLargeFile() {
    Task {
        let data = try await downloadFile() // 파일이 매우 크면 시간이 오래 걸림
        await MainActor.run {
            self.fileData = data // 다운로드 완료 전에 객체가 해제되어야 한다면?
        }
    }
}

 

2. 무한 스트리밍:

func startLiveUpdates() {
    Task {
        while !Task.isCancelled {
            let update = try await fetchUpdate()
            await MainActor.run {
                self.latestUpdate = update
            }
            try await Task.sleep(for: .seconds(1))
        }
    }
    // Task를 저장하지 않고 취소하지 않으면?
}

 

3. SwiftUI 뷰에서 타이머 사용:

struct TimerView: View {
    @State private var time = 0
    
    var body: some View {
        Text("Time: \(time)")
            .onAppear {
                Task {
                    while true {
                        try await Task.sleep(for: .seconds(1))
                        time += 1
                    }
                }
            }
        // 뷰가 사라져도 타이머는 계속 돌아감ㅋㅋ
    }
}

메모리 누수 디버깅 팁 🔍

1. Xcode Memory Graph Debugger 사용하기:
   • 실행 중 디버그 영역에서 메모리 그래프 버튼 클릭
   • 의심스러운 객체들의 참조 관계 확인
2. Instruments의 Leaks 도구 사용하기:
   • 메모리 누수 자동 탐지
   • 시간에 따른 메모리 사용량 추적
3. deinit에 로그 추가하기:이렇게 하면 객체가 제대로 해제되는지 확인 가능

deinit {
    print("🗑️ \(type(of: self)) deinit 됨!")
}

정리: 메모리 누수 방지를 위한 체크리스트 ✅

1. 비동기 작업을 시작할 때 참조를 저장하고 관리하기:

var currentTask: Task<Void, Never>?

func startWork() {
    currentTask?.cancel()
    currentTask = Task { ... }
}

deinit {
    currentTask?.cancel()
}

 

2. 장기 실행 작업은 취소 가능하게 만들기:

while !Task.isCancelled {
    // 주기적으로 취소 여부 확인
}

 

3. SwiftUI에서는 .task 수정자 활용하기

4. 클로저에서 [weak self] 사용하기

5. 작업 완료 후 참조 해제하기:

dataTask = Task {
    // 작업 완료
    self.dataTask = nil
}

 

Swift Concurrency는 정말 멋진 기능이지만, 이런 메모리 관리에 주의하지 않으면 앱이 점점 느려지거나 메모리 경고가 발생할 수 있어요. 제대로 이해하고 사용하면 앱의 성능과 안정성이 크게 향상됩니다! 💯