RxSwift – DisposeBag

subscription.dispose()

Lúc này, kết nối của subscription sẽ chấm dứt và Observable sẽ dừng phát.  Và hoà bình sẽ trở lại với thế giới!

Observable<String>.of("A", "B", "C", "D", "E", "F")
        .subscribe { event in
            print(event)
        }

Nếu như bạn tạo ra 1 subscription để quản lý các đăng ký. Thì mọi thứ đơn giản rồi. Tuy nhiên vẫn là câu nói cũ Đời không như là mơ. Thường trong code Rx thì:

• Các đối tượng subscriber hầu như không tồn tại hoặc không tạo ra.
• Các subscription sẽ được tạo ra nhằm giữ kết nối. Nó sẽ phục vụ cho tới khi nào class chứa nó bị giải phóng.
• Có quá nhiều subscription trong một class.
• Nhiều trường hợp muốn subscribe nhanh tới 1 Observable nên các subscription sẽ không tạo ra.

Không giải quyết riêng lẻ được thì gom lại mà xử lý thằng cầm đầu.

Vậy là, vấn đề bộ nhớ vẫn nhức nhói. Do đó, người ta sinh ra khái niệm mới DisposeBag (túi rác quốc dân). Bạn xem tiếp code ví dụ trên với việc thêm DisposeBag vào.

    let bag = DisposeBag()
    
    Observable<String>.of("A", "B", "C", "D", "E", "F")
        .subscribe { event in
            print(event)
        }
        .disposed(by: bag)

Lúc này, bạn không cần bận tâm lắm về Observable mình tự do làm càng. Tất cả sẽ được disposeBag quản lý và thủ tiêu.

Áp dụng vào trong project, khi bạn khai báo 1 disposeBag là biến toàn cục. Khi đó, bạn chỉ cần ném tất cả các subscription hoặc các Observable vào đó. Và yên tâm về vấn đề bộ nhớ sẽ không bị ảnh hưởng.

Tất nhiên, nếu bạn quên việc thêm dispose() hay disposeBag thì trình biên dịch sẽ nhắn lời yêu thương cho bạn biết.

4. Dispose vs. DisposeBag

Hai thằng Dispose và DisposeBag có gì khác nhau. Vì tất cả cũng đều phục vụ cho việc giải phóng subscription. Để hiểu hơn thì bạn phải đưa vào bài toán thực tế.

Ví dụ, ta có 1 ViewController với nhiều subscription. Công việc giờ quản lý và tránh đi retain-cycle khi các biến trong class ViewController không được tự động giải phóng.

4.1. Sử dụng Dispose

• Với 1 subscription đơn lẻ

final class ViewController: UIViewController {
    var subscription: Disposable?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        subscription = theObservable().subscribe(onNext: {
            // handle subscription
        })
    }
    
    deinit {
        subscription?.dispose()
    }
}

• Với nhiều subscription

final class ViewController: UIViewController {
    var subscriptions = [Disposable]()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        subscriptions.append(theObservable().subscribe(onNext: {
            // handle subscription
        }))
    }
    
    deinit {
        subscriptions.forEach { $0.dispose() }
    }
}

Bạn hãy chú ý tới function deinit. Nó là nơi các subscription gọi việc tự huỷ .dispose().

4.2. Sử dụng DisposeBag

final class ViewController: UIViewController {
    let disposeBag = DisposeBag()

    override func viewDidLoad() {
        super.viewDidLoad()
        theObservable().subscribe(onNext: {
                // handle subscription
        })
        .disposed(by: disposeBag)
    }
}

Vậy thì function deinit đã đi đâu?

Một điều tuyệt vời của DisposeBag, là nó sẽ chịu trách nhiệm cho việc gọi dispose trên mỗi Disposable bên trong nó. Việc này sẽ được gọi khi bản thân DisposeBag bị deinit.

4.3. Retain cycle

Khi bạn đã cài đặt đầy đủ DisposeBag rồi, nhưng nguy cơ retain-cycle vẫn còn. Nhất là với với thao tác bất đồng bộ.

Ví dụ, bạn gọi kết nối tới 1 API. Lúc này, bạn phải chờ response trả về. Nhưng thời gian chờ quá lâu, bạn thoát khỏi màn hình đó. Và sau đó, response về. Đây là lúc nhiều câu chuyện bắt đầu

• Về mặt quản lý biến và đối tượng thì chúng bằng nil khi chúng ta thoát khỏi màn hình đó.
• Tuy nhiên vì để chờ response thì đâu đó, ta cần phải sử dụng chính đối tượng self để xử lý & update UI. Việc này tạo ra sự tham chiếu tới self.

Mà cái closure handle response đó lại được lưu trữ trong 1 Subscription. Và subscription đó lại ở trong 1 DisposeBag. DisposeBag lại ở trong ViewController.

Khi thoát khỏi màn hình,  hàm deinit sẽ chạy, nhưng chúng sẽ không deinit được vì trong closure trên vẫn còn được trỏ tới.

Mô tả code như sau:

final class MyViewController: UIViewController {
    private let disposeBag = DisposeBag()
    private let parser = MyModelParser()

    override func viewDidLoad() {
        super.viewDidLoad()
        
        let parsedObject = theObservable
            .map { json in
                return self.parser.parse(json)
            }
            
        parsedObject.subscribe(onNext:{ _ in 
            //do something
        })
        .disposed(by: disposeBag)
    }
}

4.4. weak self

Cách để giải quyết nó là bạn hãy nhớ về [weak self]. Bạn hãy xem đoạn code

let parsedObject = theObservable
    .map { [weak self] json in
        return self?.parser.parse(json) //compile-time error. What should be returned if `self` is nil?
    }

Tuy nhiên, nếu sử dụng [weak self], ta cần báo cho compiler phải trả về giá trị gì nếu self bị nil. Trong trường hợp này, cách tốt nhất là truyền parser trong capture list thay vì dùng self:

let parsedObject = theObservable
    .map { [parser] json in
        return parser.parse(json)
    }

Swift cho phép ta truyền một biến vào capture list mà không cần bất cứ thuộc tính nào như weak hoặc unowned. Nếu làm như thế, compiler sẽ biết phải giữ reference cho duy nhất parse (với strong reference), chứ không phải cho self.

Một cách nữa là sử dụng [unowned self] thay cho [weak self].

Observable<String>.create { observer -> Disposable in
        observer.onNext("1")
        
        observer.onNext("2")
        
        observer.onNext("3")
        
        observer.onNext("4")
        
        observer.onNext("5")
        
        observer.onCompleted()
        
        observer.onNext("6")
        
        return Disposables.create()
    }

Bạn sẽ thấy trong closure đó, chúng ta tuỳ ý phát ra các dữ liệu. Quan trọng là return về Disposables , để có thể kết thúc việc đăng ký từ bên ngoài. Và nó cũng là đại diện cho mỗi lần đăng ký tới Observable.

5.3. Subscribe

Bạn khai báo thêm 1 túi rác quốc dân nữa.

let bag = DisposeBag()

Tiếp theo là .subscribe tới Observable nào

.subscribe(
        onNext: { print($0) },
        onError: { print($0) },
        onCompleted: { print("Completed") },
        onDisposed: { print("Disposed") }
        )
    .disposed(by: bag)

1
2
3
4
5
Completed
Disposed

enum MyError: Error {
  case anError
}

observer.onError(MyError.anError)

1
2
3
4
anError
Disposed

disposed(by: bag)
observer.onError(MyError.anError)
observer.onCompleted()
enum MyError: Error {
      case anError
    }
    
    let bag = DisposeBag()
    
    Observable<String>.create { observer -> Disposable in
        observer.onNext("1")
        
        observer.onNext("2")
        
        observer.onNext("3")
        
        observer.onNext("4")
        
        //observer.onError(MyError.anError)
        
        observer.onNext("5")
        
        //observer.onCompleted()
        
        observer.onNext("6")
        
        return Disposables.create()
    }
    .subscribe(
        onNext: { print($0) },
        onError: { print($0) },
        onCompleted: { print("Completed") },
        onDisposed: { print("Disposed") }
        )
    //.disposed(by: bag)

1
2
3
4
5
6