ARC(Automatic Reference Counting)

Contents

• ARC
  • 참조카운팅 시점: 컴파일시
  • 장점: 컴파일시 인스턴스 해제 시점이 정해져서 메모리 해제 시점 예측 가능, 메모리 관리를 위한 시스템 자원 추가 불필요
  • 단점: 인스턴스 메모리가 영원히 해제되지 않을 가능성 존재
• Garbage Collection
  • 참조카운팅 시점: 런타임
  • 장점: 특별히 규칙에 신경 쓸 필요 없음
  • 단점: 메모리 감시를 위한 추가 자원 필요, 인스턴스가 정확히 언제 해제될지 예측하기 어려움
• Strong Reference
• Weak Reference
  • weak var xxx: should be optional
• Unowned Reference
  • unowned var/let xxx : should not be optional
• Strong reference in closure
  • https://outofbedlam.github.io/swift/2016/01/31/Swift-ARC-Closure-weakself/

Details

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

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

reference1 = Person(name: "John Appleseed")
reference2 = reference1
reference3 = reference1

reference1 = nil
reference2 = nil
reference3 = nil
// We should see the message that the Person object has been deinitialized however 
// due to the playground this has not occured.

// Strong Reference cycles between Classes
class Person2 {
    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: Person2?
    deinit { print("Apartment #\(unit) is being deinitialized") }
}

var john: Person2?
var unit4A: Apartment?

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

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

//  Unfortunately, linking these two instances creates a strong reference cycle between them. 
// The Person instance now has a strong reference to the Apartment instance, 
// and the Apartment instance has a strong reference to the Person instance. 
// Therefore, when you break the strong references held by the john and number73 variables, 
// the reference counts do not drop to zero, and the instances are not deallocated by ARC:
john = nil
unit4A = nil
// We have now leaked memory
// Resolving Strong Reference Cycles between Class Instances
// Use a weak reference whenever it is valid for that reference to become nil 
// at some point during its lifetime. Conversely, use an unowned reference 
// when you know that the reference will never be nil once it has been set during initialization.

// Weak References
class Person3 {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment3?
    deinit { print("\(name) is being deinitialized") }
}

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

var james: Person3?
var number74: Apartment3?

james = Person3(name: "James Appleseed")
number74 = Apartment3(unit: "74")

james!.apartment = number74
number74!.tenant = james

james = nil
number74 = nil

// Unowned References
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
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

var justin: Customer?
justin = Customer(name: "Justin McIntyre")
justin!.card = CreditCard(number: 1234_5678_9012_3456, customer: justin!)
justin = nil


// Unowned References and Implicitly Unwrapped Optional Properties
//  Both properties should always have a value, and neither property should ever be nil 
// once initialization is complete. This enables both properties to be accessed directly 
// (without optional unwrapping) once initialization is complete, while still avoiding a reference cycle.
class Country {
    let name: String
    var capitalCity: City!
    init(name: String, capitalName: String) {
        self.name = name
        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
    }
}
// The initializer for City is called from within the initializer for Country. 
// However, the initializer for Country cannot pass self to the City initializer 
// until a new Country instance is fully initialized, as described in Two-Phase Initialization. 
// To cope with this requirement, you declare the capitalCity property of Country 
// as an implicitly unwrapped optional property, indicated by the exclamation mark 
// at the end of its type annotation (City!). 
// This means that the capitalCity property has a default value of nil, like any other optional, 
// but can be accessed without the need to unwrap its value.
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")

• http://jhyejun.com/blog/strong-reference-cycles-in-closure

// Strong Reference Cycles for Closures
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) is being deinitialized")
    }
}

let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
    return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())


var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())
//  Unfortunately, the HTMLElement class, as written above, 
// creates a strong reference cycle between an HTMLElement instance 
// and the closure used for its default asHTML value. 
paragraph = nil
//  Note that the message in the HTMLElement deinitializer is not printed, 
// which shows that the HTMLElement instance is not deallocated.
// Resolving Strong Reference Cycles for Closures
/*
@lazy var someClosure: (Int, String) -> String = {
    [unowned self] (index: Int, stringToProcess: String) -> String in
    // Closure body goes here
}
*/

class HTMLElement2 {
    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) is being deinitialized")
    }
}
var paragraph2: HTMLElement2? = HTMLElement2(name: "p", text: "hello, world")
print(paragraph2!.asHTML())

paragraph2 = nil
// prints "p is being deinitialized"

Reference

• https://medium.com/the-traveled-ios-developers-guide/arc-swift-d323535baecb
• https://medium.com/@JoyceMatos/arc-strong-and-weak-references-in-swift-f2a085a17119
• https://medium.com/@JimmyMAndersson/understanding-arcs-effect-on-your-apps-performance-377e39076a88
• https://medium.com/swift2go/beginning-swift-programming-part-7-initialization-and-de-initialization-overrides-and-reference-4e745ba40d0c
• https://medium.com/yay-its-erica/a-brief-introduction-arc-and-weak-unowned-vs-strong-references-dae2ba59ccb2
• https://medium.com/ios-seminar/swifts-arc-and-memory-leaks-1a227cae55da
• https://medium.com/disblu/what-is-arc-automatic-reference-counting-5f2330497b3d
• https://medium.com/@how_noobs_think/swift-arc-behavior-of-strong-reference-from-a-weak-referenced-capture-list-3d1cbc67dc3
• https://medium.com/@enricopiovesan/arc-swift-tutorial-d42dea53eddb
• https://medium.com/@Dougly/automatic-reference-counting-arc-swift-3-d13ef5843763
• https://medium.com/@jang.wangsu/ios-swift-rc-arc-%EC%99%80-mrc-%EB%9E%80-%EA%B7%B8%EB%A6%AC%EA%B3%A0-strong-weak-unowned-%EB%8A%94-%EA%B0%84%EB%8B%A8%ED%95%98%EA%B2%8C-%EC%A0%81%EC%96%B4%EB%B4%A4%EC%8A%B5%EB%8B%88%EB%8B%A4-988a293c04ac
• https://medium.com/@vialyx/swift-intro-to-ios-development-automatic-reference-counting-521d9998be