[Swift] ARC (2); 메모리 누수, Retain Cycle

저번 글에서는 ARC의 개념에 대해 알아봤는데,

오늘은 ARC가 제대로 작동할 수 없게 되는 이유에 대해서 공부하고

그로 인해 메모리 누수가 발생할 수 있는 상황을 정리해보려고한다.

 

메모리 누수는 프로그램이 필요하지 않은 메모리를 계속 점유하고 있는 현상이다.

iOS앱에 메모리 누수가 쌓이게되면 메모리 사용량이 증가하고, 결국엔 앱을 죽일 수 있다.

 

우선 메모리 누수가 발생할 수 있는 원인에 대해 살펴보자.

📎 메모리 누수 발생 원인 - Retain Cycle (강한참조 순환)

저번 글에서 말했듯 swift의 메모리 관리는 ARC가 자동으로 수행해주고,

ARC는 참조 카운트를 통해 메모리를 적절한 때에 해제시켜준다.

 

참조의 종류는 여러가지가 있는데,

우리가 클래스 타입의 프로퍼티나 변수, 상수 등을 선언할 때

별도의 식별자를 명시하지 않으면 기본으로 '강한참조'를 하게 된다.

(지금까지 인스턴스를 생성할 때 var tmp = ~~ 이렇게 선언했던 것들 모두 강한참조였던것,,)

 

그런데 복합적으로 참조가 일어나는 상황에서, 강한 참조를 잘못 사용하면 메모리 누수 문제가 발생할 수 있다.

인스턴스끼리 서로가 서로를 강한 참조할 때가 대표적!!!💥

이 문제를 바로 Retain Cycle, 강한참조 순환이라고 한다.

 

아래에 Retain Cycle이 일어나는 대표적인 사례를 작성했다.

class Example_A {
    var A: Example_B?
    init() {
        print("being initialized")
    }
    deinit {
        print("being deinitialized")
    }
}

class Example_B {
    var B: Example_A?
    init() {
        print("being initialized")
    }
    deinit {
        print("being deinitialized")
    }
}

var test1: Example_A? = Example_A() // Example_A 참조 횟수 : 1 (Prints "being initialized")
var test2: Example_B? = Example_B() // Example_B 참조 횟수 : 1 (Prints "being initialized")

test1?.A = test2 // Example_B 참조 횟수 : 2
test2?.B = test1 // Example_A 참조 횟수 : 2

test1 = nil // Example_A 참조 횟수 : 1
test2 = nil // Example_B 참조 횟수 : 1

Example_A, Example_B 클래스를 생성했고, 각 클래스를 참조하는 test1, test2 변수를 정의했다.

 

처음 참조를 정의했을 때 being initialized가 정상적으로 출력됨을 확인할 수 있고,

이 때 Example_A와 Example_B 인스턴스의 참조 횟수는 1씩 증가된다.

 

그리고 추가로, 두 변수의 각각 참조하는 클래스의 프로퍼티가 서로의 참조 클래스를 참조하도록 했다.

이 때 두 클래스의 인스턴스 참조 횟수는 또다시 1씩 증가하게 된다.

 

이렇게 참조 횟수를 증가시켜주는 것까지에는 문제가 없다.

이제 참조 횟수를 하나씩 감소시켜보자.

 

test1 변수에 nil을 할당하면 test1이 참조하는 인스턴스인 Example_A의 참조 횟수는 1 감소한다.

👉 메모리 해제를 위해서는 참조 횟수를 0까지 감소시켜줘야 하는데,

이렇게 되면 test1 변수를 통해 Example_A의 인스턴스 참조 횟수를 감소시키는 것은 불가능해진다.

하지만 우리는 test2가 참조하는 인스턴스의 B 프로퍼티로 Example_A를 참조해놨으므로..!!!

이 경로를 통해 Example_A의 참조 횟수를 줄여 메모리를 해제시킬 수 있다. 따라서 아직은 문제 없음.!

 

하지만 여기서 test2에도 nil을 할당해버리면 이 때 문제가 발생한다.❗️

1) 유일하게 Example_A 클래스의 인스턴스에 접근할 수 있는 경로가 사라짐
2) nil 할당으로 Example_B 인스턴스 참조 횟수 1이 감소되지만, 더이상 감소시킬 수 있는 경로는 없음

 

따라서 Example_A, Example_B 인스턴스 모두 참조 횟수가 1인채로

새로운 참조 횟수의 감소가 불가능하게 되었으므로, 메모리를 해제할 방법이 사라지게된다.

👉 인스턴스가 참조 횟수를 남겨둔 채로 메모리에 좀비처럼 남아있게 됨. 메모리 누수!!!

 

이 문제를 해결하기 위해서는 물론 우리가 좀 더 신경을 써서..!

아래와같은 방식으로 경로를 막지 않게, 순차적으로 nil을 할당해주면 가능은하다.

test1?.A = nil
test1 = nil

test2?.B = nil
test2 = nil

 

하지만 이렇게 하면 실수할 가능성도 커지고, 프로퍼티가 너무 많아질 경우엔 해결하기 어려울것이다.

그렇다면 이제 이 문제를 좀 더 효과적으로 해결할 수 있는 방법을 찾아봐야겠지,.!

---

📎 Retain Cycle 해결 (1) - Weak Reference (약한참조)

약한참조는 강한참조와 달리, 참조하는 인스턴스의 참조 횟수를 증가시키지 않는다.

이 약한참조는 어떻게 쓰는건지, 어떻게 동작하는지 코드로 확인해보자.

class Example_A {
    var A: Example_B?
    init() {
        print("being initialized")
    }
    deinit {
        print("being deinitialized")
    }
}

class Example_B {
    weak var B: Example_A?
    init() {
        print("being initialized")
    }
    deinit {
        print("being deinitialized")
    }
}

var test1: Example_A? = Example_A() // Example_A 참조 횟수 : 1 (Prints "being initialized")
var test2: Example_B? = Example_B() // Example_B 참조 횟수 : 1 (Prints "being initialized")

test1?.A = test2 // Example_B 참조 횟수 : 2
test2?.B = test1 // Example_A 참조 횟수 : 1

test1 = nil // Example_A 참조 횟수 : 0, Example_B 참조 횟수 : 1 (Prints "being deinitialized")
print(test2?.B) // Prints "nil"
test2 = nil // Example_B 참조 횟수 : 0 (Prints "being deinitialized")

위에서 강한참조로 인한 Retain Cycle 예제와 동일하게 클래스를 선언하고 참조했다.

test1, test2로 클래스를 참조한 부분까지는 위의 예제와 같은데, 그 아래부터는 조금씩 결과가 달라진다.

 

test2?.B에 test1을 할당했을 때의 주석을 보면, Example_A의 참조 횟수는 증가되지 않는다.

그 이유는 test2가 참조하는 Example_B의 프로퍼티 B를

weak 키워드를 이용하여 Example_A를 약한참조하게 했기 때문이다.

위에서 말했듯 약한참조를 하게되면 참조하는 인스턴스의 참조횟수를 증가시키지 않는다.💥

 

그리고 마지막에 각 변수에 nil을 할당하며 인스턴스 해제를 시작하는데,

test1에 nil을 할당한 부분을 확인하면 Example_A와 Example_B의 참조 횟수 모두 감소한 것을 볼 수 있다.

Q) Example_A를 참조하는 test1에만 nil을 할당했을 뿐인데 왜 Example_B까지 참조 횟수가 감소했을까?

그 이유는 어떻게 생각해보면 되게 당연한데,

Example_A 인스턴스가 메모리에서 해제되면 자연스레 Example_A의 프로퍼티인 A 또한 역할이 끝나게 되고,
A는 Example_B를 더이상 강한참조하지 않게 된다. 따라서 Example_B의 참조 횟수까지 감소되는것❗️

👉정리하자면, 어떤 인스턴스가 메모리에서 해제되면 그와 동시에

그 인스턴스의 프로퍼티가 강한참조하는 인스턴스의 참조 횟수까지 1 감소하게된다.

 

추가로, 이 때 우리가 발견할 수 있는 약한참조의 특징이 하나 있다.

이 부분의 코드를 보면 test2?.B의 값이 nil이라는 것을 확인할 수 있는데, 그 이유는

Example_A 인스턴스가 메모리에서 해제됨으로 인해 프로퍼티 B는 참조하는 대상이 사라지게 되었고,

B는 약한참조를 하므로 참조하는 인스턴스가 메모리에서 해제되었으니 자동으로 nil을 할당한 것이다.

+ 그리고 여기서 또 알 수 있는 점은,

약한참조를 하면 위와같이 내가 모르는 사이 참조하고있는 인스턴스가 해제되어있을 수 있고,
그 경우에는 자동으로 nil이 할당될 수 있으므로 해당 프로퍼티는 'nil'로 '변할'수 있어야한다.

따라서 약한참조를 하는 프로퍼티의 경우 꼭 옵셔널 변수로 선언되어야한다.💥

👉정리! 약한참조를 하는 프로퍼티는 자신이 참조하는 인스턴스가 메모리에서 해제되면

자동으로 nil을 할당하며, 꼭 옵셔널 변수로 선언해야한다.

 

이렇게 약한참조를 이용하여 코드를 작성함으로 인해 강한참조 순환 문제를 해결할 수 있다.

하지만 방법이 약한참조 하나만 있는것은 아님!

---

📎 Retain Cycle 해결 (2) - Unowned Reference (미소유참조)

미소유참조또한 약한참조처럼 참조 횟수를 증가시키지 않는 참조 방법이다.

이 둘의 가장 큰 차이점은,

미소유참조의 경우 내가 참조하는 인스턴스가 꼭 메모리에 존재할 것이라는 전제를 기반으로 한다는 것이다.

 

말로는 너무 어려우니,, 코드로 확인해보자!

import Foundation

class Person {
    let name: String
    var car: Car? // 사람은 차를 가지지 않아도 됨 => 강한 참조, 옵셔널로 선언
    
    init(name: String) {
        self.name = name
        print("\(name) being initialized")
    }
    
    deinit {
        print("\(name) being deinitialized")
    }
}

class Car {
    let name: String
    unowned var owner: Person // 차는 꼭 주인이 있어야 함 => 미소유 참조로 선언
    
    init(name: String, owner: Person) {
        self.name = name
        self.owner = owner
        print("\(name) being initialized")
    }
    
    deinit {
        print("\(name) being deinitialized")
    }
}

var seolhee: Person? = Person(name: "seolhee") // Person 인스턴스 참조 횟수 : 1 (Prints "seolhee being initialized")

if let person: Person = seolhee {
    person.car = Car(name: "tivoli", owner: person) // Car 인스턴스 참조 횟수 : 1 (Prints "tivoli being initialized")
    // Person 인스턴스 참조 횟수 : 1
}

seolhee = nil // Person 인스턴스 참조 횟수 : 0, Car 인스턴스 참조 횟수 : 0 (Prints "seolhee being deinitialized", "tivoli being deinitialized")

이 미소유참조는 이름처럼 '소유'의 관계를 생각하면 편하다.

나는 차와 그 차주의 관계를 예시로 코드를 작성했는데, 사람은 차가 없을 수 있지만 차는 사람이 꼭 필요하다.

따라서 Car 인스턴스를 사용하기 위해서는 Person 인스턴스가 꼭 메모리에 존재해야만 한다.!!

 

위의 이야기를 바탕으로 코드를 살펴보자. 먼저 클래스 구현부!

(1) Person 클래스의 car 프로퍼티는 Car 클래스를 강한참조하며 옵셔널로 선언했다.

사람은 차를 가질수도, 가지지 않을 수도 있으므로 옵셔널로 정의했으며

차를 한 번 가진 후에는 함부로 잃어버리면 안되므로 강한참조를 하도록 했다.

(2) Car 클래스의 owner 프로퍼티는 unowned 키워드를 이용해 미소유참조했다.

차는 소유주가 꼭 있어야 존재할 수 있으므로 옵셔널로 정의하지 않았고,

차가 있는 한 당연히 소유주도 존재한다는 확신이 있으므로 미소유참조하게 했다.

 

클래스 구현 후 가장 먼저 Person을 참조하는 seolhee를 정의했고, Person 인스턴스의 참조 횟수는 1 증가한다.

 

그리고 if let 구문을 사용하여 Person 인스턴스가 존재하면! Car인스턴스를 생성할 수 있도록 작성해주었다.

(Person 인스턴스가 메모리에 올라가 있어야만 Car인스턴스 또한 사용이 가능하기 때문!💥)

이 때 Car 인스턴스의 참조 횟수는 1 증가하고, 메모리에 올라가게된다.

하지만 이 때 주목해야 할 점은, Car의 owner프로퍼티가 Person인스턴스를 참조하게되었지만

미소유참조했으므로 Person 인스턴스의 참조 횟수는 증가하지 않는다는 것이다. 약한참조와의 공통점!

 

마지막으로는 seolhee 변수에 다시 nil을 할당해주었다.

이 때 당연히 Person 인스턴스는 참조 횟수가 1 감소하면서 메모리에서 해제되고

Car 인스턴스의 경우 약한참조 부분에서 공부한대로, Person 인스턴스가 해제됨에 따라

Person의 프로퍼티 car가 강한참조하는 Car 인스턴스 또한 참조 횟수가 1 감소하게 된다.

따라서 Car까지 모두 메모리 해제 완료!

 

이렇게 미소유참조를 이용하면

예제처럼 사람이 없어지면 차도 없어져야 하는 이런 상황을 쉽게 표현할 수 있고

강한참조 순환 문제도 피해갈 수 있게된다.❗️

---

🌟 정리

Retain Cycle은 강한참조로 인해 발생할 수 있는 문제로,

이로 인해 메모리 누수가 발생할 수 있고 앱에 치명적인 영향을 끼칠 수 있다.

강한참조 순환 문제는 약한참조나 미소유참조를 이용하여 해결이가능한데,

참조를 하면 무조건 참조 횟수가 1 증가되는 강한 참조의 문제를 개선했기 때문이다.

 

약한참조와 미소유참조는 모두 참조 횟수를 증가시키지않으며,

약한참조는 내가 참조하는 인스턴스가 메모리에서 해제되었을 경우

자동으로 nil을 할당해주기 때문에 무조건 옵셔널 변수로 선언해야하고,

미소유참조는 내가 참조하는 인스턴스가 무조건 메모리에 존재할것이라는 전제 하에 사용하는 참조이므로

옵셔널 변수로 선언하지 않아도 된다.

 

---

참고

• 📖 스위프트 프로그래밍