Kotlin / Native multithreading sử dụng coroutines

Tôi đã có một cảnh quay ở kotlin multiplatform và nó rất tuyệt vời, nhưng việc phân luồng khiến tôi khó chịu. Việc đóng băng trạng thái giữa các luồng có ý nghĩa về mặt khái niệm và hoạt động tốt trong các ví dụ đơn giản khi các đối tượng nhỏ hoặc nguyên thủy được truyền qua lại, nhưng trong các ứng dụng thế giới thực, tôi không thể vượt qua được InvalidMutabilityException.

Lấy đoạn mã phổ biến sau đây từ ứng dụng android

class MainViewModel(
    private val objectWhichContainsNetworking: ObjectWhichContainsNetworking
)

    private var coreroutineSupervisor = SupervisorJob()
    private var coroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main + coreroutineSupervisor)

    private fun loadResults() {
        // Here: Show loading
        coroutineScope.launch {
            try {
                val result = withContext(Dispatchers.Default) { objectWhichContainsNetworking.fetchData() }
                // Here: Hide loading and show results
            } catch (e: Exception) {
                // Here: Hide loading and show error
            }
    }
}

Không có gì phức tạp lắm, nhưng nếu được sử dụng trong mã phổ biến và chạy từ Kotlin / Native thì pow InvalidMutabilityException trên MainViewModel.

Có vẻ như lý do cho điều này là bất cứ thứ gì được truyền vào withContext đều bị đóng băng đệ quy vì objectWhichContainsNetworking là một thuộc tính của MainViewModel và được sử dụng trong withContext thì MainViewModel sẽ bị đóng băng.

Vì vậy, câu hỏi của tôi là, đây chỉ là một hạn chế của mô hình bộ nhớ Kotlin / Native hiện tại? Hoặc có lẽ là phiên bản hiện tại của coroutines? Và có cách nào làm tròn điều này không?

Lưu ý: phiên bản coroutines: 1.3.9-native-mt. kotlin phiên bản 1.4.0.

Chỉnh sửa 1: Có vẻ như đoạn mã thu gọn ở trên thực sự hoạt động tốt. Hóa ra mã buộc tội là một var có thể cập nhật trong mô hình chế độ xem (được sử dụng để giữ một tham chiếu đến trạng thái chế độ xem cuối cùng) bị đóng băng và sau đó ném ngoại lệ khi nó cố gắng bị thay đổi. Tôi sẽ cố gắng sử dụng Dòng / Kênh để đảm bảo không cần tham chiếu var và xem liệu điều này có khắc phục được sự cố tổng thể hay không.

Lưu ý: nếu có cách nào đó để tránh việc MainViewModel bị đóng băng ngay từ đầu thì sẽ rất tuyệt vời!

Chỉnh sửa 2: Đã thay thế var bằng Flow. Tôi không thể thu thập quy trình chuẩn trong iOS cho đến khi sử dụng trình trợ giúp tại đây:https://github.com/JetBrains/kotlinconf-app/blob/master/common/src/mobileMain/kotlin/org/jetbrains/kotlinconf/FlowUtils.kt.

MainViewModel vẫn bị đóng băng, nhưng vì tất cả trạng thái của nó là không thay đổi nên không còn là vấn đề nữa. Hy vọng nó sẽ giúp một ai đó!

Trong mã gốc của bạn, bạn đang tham chiếu đến một trường của đối tượng mẹ, điều này khiến bạn nắm bắt toàn bộ đối tượng gốc và đóng băng nó. Nó không phải là một vấn đề với coroutines. Coroutines tuân theo các quy tắc tương tự như tất cả các thư viện đồng thời khác trong Kotlin / Native. Nó đóng băng lambda khi bạn vượt qua các chủ đề.

class MainViewModel(
    private val objectWhichContainsNetworking: ObjectWhichContainsNetworking
)

//yada yada
    private fun loadResults() {

        coroutineScope.launch {
            try {

                val result = withContext(Dispatchers.Default) {

                    //The reference to objectWhichContainsNetworking is a field ref and captures the whole view model
                    objectWhichContainsNetworking.fetchData() 

            }

        } catch (e: Exception) {}
    }
}

Để ngăn điều này xảy ra:

class MainViewModel(
    private val objectWhichContainsNetworking: ObjectWhichContainsNetworking
){
    init{
        ensureNeverFrozen()
    }
    //Etc

Điều phức tạp nhất với mô hình bộ nhớ là điều này. Làm quen với những gì được nắm bắt và tránh nó. Không quá khó khi bạn làm quen nhưng bạn cần học những điều cơ bản.

Tôi đã nói nhiều về điều này:

Kotlin thực tế / Đồng tiền bản địa

Kotlin Native Concurrency bắt tay

KotlinConf KN Concurrency

Mô hình bộ nhớ đang thay đổi, nhưng sẽ khá lâu trước khi nó hạ cánh. Khi bạn đã quen với mô hình bộ nhớ, các vấn đề bất biến thường dễ dàng chẩn đoán.