Swift: weak and unowned

Automatic Reference Counting aka ARC, là 1 tính năng của Swift dùng để đếm số lượng strong reference, và cho phép quản lý việc giải phóng memory khi 1 instance không còn được reference(tham chiếu) đến.

Theo như doc của Apple:

Ví dụ : 

class FirstClass: UIViewController {

    let secondClass = SecondClass()

}

class SecondClass {

}

Trong ví dụ này, class FirstViewController của mình đang strong reference đến instance secondClass

Như mình đã đề cập bên trên, ARC sẽ giúp chúng ta quản lý, phân bổ memory từ những instance không còn được tham chiếu đến.

Tuy nhiên, câu hỏi đặt ra là điều gì sẽ xảy ra khi có 2 object/instance strong reference đến nhau?

Từ strong việt hóa ra là mạnh, bền, … nghe thôi cũng cảm giác khó phá hỏng, phá hủy nó rồi đúng không? :)))

Thì strong reference cũng thế, strong reference trỏ đến 1 instance/object và sở hữu nó, quyết định đến sự tồn tại của instance/object đó. 

ARC không thể có cách nào giải phóng được memory từ những kiểu instace/object này, và điều này sẽ dẫn đến memory leak.

Trong thực tế những project đã làm, thì mình rất hay thường gặp những case strong reference, và mình cũng rất hay vô tình tạo ra strong reference :v 

Case mình hay gặp nhất là case khi khởi tạo delegate:

protocol DemoDelegate {
    func demoFunc()
}

class FirstClass {
    var delegate: DemoDelegate?
}

Trông ví dụ này có vẻ quen đúng không? :))) ở đây mình có 1 protocol DemoDelegate, và khởi tạo delegate này trong FirstClass. Và FirstClass và delegate DemoDelegate đang strong reference đến nhau.

Để giải quyết vấn đề này, chúng ta có weak và unowned.

Trái ngược với strong pointer, weak pointer trỏ đến một instance/object và không quyết định đến sự tồn tại của instance/object đó.

Vì thế nên ARC có thể dễ dàng giải phóng bộ nhớ từ instance/object này kể cả chúng ta vẫn còn đang tham chiếu đến nó 

=> Weak reference rất hữu ich, giúp chúng ra tránh được việc vô tình hay cố ý tạo ra 1 strong reference cycle.

Việc sử dụng weak reference thực sự quan trọng, ví dụ nếu chúng ta để ý hơn và xem source code bên trong definition của UITableView, ta có thể nhận thấy rằng tất cả delegate(bao gồm 2 var quen thuộc là dataSource và delegate) đều được sử dụng với weak khi khởi tạo.

Và mình nghĩ là đến apple còn để ý và chú trọng đến việc sử dụng weak, tại sao chúng ta lại không làm như thế ? :v

protocol DemoDelegate {
    func demoFunc()
}

class FirstClass {
    weak var delegate: DemoDelegate?
}

Ok, thêm weak là xong, đơn giản phải không nào.

Tuy nhiên, khi thêm weak, lại nảy sinh vấn đề không thể compile đoạn code:

Để giải quyết, theo doc Protocols của apple:

Để fix, chỉ cần thêm keyword class là được

protocol DemoDelegate: class {
    func demoFunc()
}

class FirstClass {
    weak var delegate: DemoDelegate?
}

Một variable kiểu unownevề cơ bản giống với variable kiểu weak, nhưng khác nhau ở chỗ: compiler sẽ make sure rằng variable này khi được gọi đến sẽ không có giá trị nil.

Vậy thực sự trong trường hợp nào nên sử dụng unowned thay vì sử dụng weak ? Vẫn theo doc của Apple: 

Để hiểu rõ hơn, mình có 2 ví dụ như này

Ví dụ của weak reference: mình sở hữu 1 chiếc xe đạp, nhưng 1 hôm đẹp trời nào đó, mình đổi ý không muốn đạp xe nữa, thì ở đây chiếc xe đạp vẫn còn đó, có chăng chỉ là đổi chủ, trong khi mình đang ngồi 1 chiếc 4 bánh nào đó :v 

Ví dụ của unowned reference: mình chơi 1 yasuo chẳng hạn :))), thằng nhân vật của mình tăng skill theo cấp độ. Tuy nhiên, khi xám màn hình, những skill đó cũng sẽ xám theo. Có nghĩa rằng là những skill này có tuổi thọ = tuổi thọ của nhân vật mình đang chơi.

Triển khai trong code:

class Yasuo {

    let name: String
    let skill: Skill?

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

}

class Skill {

    let damage: Int
    unowned let champ: Yasuo

    init(damage: Int, champ: Yasuo) {
        self.damage= power
        self.champ = champ
    }

}

Vậy là chúng ta đã hiểu phần nào về 2 keyword weak và unowned. Chúng dùng để tránh tình trạng vô tình tạo ra memory leak. 

Nhưng sao để biết được có thực sự tránh được hay không?

Cách đơn giản và xưa như quả đất, là sử dụng print trong 2 method init và deinit

class FirstClass {

    init() {
        print("FirstClass is being initialized")
    }

    deinit { 
        print("FirstClass is being deinitialized") 
    }

}

Và để ý memory trong XCode nữa :v

Strong, weak, unowned là những thuật ngữ cơ bản trong swift, tuy nhiên chúng ta thường – do vô ý hoặc chủ quan – bỏ qua chúng.

Điều này không thực sự ảnh hưởng quá lớn với những project nhỏ. 

Tuy nhiên với những app lớn, việc quản lý bộ nhớ ra sao cho hiệu quả là 1 việc quan trọng và đáng lưu ý, bởi vì khi memory leak trở thành 1 vấn đề nghiêm trọng, thì rất khó và tốn effort để fix. 😀

REFERENCE

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

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