[iOS] ARC란 무엇인가?

안녕하세요^^

비모입니다.🤖

 

오늘 얘기해볼 주제는 바로 ARC입니다.

요즘 GIF 관련 메모리 이슈도 있고 또 관련 프레임워크를 만들다보니

메모리 관리에 중요성을 느끼고 있는데요.

이와 관련된 지식들을 확실하게 짚고 넘어가야될 것 같아서 정리해봅니다.

 

 

ARC

자동으로 메모리를 관리해주는 방식.

인스턴스가 적절한 시점에 메모리에서 해제되지 않으면 메모리 자원을 낭비하게 됩니다.

때문에 ARC는 필요하지 않는 메모리를 자동으로 해제시켜줍니다.

 

 

ARC의 작동 방식

클래스의 인스턴스를 생성할 때마다 ARC는 그 인스턴스에 대한 정보를 저장하기 위한 메모리 공간을 할당합니다.

그 메모리 공간에는 인스턴스 타입 정보 및 관련 저장 프로퍼티의 값들이 저장되어 있습니다.

그 후 해당 인스턴스가 더 이상 필요하지 않을 때 ARC가 클래스 인스턴스에서 사용하는 메모리를 자동으로 해제합니다.

 

 

ARC의 장단점

장점

• 컴파일 당시 이미 인스턴스의 해제 시점이 정해져 있어서 인스턴스가 언제 메모리에서 해제될지 예측할 수 있습니다.
• 메모리 관리를 위한 시스템 자원을 추가할 필요가 없습니다.

단점

• ARC의 작동 규칙을 모르고 사용시 인스턴스가 메모리에서 해제되지 않을 가능성이 있습니다.

 

 

ARC 사용 규칙

• 아직 더 사용해야 하는 인스턴스를 메모리에서 해제시키면 인스턴스와 관련된 프로퍼티에 접근하거나 인스턴스의 메서드를 호출할 수 없습니다.
• 인스턴스에 강제로 접근하려고 하면 잘못된 메모리 접근으로 인해 프로그램이 강제 종료 될 수 있습니다.
• 인스턴스가 필요한 상황에서 ARC는 인스턴스가 메모리에서 해제되지 않도록 인스턴스 참조 여부를 계속 추적해야 합니다.
• 다른 인스턴스의 프로퍼티나 변수, 상수등 어느 한곳에서 인스턴스를 참조한다면 ARC가 해당 인스턴스를 해제하지 않고 유지해야 하는 명분이 됩니다.
• 인스턴스를 메모리에 유지시키려면 이런 명분을 ARC에게 제공해야 합니다.

 

 

💪🏼강한참조 (Strong Reference)

• 인스턴스가 메모리에 계속 남아있게 해주는 명분은 바로 강한 참조(Strong Reference)입니다.
• 코드들로 확인해보겠습니다.

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

var reference1: Robot?
var reference2: Robot?
var reference3: Robot?

reference1 = Person(name: "BMO")
// BMO is being initialized
// 인스턴스의 참조 횟수 : 1

reference2 = reference1 // 인스턴스의 참조 횟수 : 2
reference3 = reference1 // 인스턴스의 참조 횟수 : 3

• 인스턴스는 참조 횟수가 0이 되는 순간 메모리를 해제하게 되는데, 인스턴스(reference1)를 다른 인스턴스(reference2, reference3)의 프로퍼티나 변수, 상수 등에 할당할 때 강한 참조를 사용하면 참조 횟수가 1 증가하게 됩니다.

 

//메모리 주소 출력
print(Unmanaged.passUnretained(reference1!).toOpaque()) ///0x0000600002a77c00출력 
print(Unmanaged.passUnretained(reference2!).toOpaque()) ///0x0000600002a77c00출력 
print(Unmanaged.passUnretained(reference3!).toOpaque()) ///0x0000600002a77c00출력

• 그 다음 메모리 주소를 한번 보겠습니다.
• reference1, 2, 3 모두 같은 메모리 주소를 참조하고 있다는 것을 알 수 있습니다.

 

reference1 = nil // 인스턴스의 참조 횟수 : 2
reference2 = nil // 인스턴스의 참조 횟수 : 1
reference3 = nil // 인스턴스의 참조 횟수 : 0
// BMO is being deinitialized

• 위처럼 reference1이 참조 해제되어도 Robot 인스턴스 아직 reference2, reference3에 대한 강한 참조를 유지하고 있으므로 deallocated가 되지 않습니다.
• 해당 인스턴스를 deinit시키기 위해선, 해당 인스턴스가 가진 모든 강한 참조를 해제해야 deinit 되는 걸 확인할 수 있습니다.

 

 

💪🏼강한 순환 참조 (Strong Reference Cycle)

강한 참조를 사용할때도 주의해야 될 점이 있습니다. 

바로 "강한 순환 참조" 입니다.

 

강한 순환 참조는 여러 인스턴스가 서로 강한 참조를 하는 사이클을 생성하는 것을 의미합니다.

예를 한번 보겠습니다.

class Robot {
    let name: String
    
    init(name: String) {
        self.name = name
    }
    
    var battery: Battery?
    
    deinit {
        print("\(name) is being deinitialized!")
    }
}
 
class Battery {
    let energy: String
    
    init(energy: String) {
        self.energy = energy
    }
    
    var master: Robot?
    
    deinit {
        print("Battery \(number) is being deinitialized!")
    }
}

• 각각 Robot 클래스와 Battery 클래스가 있습니다.
• Battery 에는 nil로 초기화 된 Robot 타입의 master 프로퍼티가 있습니다.
• Robot 에는 nil로 초기화 된 Battery 타입의 battery 프로퍼티가 있습니다.

 

var bmo: Robot? = Robot(name: "bmo") // Robot 인스턴스 참조 횟수 : 1
var energizer: Battery? = Battery(number: "50") // bmo 인스턴스 참조 횟수 : 1

 

• 각각 인스턴스를 만들어봅시다.

 

bmo?.battery = energizer // Battery 인스턴스 참조 횟수 : 2
energizer?.master = bmo // Robot 인스턴스 참조 횟수 : 2

• robot에 battery 를, battery 에는 robot 을 할당하게 되면 다음과 같습니다.
• Robot 의 인스턴스를 Battery 인스턴스에 대해 강한 참조를 가지고 있고, Battery 의 인스턴스는 Robot 인스턴스에 대해 강한 참조를 가지게 되어 두 인스턴스 사이에는 강한 참조 사이클이 생성 됩니다.

이러한 강한 순환 참조는 어떤 문제가 생기냐면, ARC가 참조 횟수가 0 이 되면 메모리에서 자동으로 할당 해제를 해줘야하는데

강한 순환 참조가 생기게 되면 Reference Count 가 0이 되지 않아 인스턴스 메모리를 계속 차지  (메모리 누수 현상이 발생) 하게 됩니다.

bmo = nil // Robot 인스턴스의 참조 횟수 : 1
energizer = nil // Battery 인스턴스의 참조 횟수 : 1

그렇다면 어떻게 해결해야 할까요? 🤷🏻‍♂️

 

문제를 해결하기 앞서 참조의 종류에 대해서 먼저 알아야 합니다.

 

 

References

Swift 에선 인스턴스를 참조하는 방식이 위에서 설명 드린 강한 참조 외에도 2가지가 있습니다.

 

strong reference

• 참조하는 인스턴스의 Reference Count 를 증가시킵니다.
• 인스턴스를 참조하는 default한 방식입니다.

weak reference

• 참조하는 인스턴스의 Reference Count를 증가 시키지 않습니다.
• 참조하는 인스턴스가 메모리에서 할당 해제될 경우 nil 이 할당 됩니다.

즉, weak reference가 강한 순환 참조를 해결할 수 있는 하나의 방법이 될 수 있습니다.

🎈주의
nil 이 할당 될 수 있기 때문에 옵셔널 타입으로 선언
ARC가 weak 변수를 nil 로 만들때는 프로퍼티 옵저버 (Property observer)가 호출되지 않습니다.

 

unowned reference

• 참조하는 인스턴스의 Reference Count가 증가하지 않습니다.
• 참조하는 인스턴스가 메모리에서 할당 해제될 경우 별다른 조치를 취하지 않습니다.

unowned은 weak와 마찬가지로 강한 순환참조를 해결할 수 있는 방법 중 하나입니다.

 

그러나 weak 와 다르게 옵셔널 타입으로 선언하지 않아도 됩니다.

그 이유는 unowned 참조를 하면 참조하는 인스턴스가 메모리에서 할당 해제되어도 여전히 Heap 영역에 인스턴스가 있던 곳을 가리키고 있습니다. 즉 허상 포인터가 됩니다.

 

허상 포인터(Dangling Pointer)란..?
유효하지 않은 주소를 참조하고 있는 포인터를 말하며 주로 객체 파괴시 발생

그렇기 떄문에, 참조하는 인스턴스가 먼저 메모리에서 해제될 가능성이 없는 경우에만 사용해야합니다.

 

weak vs unowned

구분	weak	unowned
언제?	참조한 객체가 실제 사용할때 해제될지도 모를 때 사용. 보통 짧은주기로 참조할 때 사용	참조한 객체와 생명주기가 같거나 참조한 객체가 더 길때 사용
순환 참조 문제	발생하지 않음	발생하지 않음
참조한 객체가 해제 되었을때	nil로 값이 변경	dangling pointer가 됨

 

 

강한 순환 참조 해결 방법

서로 다른 클래스 인스턴스간에 순환 참조가 있을때, 해당 변수를 weak 또는 unowned 로 선언해서 강한 순환 참조가 생기는 것을 막을 수 있습니다.

 

weak로 해결하였을 때

class Robot {
    // 생략: 위와 동일
}
 
class Battery {
    let energy: String
    
    init(energy: String) {
        self.energy = energy
    }
    
    weak var master: Robot? // weak 를 넣어보았다.
    
    deinit {
        print("Battery \(number) is being deinitialized!")
    }
}

• Battery 에 있는 master를 weak로 바꿔보았다.

 

var bmo: Robot? = Robot(name: "bmo") // Robot 인스턴스 참조 횟수 : 1
var energizer: Battery? = Battery(energy: "50") // bmo 인스턴스 참조 횟수 : 1

bmo?.battery = energizer // Battery 인스턴스 참조 횟수 : 2
energizer?.master = bmo // Robot 인스턴스 참조 횟수 : 2

bmo = nil // Robot 인스턴스의 참조 횟수 : 0
// bmo is being deinitialized!
energizer = nil // Battery 인스턴스의 참조 횟수 : 0
// energizer is being deinitialized!

• deinitialized 가 불리는 것을 확인할 수 있다!

 

unowned로 해결하였을 때

class Robot {
    // 생략: 위와 동일
}
 
class Battery {
    let energy: String
    
    init(energy: String) {
        self.energy = energy
    }
    
    unowned var master: Robot? // weak 를 넣어보았다.
    
    deinit {
        print("Battery \(number) is being deinitialized!")
    }
}

• 이번엔 unowned 로 바꿔 보았다.

 

var bmo: Robot? = Robot(name: "bmo") // Robot 인스턴스 참조 횟수 : 1
var energizer: Battery? = Battery(energy: "50") // bmo 인스턴스 참조 횟수 : 1

bmo?.battery = energizer // Battery 인스턴스 참조 횟수 : 2
energizer?.master = bmo // Robot 인스턴스 참조 횟수 : 2

bmo = nil
// 참조 횟수 0
// bmo is being deinitialized!
// energizer is being deinitialized!

• Robot에 대한 강한 참조가 해제되며 Robot 인스턴스에 대해 강한 참조가 더 이상 없으므로 할당 해제 되었습니다.
• 그 이후 Battery 인스턴스에 대한 강한 참조도 없어지므로 Battery 인스턴스도 할당 해제된 것을 볼 수 있습니다. 

 

 

이상 비모였습니다.🤖

감사합니다.

 

참고자료

https://docs.swift.org/swift-book/LanguageGuide/AutomaticReferenceCounting.html

Automatic Reference Counting — The Swift Programming Language (Swift 5.7)