Complete Concurrency với Swift 6

Chào mừng bạn đến với Fx Studio. Swift 6 là một bản nâng cấp với nhiều cải tiến lớn cho Concurrency. Giúp cho các đoạn mã về xử lý đồng thời đơn giản và hiệu quả hơn. Điều quan trọng chính là các tính năng về Concurrency trong Swift 6.

Được sử dụng mặc định.

class Counter {
    private var value = 0
    private let queue = DispatchQueue(label: "counterQueue", attributes: .concurrent)

    func increment() {
        queue.async(flags: .barrier) {
            self.value += 1
        }
    }

    func getValue(completion: @escaping (Int) -> Void) {
        queue.async {
            completion(self.value)
        }
    }
}

let counter = Counter()

let group = DispatchGroup()

for _ in 0..<1000 {
    group.enter()
    DispatchQueue.global().async {
        counter.increment()
        group.leave()
    }
}

group.notify(queue: .main) {
    counter.getValue { value in
        print("Final counter value: \(value)")
    }
}

Trong ví dụ này, sử dụng DispatchQueue và các cờ .barrier để quản lý việc truy cập đồng thời vào biến value.

Sau Swift 6

Với Swift 6, tính năng Isolation Regions giúp đơn giản hóa việc quản lý truy cập đồng thời thông qua các actors và các cơ chế cô lập khác. Đảm bảo rằng chỉ các nhiệm vụ được ủy quyền mới có thể truy cập và thay đổi dữ liệu.

actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

let counter = Counter()

Task {
    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<1000 {
            group.addTask {
                await counter.increment()
            }
        }
    }

    let finalValue = await counter.getValue()
    print("Final counter value: \(finalValue)")
}

Trong ví dụ này,

• Counter được định nghĩa là một actor.
• Đảm bảo rằng các phương thức increment và getValue được thực thi một cách an toàn mà không cần sử dụng khóa thủ công.

Đây cũng là phần “Region based Isolate” được đề cập tới trong Swift 6. (Nếu có điều kiện thì mình sẽ có một bài viết chi tiết hơn.)

Sendable

Cốt lõi ở đây nằm ở sự thay đổi về Sendability hay Sendable Type trong Swift 6.

Sendable là một giao thức được giới thiệu để chỉ định rằng một loại có thể an toàn khi được chuyển giao giữa các nhiệm vụ đồng thời. Một loại (type) tuân thủ Sendable đảm bảo rằng dữ liệu của nó không thể bị thay đổi không an toàn khi truyền qua các ranh giới của các nhiệm vụ đồng thời.

Ta có thể lấy 1 đoạn ví dụ sau:

class User {
    var name = "Anonymous"
}

struct ContentView: View {
    var body: some View {
        Text("Hello, world!")
            .task {
                let user = User()
                await loadData(for: user)
            }
    }

    func loadData(for user: User) async {
        print("Loading data for \(user.name)…")
    }
}

Với:

• Trước Swift 6: bạn sẽ nhận được thông báo lỗi: “passing argument of non-sendable type ‘User’ outside of main actor-isolated context may introduce data races.“
• Sau Swift 6: chúng ta không nhận được thông báo nào hết

Điều này có nghĩa:

• Các đối tượng (sendable & non-sendable) đều có thể gửi đi được, mà không nhất thiết phải tuân thủ Sendable Protocol
• Swift 6 trở nên an toàn hơn với Concurrency

Thể hiện tính đơn giản hóa dành cho các lập trình viên, do việc trình biên dịch đã thông minh hơn rồi.

Ngoài ra có các tính năng bổ sung thêm trong các bản cập nhật tiếp theo của Swift 6:

• Thêm từ khóa sending
• Tương thích với Objective-C
• Nâng cấp các hàm async kế thừa các actor isolation (dịch đại thôi)

Loại bỏ @MainActor cho Property Wrappers

Trong Swift 5.5, một tính năng gọi là suy luận actor cho property wrappers đã được giới thiệu. Tính năng này được thiết kế để giúp quản lý đồng thời bằng cách tự động suy luận rằng một số thuộc tính nên được bảo vệ bởi các actor, một mô hình đồng thời trong Swift. Tuy nhiên, tính năng này chưa được kích hoạt hoàn toàn và bị ẩn sau một cờ tính năng, có nghĩa là các nhà phát triển phải chủ động bật để sử dụng nó.

Swift 6 loại bỏ tính năng suy luận actor cho property wrappers. Điều này có nghĩa là:

• Swift sẽ không còn tự động suy luận rằng các thuộc tính sử dụng property wrappers. Nên được cô lập vào một actor cụ thể, như @MainActor.
• Động cơ đằng sau việc loại bỏ này bao gồm: Việc đơn giản hóa mô hình đồng thời và Tránh những hành vi không mong muốn hoặc gây nhầm lẫn.

Tại sao thay đổi này được thực hiện?

1. Giảm Phức Tạp: Suy luận tự động đôi khi có thể dẫn đến hành vi không mong muốn. Đặc biệt trong các cơ sở mã phức tạp mà nhà phát triển có thể không hoàn toàn nhận thức được những gì được suy luận.
2. Dễ Dự Đoán: Bằng cách loại bỏ suy luận tự động, Swift làm cho hành vi của property wrappers trở nên dễ dự đoán và rõ ràng hơn. Các nhà phát triển bây giờ phải chỉ rõ bất kỳ sự cô lập actor nào một cách thủ công, dẫn đến mã rõ ràng và dễ hiểu hơn.
3. Tiến Hóa của Mô Hình Đồng Thời: Mô hình đồng thời của Swift vẫn đang phát triển, và những thay đổi như thế này phản ánh nỗ lực liên tục để tinh chỉnh và cải thiện ngôn ngữ dựa trên phản hồi của nhà phát triển và việc sử dụng thực tế.

Ví dụ

Trong Swift 5.5 với suy luận actor, bạn có thể có mã như sau:

@propertyWrapper
struct MyWrapper {
    var wrappedValue: Int
}

@MainActor
class MyClass {
    @MyWrapper var myProperty: Int
}

Ở đây, @MyWrapper sẽ suy luận ngầm @MainActor cho myProperty. Trong Swift 6, bạn sẽ cần phải rõ ràng:

@propertyWrapper
struct MyWrapper {
    var wrappedValue: Int
}

@MainActor
class MyClass {
    @MainActor @MyWrapper var myProperty: Int
}

Khai báo rõ ràng này giúp bất kỳ ai đọc mã đều hiểu rằng myProperty được cô lập vào @MainActor. Áp dụng cho các Wapper Property có sẵn như @StateObject, @ObservedObject khi bạn dùng trong SwiftUI.

Tóm lại, Swift 6 loại bỏ suy luận actor tự động cho property wrappers để làm cho việc quản lý đồng thời trở nên rõ ràng và dễ dự đoán hơn, đơn giản hóa mô hình đồng thời của ngôn ngữ và giảm các nguồn gây nhầm lẫn tiềm ẩn.

Tạm kết

• Giới thiệu về việc hoàn chỉnh Concurrency với Swift 6
• Chỉ ra vài thay đổi nhỏ đảm bảo việc sử dụng đơn giản đối với lập trình viên
• Có nhiều khái niệm mới liên quan tới Region based Isolation
• Một số thay đổi cho Actor & MainActor

Tham khảo:

• Complete concurrency enabled by default
• Swift Evolution – Region based Isolation
• Swift Evolution – Remove Actor Isolation Inference caused by Property Wrappers

Okay! Tới đây, mình xin kết thúc bài viết giới thiệu về Builder Pattern. Nếu có gì thắc mắc hay góp ý cho mình. Thì bạn có thể để lại bình luận hoặc gửi email theo trang Contact.

Cảm ơn bạn đã đọc bài viết này!

Written by chuotfx

Hãy ngồi xuống, uống miếng bánh và ăn miếng trà. Chúng ta cùng nhau đàm đạo về đời, về code nhóe!