[swift] ARC와 메모리 구조

---

---

<TIL>

오늘은 iOS 앱 개발 심화 주간 시작하는 날이었다.
(팀도 새로 바뀌었는데, 다들 넘 활달하셔서 좋다..☺️)
강의는 다 들었는데,
아직 전체적으로 이해를 못 한 것 같아서 내일 한 번 더 듣고 정리할 예정이다.

오늘은 지난 Escaping Closure 게시글에 이어서
ARC와 메모리 구조에 대해서 정리해 보려고 한다.

---

---

 

ARC

ARC는 Automatic Reference Counting의 약자로
Swift는 이 ARC를 사용하여 Heap 영역의 객체 메모리를 자동으로 관리합니다.


Swift는 컴파일 시에 컴파일러가 메모리에서 해제하는 코드를 적절히 넣어줌으로써
개발자가 수동으로 메모리를 관리하지 않도록 도와줍니다.☺️


RC(Reference Counting)은 말 그대로!!
참조(reference)를 세서 해당 객체가 참조될 때 참조값을 늘리고,
더 이상 사용하지 않을 경우에는 참조값을 줄이는 방식을 사용하여
참조값이 0이 될 때 해당 객체를 메모리에서 해제합니다.

- 힙(Heap)메모리에서 해제
- 모든 인스턴스는 자신의 RC(Reference Count) 값을 가지고 있음

이 참조(reference) 방법으로 4가지가 있습니다.

1. Strong Reference(강한 참조)
2. Circular Reference(순환 참조)
3. Weak Reference(약한 참조)
4. Unowned Reference(미소유 참조)


이 4가지를 살펴보기 전에
간단하게 'Swift 메모리 구조'에 대해서 먼저 알아봅시다!

---

 

Swift 메모리 구조

 

프로그램이 실행되면,
운영체제(OS)는 메모리(RAM)에 이 프로그램을 위한 공간을 할당해줍니다.

그 공간은 아래와 같습니다.

이렇게 코드 영역(Code), 데이터 영역(Data), 힙 영역(Heap), 스택 영역(Stack)으로
4가지 영역으로 나누어져 있습니다.

---

1. Code 영역

- 프로그램의 실행 코드가 저장되는 공간입니다.

- 컴파일된 소스 코드와 프로그램의 명령어들이 저장되어 있습니다.

- 우리가 작성한 코드는 기계어 형태로 저장됩니다. (ex.0010101)

- 컴파일 타임에 결정되고, 중간에 코드가 변경되지 않도록 Read-Only 형태로 저장됩니다.

2. Data 영역

- 전역 변수(global vaiables)와 정적 변수(static variables), 상수(constants)가 저장되는 공간입니다.

- 프로그램 시작 시 할당되고 프로그램이 종료될 때까지 유지됩니다. (ex. static)
(= 프로그램이 종료 되어야 메모리가 해제됨)
- 실행 도중 변수 값이 변경될 수 있으니 Read-Write으로 지정됩니다.
 

 

3. Heap 영역

- 프로그램 실행 중(런타임) 동적으로 할당된 데이터가 저장되는 곳입니다.

- 런타임 중에 메모리 할당이 필요한 경우 사용되며, 개발자가 직접 제어할 수 있습니다.

- 힙에 저장된 데이터는 직접적으로 포인터를 통해 접근(참조)됩니다.

- 힙은 스택과는 달리 메모리의 자유 공간을 사용하여 데이터를 저장하므로,
크기나 수명에 대한 동적인 요구에 대응할 수 있습니다.

- 참조타입(Reference Type)이 저장되는 영역입니다.

- 사용하고 난 후에는 반드시 메모리 해제를 해주어야합니다.
(그렇지 않으면 memory leak이 발생)

- Code, Data, Stack 중 유일하게 런타임 시에 결정되기 때문에
데이터의 크기가 확실하지 않을 때 사용합니다.

- 인스턴스가 저장되는 공간

장점	- 메모리 크기에 제한이 없음 - 범위가 전역이기 때문에 프로그램의 모든 함수에서 액세스 할 수 있음
단점	- 할당 작업, 해제 작업으로 인한 속도 저하 - 힙 손상(이중 해제, 해제 후 사용 등)으로 인한 속도 저하 - 힙 경합(2개 이상의 thread가 동시에 접근하려 할 때 lock이 걸림)으로 인한 속도 저하 - 메모리를 직접 관리해야 함(안그러면 memory leak 발생)

 

 

4. Stack 영역

- 소스코드가 컴파일러에 의해 기계어로 변환되는 시점(컴파일 타임)에 크기가 결정됩니다.

- 함수 호출과 관련된 정보를 저장하는 데 사용됩니다.

- 함수가 호출될 때마다 해당 함수의 로컬 변수(local variables), 함수 매개변수(parameter), 반환 주소(return address)
그리고 함수 호출에 필요한 기타 정보가 스택에 저장됩니다.

- 함수가 실행을 마치면 해당 함수와 관련된 데이터가 스택에서 제거됩니다.

- 컴파일 타임에 결정되기 때문에 무한히 할당할 수 없습니다.

- 스택은 후입선출(LIFO)의 구조를 가지고 있습니다.

- 값타입(Value Type)이 저장되는 영역입니다.

- 인스턴스가 저장되는 공간

장점	- CPU가 스택 메모리를 효율적으로 구성하기 때문에 속도가 매우 빠름 - 메모리를 직접 해제 해주지 않아도 됨
단점	- 메모리 크기에 대한 제한이 있음 - 지역 변수만 액세스가 가능함

 

---

데이터의 크기를 모르거나, 스택에 저장하기에는 큰 데이터를 가지고 있다면?
힙(Heap)에 할당하면 되고,
그 외에는 스택(Stack)에 할당하면 됩니다.


스택(Stack)에 너무 많은 메모리를 할당하게 되면,
스택 오버 플로우(Stack Overflow)가 발생하게 됩니다.

---

Stack Overflow?🧐

 함수나 메서드를 사용할 때, CPU는 반환 주소(return address)를 스택(Stack)에 배치합니다.
그리고 호출이 종료되면, CPU는 반환 주소를 사용하여 다시 호출자에게 응답합니다.
그래서 끝이 없는 재귀 함수(recursive function)을 사용하면
CPU 스택의 공간이 부족해지게 되면서 발생하는 것이 바로 'Stack Overflow' 입니다.

---

 

---

 

🔥그럼 이제!🔥

이 4가지에 대해서 알아봅시다!! :)

---

1. Strong Reference(강한 참조)

기본적으로 Swift에서는 변수나 상수는 Strong Reference(강한 참조)를 합니다.

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var person1: Person? = Person(name: "Yejin") // 강한 참조
var person2 = person1 // 강한 참조

person1 = nil

위 예시처럼 person1 = nil 을 하더라도
강한 참조의 count가 증가되어 있기 때문에 객체는 메모리에 유지됩니다.

 

 

2. Circular References(순환 참조)

순환 참조는 ARC 작동 방식의 특성상
두 가지 이상의 객체가 서로에 대한 Strong Reference(강한 참조) 상태를 가지고 있을 때 발생합니다.
순환 참조가 발생하게 되면 서로에 대한 참조가 해제되지 않기 때문에 메모리에서 유지되어
Reference count가 감소하지 않습니다.
이로 인한 memory leak(메모리 릭)이 발생하게 됩니다.

class Person {
    var name: String
    var pet: Pet? // Person이 소유하는 Pet

    init(name: String) {
        self.name = name
    }
}

class Pet {
    var species: String
    var owner: Person? // Pet을 소유하는 Person

    init(species: String) {
        self.species = species
    }
}

var person: Person? = Person(name: "Yejin") // Person 클래스의 인스턴스를 생성
var pet: Pet? = Pet(species: "Cheeze") // Pet 클래스의 인스턴스를 생성

person?.pet = pet // Person 클래스의 pet에 Pet 인스턴스를 할당
pet?.owner = person // Pet 클래스의 owner에 Person 인스턴스를 할당

 

그렇다면,
두 클래스 인스턴스가 서로에 대한 참조를 유지하게 된다면 어떻게 될까요?

두 클래스 인스턴스가 서로에 대한 강한 참조를 가지고 있어서
각 인스턴스가 다른 인스턴스를 계속 유지하게 되는 경우를 'Strong Retain Cycle(강한 순환 참조)'라고 합니다.

class Person {
    let name: String
    init(name: String) {
        self.name = name
    }
    
    var car: Car?
    
    deinit {
        print("deinit Person class instance")
    }
}

class Car {
    let model: String
    init(model: String) {
        self.model = model
    }
    
    var owner: Person?
    
    deinit {
        print("deinit Car class instance")
    }
}

Person 클래스는
String 타입의 name 프로퍼티와
nil로 초기화된 옵셔널 Car? 타입의 car 프로퍼티가 있습니다.

Car 클래스에는
String 타입의 model 프로퍼티와
nil로 초기화된 옵셔널 Person? 타입의 owner 프로퍼티가 있습니다.


여기에 각 타입에 변수를 정의하고, 인스터스를 할당해봅시다.

그리고 person에 car를
car에 owner를 할당해봅시다.

var yejin: Person?
var benz: Car?

yejin = Person(name: "yejin")
benz = Car(model: "benz")

yejin!.car = benz
benz!.owner = yejin

이렇게 하면
이 두 인스턴스(yejin, benz)는 서로 강한 참조 사이클 관계를 가지게 됩니다.

reference count를 확인해보면,

yejin은
Person 인스턴스를 강한 참조 count + 1
Person 인스턴스가 Car 인스턴스에 대해 강한 참조 count + 1
(yejin - reference count: 2)

benz는
Car 인스턴스를 강한 참조 count + 1
Car 인스턴스가 Person 인스턴스에 대해 강한 참조 count + 1
(benz - reference count: 2)



이제 두 변수에 nil을 할당해 볼까요?

yejin = nil
benz = nil

yejin과 benz에 nil을 할당하여 메모리에서 해제하려고 했지만,
각각의 인스턴스가 강한 참조를 가지고 있어 메모리에서 사라지지 않습니다.

ARC는 이런 강항 순환 참조에 대한 메모리는 관리해주지 않으니 메모리 릭이 발생할 수 있습니다.

이를 해결하기 위해서
약한 참조(weak reference), 미소유 참조(unowned reference)와 같은 다른 참조 유형을 사용할 수 있습니다.

 

 

 

3. Weak Reference(약한 참조)

 

약한 참조는 강한 참조와는 다르게 객체의 참조 count를 증가시키지 않습니다.
그래서 객체의 생명 주기에 영향을 주지 않으면서 참조를 유지할 수 있습니다.

변수 혹은 속성 앞에 weak 키워드를 써서 Weak Reference임을 나타낼 수 있습니다.
참조하는 인스턴스에 대한 참조를 강하게 유지하지 않기 때문에
참조되고 있는 동안에도 해당 인스턴스가 할당 해제될 수 있습니다.

ARC는 인스턴스가 할당 해제될 때,
해당 인스턴스를 약한 참조하는 프로퍼티를 nil로 초기화 합니다.

그래서 약한 참조는 항상 옵셔널 변수에만 가능하며, 상수에는 사용이 불가능합니다.

class Car {
    let model: String
    init(model: String) {
        self.model = model
    }
    
    weak var owner: Person?
    
    deinit {
        print("deinit Car class instance")
    }
}

아까의 코드에서 Car 클래스의 owner 프로퍼티에 weak를 붙여
약한 참조로 바꿔보았습니다.


이렇게 하면,

var yejin: Person?
var benz: Car?

yejin = Person(name: "yejin")
benz = Car(model: "benz")

yejin!.car = benz
benz!.owner = yejin

Person 인스턴스는 Car 인스턴스에 대해 여전히 강한 참조를 유지하게 되고,
Car 인스턴스는 Person 인스턴스에 대해 약한 참조를 가지게 됩니다.

즉, 아까처럼 (yejin = nil)
이렇게 yejin이라는 변수를 nil로 만들어서 강한 참조를 깨게 되면,
Person 인스턴스는 더이상 강한 참조를 가지지 않게 됩니다.

그래서 Person 인스턴스에 대해 약한 참조를 가지던
owner 프로퍼티는 nil이 됩니다.

아까는 print되지 않던게 프린트가 됐습니다.😲

Car 인스턴스에 대한 강한 참조 또한 깨게 되면 마찬가지겠죠?

 

4. Unowned References(무소유 참조)

무소유 참조는 다른 인스턴스와 생명주기가 같거나 더 긴 경우에 사용합니다.

미소유 참조는 약한 참조와 유사하지만, optional 값이 아니라서 nil로 설정될 수 없습니다.
만약 참조하는 객체가 이미 메모리에서 해제된 상태로 접근하려고 한다면!
런타임 에러(runtime error)가 발생하게 됩니다.

그래서 사용 시점에 객체가 이미 해제되지 않았다고 확실할 수 있는 경우에 사용해야 합니다.
(항상 값을 가지고 있다고 가정)

변수 혹은 속성 앞에 unowned 키워드를 둬서 무소유 참조임을 나타냅니다.

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    
    deinit { print("deinit Customer Class instance") }
}

class CreditCard {
    let number: Int
    unowned let customer: Customer
    init(number: Int, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    
    deinit { print("deinit CreditCard Class instance") }
}

var fubao: Customer?
fubao = Customer(name: "fubao")
fubao!.card = CreditCard(number: 1234, customer: fubao!)

위 예시를 살펴보면,

fubao는 Customer 인스턴스에 대해 강한 참조를 가지고 있고,
CreditCard 인스턴스에 customer에 대해 무소유 참조를 가진 Customer 인스턴스가 있습니다.

여기서 fubao = nil을 하게 되면,

deinitialize 됐다고 출력됩니다.

즉, Customer에 대한 강한 참조가 해제되면서
Customer 인스턴스에 대한 강한 참조가 더이상 없으므로 할당 해제되었고,

CreditCard 인스턴스에 대한 강한 참조 또한 없어지므로
마찬가지로 할당 해제된 것입니다.

---

ARC에 관련해서 더 자세한 내용은
아래 Swift Documentation으로 Go!!

Documentation

 

수정이 필요한 부분이 있거나 틀린 내용이 있다면, 댓글로 알려주세요!!🙋🏻‍♀️
읽어주셔서 감사합니다.😆

---