[iOS/Swift] 소멸자를 사용한 메모리 해제

0. 발단

환형 링크드 리스트를 메모리에서 해제했는데, 해당 리스트 내의 노드들이 메모리에서 해제되지 않는 이슈가 발생하였다.

var myCLL: CircularLinkedList<Int>? = CircularLinkedList<Int>()
for i in 0..<2{
    myCLL!.insertAtLast(DoublyNode(data: i))
}
myCLL = nil

dealloc이 호출되지 않는다...

똑똑....메모리 누수가 일어나고 있습니다만..?

1. 상황 및 원인 파악

메모리 해제 전, 리스트에 노드를 추가할 때 오로지 메소드 insertAtLast만을 사용하였다.
따라서 해당 메소드를 호출하여 노드의 관계를 설정할 때, 리스트의 특성상 head와 tail 프로퍼티 및 입력되는 노드에 대한 참조가 빈번하므로 해당 인스턴스들에 대한 마구잡이식 접근으로 RC가 마구잡이로 쌓이는 것이 원인이라 짐작하였다.

리스트의 구현부 및 리스트에 노드를 추가할 때 사용했던 insertAtLast 함수의 구현은 다음과 같다.

class DoublyNode<T>{
    weak var prevNode: DoublyNode<T>?
    var nextNode: DoublyNode<T>?
    var data: T?
}
class CircularLinkedList<T>{
    var head: DoublyNode<T>?
    weak var tail: DoublyNode<T>?
    
    ....
    
    func insertAtLast(_ newNode: DoublyNode<T>){
        if self.head == nil {
            self.head = newNode
            self.tail = newNode
            head?.prevNode = newNode
            tail?.nextNode = newNode
            return
        }
        self.head?.prevNode = newNode
        self.tail?.nextNode = newNode
        newNode.prevNode = self.tail
        newNode.nextNode = self.head
        self.tail = newNode
    }

 

2. 문제점 찾기

노드를 1개만 추가하였을 경우에도 메모리 해제가 일어나지 않는다.
즉, head == nil 일 때에도 문제가 있음을 알 수 있다.
해당 블록을 하나씩 뜯어보면 이렇다.

1. head == nil 일 때 노드 추가 시
   1. self.head = newNode // newNode에 대한 RC 1증가, total:1
   2. self.tail = newNode 
   3. head?.prevNode = newNode 
   4. tail?.nextNode = newNode // newNode에 대한 RC 1 증가, total:2
2. 이때 myCLL = nil 을 수행 시
   1. 환형 링크드 리스트 인스턴스가 메모리에서 해제되며 제거됨
   2. 인스턴스 제거로 인한 내부 프로퍼티들이 가리키는 인스턴스의 RC가 1씩 감소
   3. 이때, head가 가리키는 노드의 RC가 1 감소 // newNode에 대한 RC total:1
   4. 상황 종료 // newNode에 대한 RC total:1, 메모리 누수 발생

1-4로 인하여 스스로에 대한 RC가 증가하였으므로, 해당 코드를 삭제한 후 head와 tail 프로퍼티를 fileprivat 처리하였다.

상기 작업을 수행하며, 스스로를 참조할 수 있는 프로퍼티는 weak로 하여 스스로에 대한 RC를 증가시키지 않도록 해야 한다는것을 알았다.
동시에, 리스트 내의 노드들은 이전 노드의 next 프로퍼티만이 유일한 참조 경로인 경우가 많으므로 next 프로퍼티는 weak로 설정할 경우에 문제가 발생할 수 있다는 점 또한 연관지을 수 있었다.
따라서 insertAtLast함수의 동작에 따라 증감하는 RC를 추적하며 수정한 코드는 다음과 같다.

    ///리스트의 마지막에 노드 추가
    func insertAtLast(_ newNode: DoublyNode<T>){
        if self.head == nil {
            self.head = newNode
            self.tail = newNode
            return
        }
        newNode.prevNode = self.tail //prevNode는 weak라 rf 증가 안한다
        newNode.nextNode = self.tail?.nextNode //rf 1 증가, newNode.nextNode = self.head시 head에 대한 rf가 증가함
        self.tail!.nextNode = newNode //새 노드의 rf 1 증가
        self.tail = newNode //tail은 weak라 rf 증가 안한다
    }

그러나... 가장 근본적인 문제는...

DoublyNode는 이전에 이중 링크드 리스트를 구현하기 위하여 사용했던 클래스이다.
이 클래스는, 마지막 노드의 next 프로퍼티는 항상 nil이여서 첫 노드의 RC를 증가시키지 않았는데
환형 링크드 리스트는 마지막 노드가 첫 노드의 RC를 증가시키고, 이로 인하여 어느 인스턴스도 해제되지 않아 RC가 정상적으로 감소하지 않고, 이로 인하여 메모리 누수가 발생한다는 것을 깨달았다.
또한, 환형 링크드 리스트 클래스는 노드를 삽입하는 함수가 3개 존재하였고, 각 함수에 대해 추가되는 로직에 따른 RC를 추적하며 최대한 리스트가 dealloc 됐을 때 그 안의 노드 모두 dealloc 할 수 있도록 정말 많은 시간을 투자하였으나 실패하였다.

나의 Strong Refence 베이비들...

 

 

3. 문제 해결

한참을 싸메다 deinit 메소드에서 노드들을 dealloc 시킬 수 있겠다는 생각이 들었고, 구현을 위해 타이핑 하던 중...

오브젝트가 dealloc 되기 전, 정리를 수행합니다.

비로소 이제서야 소멸자의 역할을 깨달았다.
툴팁을 보는 순간 도서관에서 탄성을 내지를 뻔 했다. 소멸자의 존재 이유를 깨달은 순간이었다.
컴퓨터 공학과를 졸업한 후에야 소멸자의 쓰임을 깨닫다니....! 참으로 부끄러운 일이다.

class CircularLinkedList<T>{
    fileprivate var head: DoublyNode<T>?
    fileprivate weak var tail: DoublyNode<T>?
    deinit {
        var currentNode = self.head
        while(currentNode != nil){
            currentNode?.nextNode = nil
            currentNode = currentNode?.prevNode
        }
    }
    ...
}

예상한 대로, 노드들이 정상적으로 dealloc 되었다.

 

4. 후기

myCLL = nil 일 때, 소멸자를 사용하지 않고서도 모든 노드들이 단번에 dealloc 되도록 하지 못한것에 큰 아쉬움이 남는다.
만약, 이 클래스로 구현된 자료구조가 1천만명의 데이터에 대해 관리하는 코드였다면..? 서버컴퓨터를 정말 많이 재부팅했어야겠지...

취업을 준비하며, Swift를 기초부터 다시 다지는 과정에서 그동안 신경쓰지 않았던 부분들도 습득하려 힘쓰고 있다.
그동안 지나쳤던 것들에 대한 중요성을 깊이 깨닫는다. 역시 기초는 쉬운게 아니라 중요한 것이다.
앞으로 공부할 것과 경험할 것들에 기대감이 생긴다!