Swift 공식 문서 정리 - 자동 참조 카운팅 (Automatic Reference Counting)

안녕하세요! 오늘은 Swift의 '자동 참조 카운팅(Automatic Reference Counting, ARC)'에 대해 알아보겠습니다. 메모리 관리는 앱 성능과 안정성에 직결되는 중요한 주제인데요, Swift의 ARC를 이해하면 메모리 누수 없는 효율적인 앱을 개발할 수 있습니다.

📌 ARC란 무엇인가?

자동 참조 카운팅(ARC)은 Swift에서 메모리 사용량을 자동으로 추적하고 관리하는 시스템입니다. ARC는 클래스 인스턴스가 더 이상 필요하지 않을 때 자동으로 메모리를 해제합니다.

대부분의 경우 메모리 관리는 "그냥 동작하는" 방식으로, 개발자가 특별히 신경 쓸 필요가 없습니다. 하지만 특정 상황에서는 코드의 객체 간 관계에 대해 ARC에 추가 정보를 제공해야 할 필요가 있습니다.

중요: ARC는 클래스 인스턴스에만 적용됩니다. 구조체(struct)와 열거형(enum)은 값 타입이므로 참조로 저장되거나 전달되지 않습니다.

📌 ARC의 작동 원리

클래스의 새 인스턴스를 생성할 때 ARC는 인스턴스 정보를 저장할 메모리를 할당합니다. 이 메모리에는:

• 인스턴스의 타입 정보
• 인스턴스와 관련된 모든 저장 프로퍼티의 값이 포함됩니다

인스턴스가 더 이상 필요하지 않으면 ARC는 해당 메모리를 해제하여 다른 용도로 사용할 수 있게 합니다. 이는 필요하지 않은 인스턴스가 메모리를 차지하지 않도록 보장합니다.

ARC가 사용 중인 인스턴스의 메모리를 해제한다면? 해당 인스턴스의 프로퍼티나 메서드에 더 이상 접근할 수 없게 되고, 접근을 시도하면 앱이 충돌(crash)하게 됩니다!

이를 방지하기 위해 ARC는 몇 개의 프로퍼티, 상수, 변수가 각 클래스 인스턴스를 참조하고 있는지 추적합니다. 인스턴스에 대한 활성 참조가 하나라도 존재하는 한 ARC는 인스턴스를 메모리에서 해제하지 않습니다.

📌 ARC 실제 동작 예제

다음 예제를 통해 ARC가 어떻게 동작하는지 알아보겠습니다:

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name)이(가) 초기화됩니다")
    }
    deinit {
        print("\(name)이(가) 메모리에서 해제됩니다")
    }
}

// 옵셔널 Person 타입의 변수들 생성
var reference1: Person?
var reference2: Person?
var reference3: Person?

// 새 Person 인스턴스 생성
reference1 = Person(name: "홍길동")
// 출력: "홍길동이(가) 초기화됩니다"

// 같은 인스턴스를 다른 변수에도 할당 (강한 참조 추가)
reference2 = reference1
reference3 = reference1

// 두 개의 변수에서 참조 해제
reference1 = nil
reference2 = nil

// 여전히 하나의 강한 참조가 남아있음
// 인스턴스는 해제되지 않음

// 마지막 강한 참조 해제
reference3 = nil
// 출력: "홍길동이(가) 메모리에서 해제됩니다"

이 예제에서 볼 수 있듯이:

1. Person 인스턴스가 생성되면 reference1에 강한 참조가 설정됩니다.
2. 이 인스턴스를 reference2와 reference3에 할당하면 강한 참조가 3개가 됩니다.
3. reference1과 reference2를 nil로 설정해도 reference3가 여전히 인스턴스를 참조하고 있어 메모리에서 해제되지 않습니다.
4. 마지막으로 reference3마저 nil로 설정하면 강한 참조가 없어지고 인스턴스가 메모리에서 해제됩니다.

📌 강한 참조 사이클 문제

ARC는 대부분의 경우 잘 작동하지만, 특별한 상황에서는 문제가 발생할 수 있습니다. 그 중 하나가 **강한 참조 사이클(Strong Reference Cycle)**입니다.

강한 참조 사이클은 두 클래스 인스턴스가 서로를 강하게 참조할 때 발생합니다. 이런 경우, 두 인스턴스는 서로를 "붙잡고" 있어 참조 카운트가 0이 되지 않으므로 메모리에서 해제되지 않습니다.

강한 참조 사이클 예제

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name)이(가) 메모리에서 해제됩니다") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("아파트 \(unit)이(가) 메모리에서 해제됩니다") }
}

// 인스턴스 생성
var john: Person? = Person(name: "홍길동")
var unit4A: Apartment? = Apartment(unit: "4A")

// 서로 참조하도록 설정 (강한 참조 사이클 생성)
john!.apartment = unit4A
unit4A!.tenant = john

// 외부 참조 제거 시도
john = nil
unit4A = nil

// 두 인스턴스 모두 메모리에서 해제되지 않음
// deinit 메시지가 출력되지 않음

위 코드에서 Person과 Apartment 인스턴스는 서로를 강하게 참조하여 강한 참조 사이클을 형성합니다. 외부 참조인 john과 unit4A를 nil로 설정해도 두 인스턴스는 여전히 서로를 참조하고 있어 메모리에서 해제되지 않습니다.

📌 강한 참조 사이클 해결하기

Swift는 강한 참조 사이클을 해결하기 위한 두 가지 방법을 제공합니다:

1. 약한 참조(Weak References)
2. 미소유 참조(Unowned References)

1. 약한 참조(Weak References)

약한 참조는 참조하는 인스턴스를 강하게 유지하지 않습니다. 즉, ARC가 참조된 인스턴스를 해제하는 것을 막지 않습니다. 참조하는 인스턴스가 메모리에서 해제되면 약한 참조는 자동으로 nil이 됩니다.

약한 참조는 weak 키워드를 사용하여 선언합니다:

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name)이(가) 메모리에서 해제됩니다") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?  // 약한 참조로 선언
    deinit { print("아파트 \(unit)이(가) 메모리에서 해제됩니다") }
}

var john: Person? = Person(name: "홍길동")
var unit4A: Apartment? = Apartment(unit: "4A")

john!.apartment = unit4A
unit4A!.tenant = john

john = nil
// 출력: "홍길동이(가) 메모리에서 해제됩니다"

unit4A = nil
// 출력: "아파트 4A이(가) 메모리에서 해제됩니다"

약한 참조는 다음과 같은 특징이 있습니다:

• 항상 옵셔널 타입의 변수로 선언됩니다 (참조가 nil이 될 수 있어야 하므로)
• 참조 대상이 먼저 메모리에서 해제될 수 있는 경우에 사용합니다

2. 미소유 참조(Unowned References)

미소유 참조도 참조하는 인스턴스를 강하게 유지하지 않습니다. 그러나 약한 참조와 달리, 미소유 참조는 참조하는 인스턴스가 항상 자신보다 오래 존재한다고 가정합니다.

미소유 참조는 unowned 키워드를 사용하여 선언합니다:

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name)이(가) 메모리에서 해제됩니다") }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer  // 미소유 참조로 선언
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("카드 #\(number)가 메모리에서 해제됩니다") }
}

var john: Customer? = Customer(name: "홍길동")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

john = nil
// 출력: "홍길동이(가) 메모리에서 해제됩니다"
// 출력: "카드 #1234567890123456가 메모리에서 해제됩니다"

미소유 참조의 특징:

• 옵셔널이 아닌 타입으로 선언됩니다
• 참조 대상이 항상 자신보다 같거나 오래 존재하는 경우에 사용합니다
• 미소유 참조가 해제된 인스턴스를 참조하면 런타임 오류가 발생합니다

미소유 옵셔널 참조

Swift 5부터는 옵셔널 타입에도 unowned를 사용할 수 있게 되었습니다:

class Department {
    var name: String
    var courses: [Course]
    init(name: String) {
        self.name = name
        self.courses = []
    }
}

class Course {
    var name: String
    unowned var department: Department
    unowned var nextCourse: Course?  // 미소유 옵셔널 참조
    init(name: String, in department: Department) {
        self.name = name
        self.department = department
        self.nextCourse = nil
    }
}

📌 클로저와 강한 참조 사이클

클래스 인스턴스 간에만 강한 참조 사이클이 발생하는 것은 아닙니다. 클로저(Closure)와 클래스 인스턴스 사이에서도 강한 참조 사이클이 발생할 수 있습니다.

클로저는 참조 타입이며, 클로저 내부에서 self를 사용하여 클래스 인스턴스의 프로퍼티나 메서드에 접근하면 해당 인스턴스를 강하게 캡처합니다. 동시에 클래스 인스턴스가 클로저를 프로퍼티로 가지고 있다면, 서로 강한 참조를 유지하게 됩니다.

클로저의 강한 참조 사이클 예제

class HTMLElement {
    let name: String
    let text: String?
    
    lazy var asHTML: () -> String = {
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        print("\(name)이(가) 메모리에서 해제됩니다")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "안녕하세요")
print(paragraph!.asHTML())
// 출력: "<p>안녕하세요</p>"

paragraph = nil
// deinit 메시지가 출력되지 않음 - 메모리 누수 발생

이 예제에서 asHTML 클로저는 self를 강하게 캡처하고, HTMLElement 인스턴스는 asHTML 클로저를 강하게 참조합니다. 이로 인해 강한 참조 사이클이 형성되어 메모리 누수가 발생합니다.

📌 클로저의 강한 참조 사이클 해결하기

클로저의 강한 참조 사이클을 해결하기 위해 Swift는 **캡처 리스트(Capture List)**를 제공합니다. 캡처 리스트는 클로저 내에서 캡처할 때 사용할 참조 타입을 정의합니다.

캡처 리스트 사용법

class HTMLElement {
    let name: String
    let text: String?
    
    lazy var asHTML: () -> String = {
        [unowned self] in  // 캡처 리스트 사용
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }
    
    init(name: String, text: String? = nil) {
        self.name = name
        self.text = text
    }
    
    deinit {
        print("\(name)이(가) 메모리에서 해제됩니다")
    }
}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "안녕하세요")
print(paragraph!.asHTML())
// 출력: "<p>안녕하세요</p>"

paragraph = nil
// 출력: "p이(가) 메모리에서 해제됩니다"

캡처 리스트는 클로저의 매개변수 목록 앞에 대괄호([]) 내에 작성합니다. 위 예제에서 [unowned self]는 "클로저에서 self를 미소유 참조로 캡처하라"는 의미입니다.

캡처 리스트 정의 방법

// 매개변수와 반환 타입이 있는 경우
lazy var someClosure = {
    [unowned self, weak delegate = self.delegate]
    (index: Int, stringToProcess: String) -> String in
    // 클로저 본문
}

// 매개변수와 반환 타입이 없는 경우
lazy var someClosure = {
    [unowned self, weak delegate = self.delegate] in
    // 클로저 본문
}

📌 약한 참조와 미소유 참조 중 선택하기

약한 참조와 미소유 참조 중 어떤 것을 선택해야 할까요?

1. 약한 참조(weak)를 사용하는 경우:
   • 참조하는 인스턴스가 먼저 메모리에서 해제될 수 있는 경우
   • 참조가 나중에 nil이 될 수 있는 경우
   • 예: 델리게이트 패턴, 부모-자식 관계에서 부모가 자식을 참조할 때
2. 미소유 참조(unowned)를 사용하는 경우:
   • 참조하는 인스턴스가 자신과 같은 수명을 가지거나 더 오래 존재하는 경우
   • 참조가 절대 nil이 되지 않아야 하는 경우
   • 예: 신용카드와 고객의 관계처럼 한 객체가 다른 객체 없이는 존재할 수 없는 경우

📌 정리

자동 참조 카운팅(ARC)은 Swift에서 메모리 관리를 자동화하여 개발자의 부담을 줄여주는 중요한 기능입니다. 그러나 강한 참조 사이클과 같은 문제를 방지하기 위해서는 약한 참조와 미소유 참조를 적절히 사용하는 방법을 이해해야 합니다.

주요 기억 포인트:

• ARC는 클래스 인스턴스에만 적용됩니다 (구조체와 열거형은 값 타입)
• 강한 참조 사이클은 메모리 누수의 주요 원인입니다
• 약한 참조(weak)는 참조가 nil이 될 수 있을 때 사용합니다
• 미소유 참조(unowned)는 참조가 항상 유효할 때 사용합니다
• 클로저에서는 캡처 리스트를 사용하여 강한 참조 사이클을 방지합니다