[Swift🦩] #25 ARC ⭐️⭐️⭐️

• Automatic Reference Conting 자동 참조 카운팅
• Swift 가 자동적으로 메모리를 추적하고 관리하기 위해서 사용한다.
• ARC 는 인스턴스가 필요하지 않을 때, 메모리에서 내린다.

• 하지만, 프로그래머가 명시적으로 해결해야하는 상황이 있다.
• 참조 카운팅이기 때문에 class 에만 적용된다.

1. ARC 의 작동 원리

1. 새로운 인스턴스 생성 : 메모리의 청크에 할당 (해당 메모리는 인스턴스와 관련된 저장된 프로퍼티 값과 인스턴스 타입에 대한 정보 가짐)
2. 인스턴스 사용~~~
3. 인스턴스가 필요하지 않을 때 : 메모리 할당 해제

• 사용중인 인스턴스를 할당 해제해버리면..? crash 발생
• 그래서 ARC 는 클래스 인스턴스를 참조하고 있는 상수, 변수, 함수, 프로퍼티를 추적해서
• 하나라도 클래스를 참조하고 있는 경우 메모리에서 내리지 않는다.

• 프로퍼티, 상수, 변수에 클래스 인스턴스를 할당할 때마다 프로퍼티, 상수, 변수는 인스턴스에 강한 참조 를 만들게 된다.

2. ARC 동작

Person 이라는 class 코드로 설명한다.

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }
    deinit {
        print("\(name) is being deinitialized")
    }
}

Optional 을 만들면 nil 이 할당되어, 아직 참조하고 있지 않은 상태.

var reference1: Person?
var reference2: Person?
var reference3: Person?

실제 Person 인스턴스를 만들어 할당하는 순간 강한 참조가 만들어진다.

reference1 = Person(name: "John Appleseed")
// Prints "John Appleseed is being initialized"

// 그러면 변수에 할당하지 않고, 초기화 구문만 호출해버리면 어떻게 될까?
Person(name: "DDOSANG")

// 강한 참조 2개 추가. = 3
reference2 = reference1
reference3 = reference1


reference1 = nil // Person 인스턴스에 대한 강한 참조 2
reference2 = nil // Person 인스턴스 강한 참조 1


reference3 = nil  // 강한 참조 0 : 이제 Person 인스턴스를 사용하지 않음. -> 메모리 할당 해제 
// Prints "John Appleseed is being deinitialized"

3. 클래스 - 인스턴스 강한 참조 사이클

• 2번의 예시처럼 강한 참조가 없어져서 메모리에서 할당 해제되는 이상적인 시나리오도 있지만,
• 서로의 인스턴스가 서로를 참조한다면... 강한 참조 사이클에 빠져서 메모리에서 내려가질 않는다.
• 메모리가 작은 모바일 기기에선 강한 참조 사이클을 관리해주는 것이 중요하다.

• 강한 참조 발생 상황 코드로 보기
• Person 과 Apartment 가 각각의 인스턴스를 가지고 있음.

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

• 초기 선언과 할당

// 아직 메모리에 올라가지 않음.
var john: Person?
var unit4A: Apartment?

// 메모리에 올라갔고 Person, Apartment 인스턴스에 각각 참조가 생김.
// 현재 각 인스턴스 내의 apartment, tenant 변수는 nil 로 할당되어 참조되지 않은 상태.
john = Person(name: "John Appleseed") // Person 참조 1
unit4A = Apartment(unit: "4A") // Apartment 참조 1

그런데 여기서 서로를 참조하게 된다면??

john!.apartment = unit4A // Apartment 참조 2
unit4A!.tenant = joh // Person 참조 2

nil 로 변경해도 참조 카운트가 1이기 때문에, 더이상 쓰이지 않는데도 메모리에서 내려가지 않는 상황이 온다.

john = nil // Person 참조 1
unit4A = nil // Apartment 참조 1

4. 강한 참조 사이클 해결 : weak self, unowned self ⭐️⭐️

• 참조 사이클을 형성하는 하나의 인스턴스를
• 강한 참조 유지 없이 다른 인스턴스를 참조하게 하여
• 강한 참조 사이클 없이 서로를 참조할 수 있게 한다.

약한 참조 weak

• 다른 인스턴스의 수명이 더 짧은 경우 (다른 인스턴스가 먼저 할당 해제될 수 있을 때) 약한 참조를 사용한다.
• 약한 참조가 참조하는 동안 해당 인스턴스가 할당 해제 될 수 있다.
• 약한 참조가 참조하는 동안 메모리에서 내려갔다면? 해당 변수를 nil 로 자동 선언한다.
  • 런타임에서 바뀌기 때문에 var 로만 선언할 수 있다.
  • 이 때, property observer 는 불리지 않는다.

• 위의 예제에서 Apartment 소유자는 언젠가 없어질 수 있으니, 여기를 약한 참조 로 바꿔주는 것이 효과적
• weak var delegate?

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    // weak var 로 선언.
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

var john: Person?
var unit4A: Apartment?

아파트 인스턴스 쪽에서 약한 참조를 하고 있다.

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

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

강한 참조를 하고 있는 Person 을 끊어버리면?
약한 참조를 하고 있는 Apartment 의 tennant 는 자동으로 nil 이 할당되며 참조가 끊어지게 된다.

john = nil
// Prints "John Appleseed is being deinitialized"

그리고 unit4A 참조도 끊으면?

unit4A = nil
// Prints "Apartment 4A is being deinitialized"

둘 다 할당이 해제된다.

NOTE: 가비지 컬렉션을 사용하는 시스템 (ex. js) 에서는 메모리 압력이 가비지 콜렉션을 트리거 할 때만 강한 참조가 없는 객체를 메모리에서 내린다. 그래서 캐싱을 weak reference 로 활용하는 경우가 있는데,

Swift 는 참조 카운트가 0이 되자마자 메모리에서 내려버리기 때문에 캐싱을 그런 방식으로 구현했다간 캐싱된 데이터는 쓰지 못했는데 메모리에서 내려가있는 경우가 발생할 수 있다.

미소유 참조 unowned

• 역시 참조하는 인스턴스를 강하게 유지하지 않는다.
• 하지만, 다른 인스턴스의 수명이 같거나 더 긴 경우에 사용한다.
• 항상 값을 가질 것으로 예상된다.
  • 당연함. weak 에서는 먼저 메모리에서 내려간 경우 nil 이 할당됐지만,
  • unowned 는 참조하는 인스턴스가 먼저 내려가지 않는다는 강한 확신이 있는 경우에 사용
  • 그래서 Optional 로 선언되어도 해당 인스턴스가 메모리에서 내려간다고 nil 이 할당되지 않는다. -> let 가능.
  • 할당 해제된 후에 unowned 값에 접근하면 runtime error 가 발생한다.

• 예제 -> Customer / CreditCard
• CreditCard 는 Customer 보다 오래 지속되지 않는다.
  • CreditCard 는 Customer 가 메모리에 있는 동안 쓰인다고 확신.

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
    let number: UInt64
    // customer 를 unowned 변수로 설정.
    // weak 과 달리 자동으로 nil 이 할당되지 않으므로 let 가능.
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

var john: Customer? // nil

john = Customer(name: "John Appleseed") // Customer ARC 1
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!) // CreditCard ARC 1

만약 john 을 끊는다면
CreditCard ARC 1
Customer ARC 0

이 되어서, Customer 가 내려가고, CreditCard 도 내려간다. CreditCard 도 같이 내려가는 것. 남아서 쓰이지 않기 때문에 unowned 가 가능하다.

john = nil
// Prints "John Appleseed is being deinitialized"
// Prints "Card #1234567890123456 is being deinitialized"

대신 unowned 를 사용할 때는 정말로 참조하고 있는 것이 같이 혹은 나중에 내려가는 것이 맞는지에 대해 정확하게 검증해야 한다.

미소유 옵셔널 참조 Unowned Optional

• 클래스에서 옵셔널 참조를 unowned 로 표기할 수 있다.
• 차이점은, 해당 변수를 사용하기 전에
  • 객체를 참조 하고 사용하거나
  • nil 이 아닌지 확인해야 함.

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? // 메모리에서 해당 변수들이 먼저 내려가 버리면 nil
    init(name: String, in department: Department) {
        self.name = name
        self.department = department
        self.nextCourse = nil
    }
}

아래와 같은 상황이라면, department 가 끊어지는 순간, department 를 강하게 참조하는 변수가 없어서 department 내려가고, 그러면 Course 배열 안의 각 코스들도 내려가게 된다.

바로 같이 내려가니까 unowned 사용 가능.

let department = Department(name: "Horticulture")

let intro = Course(name: "Survey of Plants", in: department)
let intermediate = Course(name: "Growing Common Herbs", in: department)
let advanced = Course(name: "Caring for Tropical Plants", in: department)

intro.nextCourse = intermediate
intermediate.nextCourse = advanced
department.courses = [intro, intermediate, advanced]

NOTE : 원래 value type 은 unowned 로 표시할 수가 없다. 그것이 Swift 의 규칙임 (참조는 class 만 하니까) 근데, Optinal 은 enum 이지만 unowned 로 표기할 수 있는 예외가 있다.

Optional("class instance") 는 참조 카운트를 사용하지 않기 때문에, 강한 참조를 유지할 필요가 없다.

Unowned References and Implicity Unwrapped Optional Properties

1. weak - nil 이 될 수 있고, 강한 참조 사이클 유발 가능성이 있을 때
2. unowned - 하나는 nil 일 수 있고, 하나는 nil 일 수 없는 프로퍼티가 강한 참조 사이클을 유발할 수 있는 가능성이 있을 때,
3. 두 프로퍼티 모두 항상 값이 있고, 초기화가 완료되면 nil 이면 안되는 경우는..?

• 한 클래스의 unowned property 를 다른 클래스에 암시적으로 언래핑 된 Optional Property 와 결합한다.
• 참조 사이클을 피하면서, Optional Unwrapping 없이 직접 접근할 수 있다.
• Type! 을 쓰면 해당 구조체, 열거형, 클래스가 가진 모든 저장 프로퍼티가 초기화 되기 전에 self 에 접근할 수 없었던 것과 달리,
• Type! 을 타입으로 사용한 프로퍼티만 제외한 나머지가 초기화 되면 self 에 접근할 수 있다.
• 그러면서 강한 참조 사이클까지 피할 수 있다.

class Country {
    let name: String
    var capitalCity: City! // 기본 nil 이기 때문에, init에서 name 만 초기화하면 Country 인스턴스가 완벽하게 초기화 된 것으로 간주한다.
    
    
    init(name: String, capitalName: String) {
        self.name = name
        
        // 사실 country 가 완벽 초기화 되기 전에는, self 에 접근할 수가 없음.
        // City! 라는 암시적 언래핑을 사용하면 name 이 설정되자마자 self 에 접근할 수 있다.
        self.capitalCity = City(name: capitalName, country: self)
    }
}

class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}


// 느낌표 안쓰고 capitalCity 접근도 가능하다.
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// Prints "Canada's capital city is called Ottawa"

5. 클로저에 대한 강한 참조 사이클 ⭐️⭐️

• 위에서 클래스 인스턴스 프로퍼티가 서로 강한 참조를 유지해서 강한 참조 사이클이 생기는 경우를 봤는데,

• 클로저 역시 참조타입이기 때문에

• 클래스 인스턴스의 프로퍼티에 클로저를 할당하고,

• 해당 클로저의 바디에서 인스턴스 self 를 캡쳐하는 경우에도 발생할 수 있다.

class HTMLElement {

    let name: String
    let text: String?

    // 클로저 변수. self 캡쳐. lazy 라서 self 에 접근 가능.
    // text 가 있으면 <tag>text</tag>
    // 없으면 <tag /> 로 반환.
    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) is being deinitialized")
    }

}

이런 식으로 사용 가능.

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") // Optinal(HTMLElement)
print(paragraph!.asHTML())
// Prints "<p>hello, world</p>"

클로저와 paragraph 가 참조하고 있는 인스턴스가 서로를 강한 참조 사이클에 몰아넣게 된다.

아래 코드로는 당연히 사이클이 끊기지 않음.

paragraph = nil

6. 클로저에 대한 강한 참조 사이클 해결

• 역시 약한 참조나 미소유 참조를 이용하면 된다.

NOTE : 애초에 클로저 안에서는 self.method(), self.property 처럼 self 를 명시해야 사용이 가능한데, 순환 참조 가능성을 생각해보라는 뜻이다.

캡처 목록 정의

클로저는

• self 같은 클래스 인스턴스
• 어떤 특정한 인스턴스에 대한 참조가 있는 프로퍼티
• 더 많은 캡처 목록은 여기

를 캡처할 수 있고, self, 프로퍼티 각각에 weak / unowned 설정을 해줄 수 있다.

lazy var someClosure = {
    [unowned self, weak delegate = self.delegate]
    (index: Int, stringToProcess: String) -> String in
    // closure body goes here
}

// 컨텍스트 유추 사용.
lazy var someClosure = {
    [unowned self, weak delegate = self.delegate] in
    // closure body goes here
}

약한 참조와 미소유 참조

• 클로저와 캡쳐한 인스턴스가 서로를 참조하면서 같은 시간에 할당이 해제된다면, 미소유 참조를 사용할 수 있다.
• 그치만 같은 시간에 할당되지 않고, 캡처된 self 에 대한 참조가 nil 이 될 수 있다면 약한 참조를 사용한다.

class HTMLElement {

    let name: String
    let text: String?

    // HTMLElement 인스턴스가 내려갈 때 얘도 내려가야하니까 unowned
    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) is being deinitialized")
    }

}

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
// Prints "<p>hello, world</p>"

질문

ARC란 무엇인지 설명하시오.

• ARC 는 Swift 에서 메모리를 관리하기 위한 시스템으로
• 클래스 인스턴스를 참조하는 변수, 프로퍼티, 클로저가 생기면 참조 카운트를 올리고
• nil 로 할당 해제되면 참조 카운트를 내리는 방식으로 동작한다.
• 참조 카운트가 0 이 되면 자동으로 메모리에서도 내린다.

Retain Count 방식에 대해 설명하시오.

• Reference Count 와 같음.
• 해당 객체를 강하게 참조하는 프로퍼티, 클로저 등의 참조 타입이 있으면 1 증가, 참조하는 것이 없어지면 1 감소
• count 가 0이 되면 메모리에서 할당을 해제한다.

Strong 과 Weak 참조 방식에 대해 설명하시오.

• Strong 은 강한 참조인데, Strong 으로 참조되고 있는 것이 하나라도 있으면 메모리에서 내려가지 않고 남게 된다.
• Weak 는 약한 참조인데, Weak 외에 Strong 으로 해당 인스턴스를 참조하고 있는 것이 하나도 없으면 메모리에서 내려간다. weak 의 경우 참조하고 있는 인스턴스가 먼저 메모리에서 내려갈 수 있기 때문에, nil 값이 할당될 수 있다.

순환 참조에 대하여 설명하시오.

• 각 클래스 인스턴스(참조 타입)이 서로를 참조하고 있는 것을 말한다.
• 예를 들어서, A 안에 B 타입의 프로퍼티가 있고, B 안에 A 타입의 프로퍼티가 있다고 가정하고,
• A 와 B 의 인스턴스를 각각 만들어서 서로에게 할당을 해주면, 서로의 인스턴스가 서로를 가르키고 있기 때문에 순환 참조하고 있다고 말한다.

강한 순환 참조 (Strong Reference Cycle) 는 어떤 경우에 발생하는지 설명하시오.

• 강한 순환 참조는 순환 참조 상태에서 서로가 서로를 강하게 참조하고 있어서 실제로는 사용되고 있지 않으나 메모리에서 내려가지 못하는 경우를 말한다.
• weak, unowned 라는 키워드로 해결.
• 클래스 인스턴스를 서로 참조하게 되는 경우에는 해당 변수에 weak / unowned 를 붙여서 선언한다.

참고
https://bbiguduk.gitbook.io/swift/language-guide-1/automatic-reference-counting