Hướng dẫn 19 phút đọc

Swift 6.2: Approachable Concurrency, InlineArray và Tất Cả Tính Năng Mới Bạn Cần Biết

Swift 6.2 mang đến Approachable Concurrency với MainActor mặc định, nonisolated async kế thừa isolation, InlineArray cho hiệu năng cao, Subprocess API và nhiều cải tiến thiết thực. Hướng dẫn chi tiết với ví dụ thực tế.

Editorial Team

Giới Thiệu: Concurrency Không Còn Là Nỗi Ám Ảnh

Nếu bạn đã từng vật lộn với hàng tá lỗi data-race warnings khi bật strict concurrency trong Swift 6, thì Swift 6.2 chính là bản cập nhật mà bạn hằng mong đợi. Thật sự đấy — Apple và đội ngũ Swift đã lắng nghe cộng đồng, và phản hồi rất rõ ràng: concurrency trong Swift quá khó để tiếp cận.

Mình còn nhớ lần đầu bật strict concurrency cho một dự án SwiftUI cỡ vừa. Kết quả? Hơn 200 warning. Cảm giác như compiler đang "tấn công" mình vậy. Nhiều bạn chắc cũng từng trải qua điều tương tự.

Swift 6.2 mang đến triết lý "Approachable Concurrency" — Concurrency Dễ Tiếp Cận. Ý tưởng cốt lõi rất đơn giản: thay vì buộc mọi developer phải hiểu rõ actor, Sendable, và isolation ngay từ đầu, Swift 6.2 cho phép bạn viết code an toàn một cách tự nhiên hơn. Chỉ khi nào thực sự cần đào sâu vào concurrency, bạn mới phải làm vậy.

Ngoài concurrency, bản cập nhật này còn giới thiệu InlineArray cho hiệu năng cao, Subprocess API cho quản lý tiến trình, cùng nhiều cải tiến nhỏ nhưng cực kỳ thiết thực. Nào, cùng đi vào chi tiết từng tính năng nhé.

Triết Lý "Approachable Concurrency" — Ba Giai Đoạn Tiếp Cận

Trước khi nhảy vào code, hãy hiểu bức tranh tổng thể đã. Đội ngũ Swift đã công bố một vision document phác thảo ba giai đoạn tiếp cận concurrency:

Giai đoạn 1: Code đơn giản, đơn luồng

Ứng dụng chạy hoàn toàn trên main thread. Bạn không cần biết gì về actor hay isolation. Compiler sẽ không "quăng" cho bạn hàng đống cảnh báo vô nghĩa. Đây là trạng thái mặc định cho hầu hết ứng dụng iOS đơn giản — và Swift 6.2 tôn trọng điều đó.

Giai đoạn 2: Async code không có lỗi data-race

Khi ứng dụng bắt đầu cần gọi network, đọc file, hay xử lý dữ liệu nặng, bạn dùng async/await. Nhưng thay vì bị buộc phải hiểu toàn bộ hệ thống concurrency, Swift 6.2 đảm bảo code async của bạn vẫn an toàn theo mặc định — chạy trên cùng actor với nơi gọi nó.

Giai đoạn 3: Tối ưu hiệu năng với song song hóa

Chỉ khi bạn thực sự cần parallelism để tăng hiệu năng, bạn mới cần đánh dấu rõ ràng các hàm cần chạy trên thread khác. Ngược hoàn toàn với trước đây — nơi mà mọi hàm async đều mặc định chạy trên thread pool.

Nói gọn lại: giảm thiểu concurrency theo mặc định, chỉ thêm vào khi bạn chủ đích muốn. Nghe hợp lý phải không?

MainActor Mặc Định (SE-0466) — Thay Đổi Lớn Nhất Của Swift 6.2

Đây là thay đổi có ảnh hưởng lớn nhất. Proposal SE-0466 giới thiệu cờ compiler -default-isolation MainActor, cho phép mọi code trong module của bạn tự động được coi là chạy trên @MainActor — trừ khi bạn chỉ định khác.

Nghe có vẻ đơn giản, nhưng tác động thì cực kỳ lớn.

Vấn đề với Swift 6.0/6.1

Trước đây, khi bạn bật strict concurrency, rất nhiều code hoàn toàn hợp lý lại bị compiler cảnh báo:

// Swift 6.0/6.1 — Lỗi khi bật strict concurrency
class DataController {
    var items: [String] = []

    func loadItems() {
        // ⚠️ Warning: Mutation of property 'items'
        // from nonisolated context
        items.append("New Item")
    }
}

struct ContentView: View {
    let controller = DataController()

    var body: some View {
        Button("Load") {
            controller.loadItems() // ⚠️ Thêm một warning nữa
        }
    }
}

Để sửa, bạn phải thêm @MainActor vào khắp nơi — class, struct, function. Rất phiền và tạo ra "noise" không cần thiết.

Giải pháp trong Swift 6.2

Với -default-isolation MainActor, mọi thứ tự động chạy trên MainActor:

// Swift 6.2 — Mọi thứ hoạt động suôn sẻ
class DataController {
    var items: [String] = []

    func loadItems() {
        // ✅ Tự động isolated trên MainActor
        items.append("New Item")
    }
}

struct ContentView: View {
    let controller = DataController()

    var body: some View {
        Button("Load") {
            controller.loadItems() // ✅ Không còn warning
        }
    }
}

Sạch sẽ hơn rất nhiều, đúng không?

Cách Bật MainActor Mặc Định

Nếu bạn dùng Swift Package Manager, thêm vào Package.swift:

targets: [
    .executableTarget(
        name: "MyApp",
        swiftSettings: [
            .defaultIsolation(MainActor.self)
        ]
    )
]

Trong Xcode, bạn thiết lập trong Build Settings bằng cách thêm cờ -default-isolation MainActor vào Other Swift Flags. Tin vui là với các dự án mới tạo trong Xcode 26, tùy chọn này được bật sẵn luôn.

Một điểm quan trọng cần nhớ: cờ này chỉ ảnh hưởng đến module hiện tại. Các thư viện bên ngoài mà bạn import sẽ không bị thay đổi — điều này đảm bảo tính ổn định của hệ sinh thái.

Khi Nào Cần "Thoát" MainActor?

Không phải tất cả code đều nên chạy trên main thread. Các tác vụ nặng về CPU hoặc I/O nên được chuyển ra ngoài. Bạn dùng nonisolated để opt-out:

// Chạy trên MainActor theo mặc định
class ImageProcessor {

    // Hàm này KHÔNG nên chạy trên main thread
    // vì xử lý ảnh rất nặng
    nonisolated func processImage(_ data: Data) async -> UIImage? {
        let processed = applyFilters(data)
        return UIImage(data: processed)
    }
}

Nonisolated Async Thay Đổi Hành Vi (SE-0461) — Hết Chuyện "Nhảy Thread" Bất Ngờ

Đây là thay đổi thứ hai cực kỳ quan trọng, và thành thật mà nói, mình nghĩ nó sẽ giúp rất nhiều developer tránh được những bug khó chịu. Proposal SE-0461 thay đổi cách hàm nonisolated async hoạt động.

Hành vi cũ (Swift 6.0/6.1)

Trước Swift 6.2, khi bạn gọi một hàm nonisolated async từ main thread, hàm đó sẽ tự động nhảy sang một thread khác trên cooperative thread pool:

// Swift 6.0/6.1
class NetworkClient {
    // nonisolated async — chạy trên thread pool
    func fetchData() async throws -> Data {
        // ⚠️ Đang ở thread #8, KHÔNG phải main thread!
        // Dù caller đang ở main thread
        let url = URL(string: "https://api.example.com/data")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    }
}

// Gọi từ MainActor
@MainActor
class ViewModel {
    let client = NetworkClient()

    func load() async {
        // Đang ở main thread
        let data = try? await client.fetchData()
        // ⚠️ fetchData() đã "nhảy" sang thread khác
    }
}

Hành vi "nhảy thread" này là nguồn gốc của rất nhiều bug khó debug. Đa số developer (kể cả mình) thường không nhận ra rằng hàm async đang chạy trên thread khác cho đến khi gặp crash lạ.

Hành vi mới (Swift 6.2)

Trong Swift 6.2, hàm nonisolated async mặc định sẽ kế thừa isolation của caller. Caller ở MainActor? Hàm chạy trên MainActor. Caller ở actor khác? Hàm chạy trên actor đó:

// Swift 6.2
class NetworkClient {
    func fetchData() async throws -> Data {
        // ✅ Nếu caller ở main thread, hàm này cũng ở main thread
        let url = URL(string: "https://api.example.com/data")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    }
}

Đơn giản và an toàn hơn nhiều.

@concurrent — Khi Bạn Muốn Chạy Song Song Thật Sự

Nhưng nếu bạn thực sự muốn hàm chạy trên thread khác (ví dụ xử lý nặng, không muốn block main thread), Swift 6.2 có attribute @concurrent mới:

class HeavyProcessor {
    @concurrent
    nonisolated func crunchNumbers(_ data: [Double]) async -> Double {
        // ✅ Chạy trên background thread — chủ đích rõ ràng
        var sum = 0.0
        for value in data {
            sum += value * value
        }
        return sum.squareRoot()
    }
}

Tóm lại sự khác biệt:

  • Mặc định (nonisolated async): Kế thừa isolation của caller → an toàn, đơn giản
  • @concurrent nonisolated: Chạy trên thread pool → hiệu năng tốt hơn cho tác vụ nặng

Bật Tính Năng

Để dùng hành vi mới, bạn cần bật feature flag:

// Package.swift
swiftSettings: [
    .enableExperimentalFeature("NonisolatedNonsendingByDefault")
]

Trong các phiên bản Swift tương lai, đây sẽ là hành vi mặc định mà không cần flag.

Global-Actor Isolated Conformance (SE-0470)

Cải tiến này nhỏ nhưng sẽ khiến bạn thở phào. SE-0470 cho phép các type isolated trên global actor conform protocol dễ dàng hơn.

Trước đây, nếu bạn có một @MainActor class conform protocol, compiler thường phàn nàn vì protocol methods mặc định là nonisolated:

// Trước Swift 6.2
protocol DataProvider {
    func fetchItems() async -> [String]
}

@MainActor
class MyProvider: DataProvider {
    // ⚠️ Warning: Main actor-isolated instance method
    // 'fetchItems()' cannot be used to satisfy nonisolated
    // protocol requirement
    func fetchItems() async -> [String] {
        return ["Item 1", "Item 2"]
    }
}

Trong Swift 6.2, compiler thông minh hơn trong việc xử lý các trường hợp này. Ít warning vô nghĩa hơn — ai mà không thích chứ?

InlineArray — Mảng Cố Định Kích Thước Trên Stack (SE-0453)

Chuyển sang một chủ đề hoàn toàn khác nhé. InlineArray là kiểu dữ liệu mới cho phép tạo mảng có kích thước cố định, lưu trực tiếp trên stack thay vì heap. Nếu bạn từng làm việc với C (T[N]), C++ (std::array<T, N>), hay Rust ([T; N]) thì sẽ thấy quen thuộc.

Tại sao cần InlineArray?

Trong Swift truyền thống, Array luôn dùng bộ nhớ heap. Linh hoạt thì có, nhưng đi kèm overhead — allocation, reference counting, cache miss. Với InlineArray, dữ liệu nằm ngay trên stack, giảm overhead đáng kể khi kích thước mảng biết trước.

Cú pháp cơ bản

// Khai báo tường minh
var planets: InlineArray<4, String> = ["Mercury", "Venus", "Earth", "Mars"]

// Suy luận kiểu tự động
var colors: InlineArray = ["Red", "Green", "Blue"]

// Cú pháp ngắn gọn (sugar syntax)
struct GameBoard {
    var cells: [64 of Cell]  // 64 ô cố định
}

// Truy cập phần tử
print(planets[0]) // "Mercury"
planets[2] = "Terra" // Thay đổi giá trị

Những Điều Cần Lưu Ý

InlineArray khác Array thông thường ở vài điểm quan trọng:

  • Không có append/remove: Kích thước cố định, không thêm hoặc xóa phần tử được
  • Không conform Sequence/Collection: Không dùng for-in trực tiếp được — phải dùng indices
  • Kích thước biết tại compile-time: Nhờ Integer Generic Parameters (SE-0452)
// Duyệt qua InlineArray
var scores: InlineArray<5, Int> = [90, 85, 92, 78, 95]

for i in scores.indices {
    print("Score \(i): \(scores[i])")
}

// KHÔNG thể dùng for-in trực tiếp:
// for score in scores { } // ❌ Lỗi compile

Ứng dụng thực tế — Game Development

InlineArray thực sự tỏa sáng trong các lĩnh vực cần hiệu năng cao. Đây là một ví dụ điển hình:

struct Sprite {
    var x: Float
    var y: Float
    var isActive: Bool
}

struct GameScene {
    // 100 sprite cố định, lưu trên stack
    var sprites: InlineArray<100, Sprite>

    mutating func update() {
        for i in sprites.indices {
            if sprites[i].isActive {
                sprites[i].x += 1.0
                sprites[i].y += 0.5
            }
        }
    }
}

Theo các benchmark, InlineArray có thể nhanh hơn Array thông thường từ 20% đến 30% trong các tình huống như render đồ họa, xử lý âm thanh, hay machine learning. Con số này khá ấn tượng cho một thay đổi tương đối đơn giản.

Subprocess API — Quản Lý Tiến Trình Không Còn Đau Đầu

Nếu bạn từng phải dùng Process (hay NSTask thời xưa) để chạy command-line tools từ Swift, bạn biết nó khó chịu đến mức nào. Swift 6.2 giới thiệu package Subprocess — một API hiện đại, thân thiện với concurrency.

Sử dụng cơ bản

import Subprocess

// Chạy lệnh đơn giản
let result = try await run(
    .name("ls"),
    output: .string(limit: 4096)
)
print(result.standardOutput) // Danh sách file
print(result.terminationStatus) // exited(0)

Truyền đầu vào và thu đầu ra

import Subprocess

let content = "Hello, Swift 6.2!"
let result = try await run(
    .name("cat"),
    input: .string(content),
    output: .string(limit: 4096)
)
print(result.standardOutput) // "Hello, Swift 6.2!"

Cấu hình nâng cao

import Subprocess

// Chạy với biến môi trường và thư mục tùy chỉnh
let result = try await run(
    .path("/usr/bin/swift"),
    arguments: ["build", "--configuration", "release"],
    environment: .inherit.updating([
        "SWIFT_DETERMINISTIC_HASHING": "1"
    ]),
    workingDirectory: "/path/to/project",
    output: .string(limit: 1024 * 1024),
    error: .string(limit: 4096)
)

if case .exited(0) = result.terminationStatus {
    print("Build thành công!")
} else {
    print("Build thất bại: \(result.standardError)")
}

Subprocess đặc biệt hữu ích cho command-line tools, script tự động hóa, và ứng dụng server-side. Nếu bạn đang xây dựng tooling bằng Swift, đây là thứ bạn sẽ dùng thường xuyên.

Raw Identifiers (SE-0451) — Tên Biến Thoải Mái Hơn

Swift đã hỗ trợ backtick để dùng keyword làm tên biến (`class`, `func`), nhưng SE-0451 mở rộng khả năng này — bạn có thể dùng gần như bất kỳ chuỗi nào làm identifier:

// Enum với HTTP status code làm case
enum HTTPError: String {
    case `401` = "Unauthorized"
    case `404` = "Not Found"
    case `500` = "Internal Server Error"
}

let error = HTTPError.`404`
print(error.rawValue) // "Not Found"

// Test method với tên mô tả rõ ràng hơn bao giờ hết
func `test users can login with valid credentials`() {
    // Test implementation
}

Tính năng này đặc biệt hay cho unit testing — tên test method mô tả chính xác điều đang được test, đọc lên như một câu tiếng Anh bình thường.

Default Value Cho String Interpolation (SE-0477)

Cải tiến nhỏ nhưng mình rất thích cái này. Bạn có thể cung cấp giá trị mặc định khi interpolate Optional vào string:

var username: String? = nil
var age: Int? = 25

// Trước Swift 6.2
print("User: \(username ?? "Unknown")") // Dùng ??
print("Age: \(age.map(String.init) ?? "N/A")")

// Swift 6.2 — gọn gàng hơn
print("User: \(username, default: "Unknown")")
print("Age: \(age, default: "N/A")")

// Kết quả:
// User: Unknown
// Age: 25

Không chỉ đẹp hơn mà còn rõ ràng về ý định. Bạn đang cung cấp giá trị mặc định, không phải thực hiện phép toán nil-coalescing. Có vẻ là chi tiết nhỏ, nhưng khi viết nhiều code xử lý Optional string, bạn sẽ cảm ơn tính năng này.

Task Naming (SE-0469) — Debug Concurrent Code Dễ Thở Hơn

Debugging concurrent code luôn là cơn ác mộng — mình nói thật. Bạn có hàng chục Task chạy đồng thời, và trong Xcode debugger tất cả đều hiện là "Task" vô danh. Swift 6.2 cho phép đặt tên cho Task:

let fetchTask = Task(name: "FetchUserProfile") {
    let profile = try await api.fetchProfile(userId: 42)
    return profile
}

let imageTask = Task(name: "DownloadAvatar") {
    let image = try await imageLoader.download(url: avatarURL)
    return image
}

// Trong Xcode Debugger:
// Task "FetchUserProfile" — Running
// Task "DownloadAvatar" — Suspended

Tên hiển thị trong debugger, Instruments, và log. Khi ứng dụng có nhiều Task chạy cùng lúc, khả năng đặt tên này tiết kiệm cho bạn hàng giờ debug. Không phóng đại đâu.

Collection Conformance Cho enumerated() (SE-0459)

Đây là thay đổi mà dân SwiftUI sẽ vui nhất. Trước Swift 6.2, enumerated() trả về EnumeratedSequence — chỉ conform Sequence, không phải Collection. Vấn đề? Không dùng được với List hay ForEach:

let items = ["Swift", "Kotlin", "Rust"]

// Trước Swift 6.2 — ❌ Không hoạt động
List(items.enumerated(), id: \.offset) { index, item in
    Text("\(index): \(item)")
}

// Swift 6.2 — ✅ Hoạt động hoàn hảo
List(items.enumerated(), id: \.offset) { index, item in
    Text("\(index): \(item)")
}

// ForEach cũng OK
ForEach(items.enumerated(), id: \.offset) { index, item in
    HStack {
        Text("\(index + 1).")
            .foregroundStyle(.secondary)
        Text(item)
    }
}

Thay đổi nhỏ, nhưng giải quyết một frustration mà rất nhiều người gặp phải hàng ngày.

Cải Tiến Swift Testing

Swift Testing framework cũng nhận được vài cải tiến đáng chú ý:

Exit Tests (ST-0008)

Giờ bạn có thể test các trường hợp mà code gây ra fatalError() hoặc preconditionFailure() — điều trước đây gần như không thể làm được một cách "sạch sẽ":

import Testing

@Test func testInvalidIndexCrashes() async {
    await #expect(processExitsWith: .failure) {
        var array = [1, 2, 3]
        _ = array[10] // Gây crash
    }
}

Attachments (ST-0009)

Đính kèm dữ liệu bổ sung vào test report — hình ảnh, log, JSON response. Rất tiện cho việc debug test thất bại:

import Testing

@Test func testAPIResponse() async throws {
    let response = try await api.fetch("/users")

    // Đính kèm response vào test report
    Test.Attachment(
        named: "api-response.json",
        data: response.body
    ).attach()

    #expect(response.status == 200)
}

Condition Trait Evaluation (ST-0010)

Cho phép skip test dựa trên runtime conditions một cách linh hoạt hơn — hữu ích khi test phụ thuộc vào platform hay environment cụ thể.

Hướng Dẫn Di Chuyển Sang Swift 6.2

Nếu dự án bạn đang dùng Swift 6.0 hoặc 6.1, tin tốt là việc migrate sang Swift 6.2 khá suôn sẻ. Đây là các bước mình gợi ý:

Bước 1: Cập nhật Xcode

Đảm bảo bạn dùng Xcode 26 hoặc mới hơn — đây là phiên bản đi kèm Swift 6.2.

Bước 2: Bật MainActor mặc định

Tùy chọn nhưng mình khuyến nghị nên bật:

// Package.swift
swiftSettings: [
    .defaultIsolation(MainActor.self)
]

Build lại dự án sau khi bật. Bạn sẽ thấy số warning giảm đáng kể — cảm giác khá satisfying.

Bước 3: Bật NonisolatedNonsendingByDefault

// Package.swift
swiftSettings: [
    .defaultIsolation(MainActor.self),
    .enableExperimentalFeature("NonisolatedNonsendingByDefault")
]

Bước 4: Xem xét các hàm cần @concurrent

Duyệt qua code và tìm các hàm async thực sự cần chạy trên background thread. Đánh dấu chúng với @concurrent nonisolated:

class MediaProcessor {
    // ✅ Nên chạy trên background — xử lý video nặng
    @concurrent
    nonisolated func compressVideo(_ url: URL) async throws -> URL {
        return compressedURL
    }

    // ✅ Chạy trên MainActor OK — chỉ cập nhật UI
    func updateProgress(_ value: Double) {
        progressBar.value = value
    }
}

Bước 5: Tận dụng InlineArray cho hot paths

Nếu bạn có code hiệu năng cao (game loop, audio processing, image filter), hãy cân nhắc thay Array bằng InlineArray ở những chỗ kích thước đã biết trước.

Ví Dụ Thực Tế: Ứng Dụng Hoàn Chỉnh Với Swift 6.2

Để kết hợp tất cả những gì đã nói, hãy cùng xây dựng một ứng dụng nhỏ sử dụng các tính năng mới. Mình sẽ chú thích để bạn thấy rõ từng tính năng được áp dụng ở đâu:

import SwiftUI

// Với defaultIsolation MainActor, tất cả code dưới đây
// tự động chạy trên MainActor — không cần annotation

struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String?
}

class UserService {
    private let baseURL = "https://api.example.com"

    func fetchUsers() async throws -> [User] {
        // Kế thừa isolation từ caller
        let url = URL(string: "\(baseURL)/users")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode([User].self, from: data)
    }

    // Xử lý nặng — chạy trên background rõ ràng
    @concurrent
    nonisolated func processUserData(
        _ users: [User]
    ) async -> [String] {
        users.map { user in
            "\(user.name): \(user.email, default: "No email")"
        }
    }
}

@Observable
class UserViewModel {
    var users: [User] = []
    var summaries: [String] = []
    var isLoading = false
    var errorMessage: String?

    private let service = UserService()

    func loadUsers() async {
        isLoading = true
        errorMessage = nil

        let fetchTask = Task(name: "FetchUsers") {
            try await service.fetchUsers()
        }

        do {
            users = try await fetchTask.value
            summaries = await service.processUserData(users)
        } catch {
            errorMessage = "Lỗi: \(error.localizedDescription)"
        }

        isLoading = false
    }
}

struct UserListView: View {
    @State private var viewModel = UserViewModel()

    var body: some View {
        NavigationStack {
            Group {
                if viewModel.isLoading {
                    ProgressView("Đang tải...")
                } else if let error = viewModel.errorMessage {
                    ContentUnavailableView(
                        "Lỗi",
                        systemImage: "exclamationmark.triangle",
                        description: Text(error)
                    )
                } else {
                    List(
                        viewModel.summaries.enumerated(),
                        id: \.offset
                    ) { index, summary in
                        HStack {
                            Text("\(index + 1).")
                                .foregroundStyle(.secondary)
                                .monospacedDigit()
                            Text(summary)
                        }
                    }
                }
            }
            .navigationTitle("Người dùng")
            .task {
                await viewModel.loadUsers()
            }
        }
    }
}

Chú ý những điểm thú vị trong ví dụ trên:

  • Không có @MainActor annotation nào — nhờ defaultIsolation
  • fetchUsers() kế thừa isolation từ caller, chạy trên MainActor
  • processUserData() dùng @concurrent vì xử lý nặng
  • Task được đặt tên "FetchUsers" để dễ debug
  • String interpolation dùng default: cho Optional email
  • enumerated() hoạt động trực tiếp với List

Kết Luận

Swift 6.2 không phải bản cập nhật mang tính cách mạng — và thành thật, đó chính là điều tuyệt vời. Thay vì thêm khái niệm mới phức tạp, nó tập trung vào việc làm cho những thứ đã có trở nên dễ dùng hơn.

MainActor mặc định (SE-0466) giúp bạn không phải rải @MainActor khắp nơi. Nonisolated async kế thừa isolation (SE-0461) chấm dứt chuyện "nhảy thread" bất ngờ. @concurrent cho bạn quyền chủ động chọn khi nào cần song song hóa.

Thêm vào đó, InlineArray mở ra cơ hội tối ưu hiệu năng, Subprocess hiện đại hóa việc quản lý tiến trình, và các cải tiến nhỏ như Task Naming, Raw Identifiers, Default String Interpolation giúp trải nghiệm viết Swift mượt mà hơn từng chút một.

Lời khuyên của mình: hãy bắt đầu bằng việc bật defaultIsolation(MainActor.self) trong dự án. Bạn sẽ ngạc nhiên khi thấy bao nhiêu warning biến mất. Từ đó, dần dần khám phá các tính năng khác theo nhu cầu thực tế.

Swift đang đi đúng hướng — làm cho điều đơn giản trở nên dễ dàng, và điều phức tạp trở nên khả thi.