Actor — คืออะไร การแยกข้อมูล และการทำงานพร้อมกัน

Actor ใน Swift คืออะไร?

Actor เป็นชนิดอ้างอิง คล้ายกับคลาส แต่มีการป้องกันอัตโนมัติต่อการแข่งข้อมูล มันถูกนำเสนอใน Swift 5.5 ซึ่งเป็นส่วนหนึ่งของระบบการทำงานพร้อมกันควบคู่ไปกับ async/await และ Task Actor รับประกันว่าสถานะที่เปลี่ยนแปลงได้ของมันจะไม่ถูกอ่านหรือเขียนพร้อมกันจากเธรดที่แตกต่างกันโดยไม่มีการซิงโครไนซ์ที่ชัดเจน

ไวยากรณ์การประกาศ Actor

ในการประกาศ actor ให้ใช้คำหลัก actor ตามด้วยวงเล็บปีกกาที่มีสมาชิกของมัน ในทางไวยากรณ์ actor มีลักษณะคล้ายคลาส แต่พฤติกรรมของมันแตกต่างอย่างสิ้นเชิง

actor BankAccount {
    private var balance: Double
    
    init(initialBalance: Double) {
        self.balance = initialBalance
    }
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func getBalance() -> Double {
        return balance
    }
}

คอมไพเลอร์จะแยกพร็อพเพอร์ตี้และเมธอดทั้งหมดของ actor โดยอัตโนมัติเพื่อให้เข้าถึงได้เฉพาะภายใน บริบทของ actor เท่านั้น เมื่อพยายามเข้าถึง balance จากภายนอก actor คอมไพเลอร์จะสร้างข้อผิดพลาดหากการเรียกไม่ได้ถูกทำเครื่องหมายเป็น async

การแยกข้อมูลใน Actor ทำงานอย่างไร

การแยกข้อมูล เป็นแนวคิดหลักของ actor Actor รับประกันการเข้าถึงสถานะของมันแบบเอกสิทธิ์ซึ่งกันและกันผ่านกลไกของผู้ดำเนินการ actor แต่ละ actor มีผู้ดำเนินการของตัวเองที่ประมวลผลการเข้าถึงสมาชิกที่ถูกแยกทั้งหมดตามลำดับ

หลักการทำงานของการแยก

เมื่อโค้ดภายนอก actor เรียกเมธอดของมัน การเรียกจะถูกวางในคิวของ ผู้ดำเนินการ actor Actor ดำเนินการเพียงงานเดียวในแต่ละครั้ง รับประกันว่าไม่มีการแข่งกัน หากสองเธรดเรียก deposit พร้อมกัน การเรียกที่สองจะรอให้การเรียกแรกเสร็จสมบูรณ์

let account = BankAccount(initialBalance: 1000.0)
// การเรียกแบบอะซิงโครนัส — จำเป็นจากภายนอก actor
await account.deposit(amount: 500.0)
let currentBalance = await account.getBalance()

ทุกการเรียกเมธอดของ actor จำเป็นต้องมี await เพราะ actor อาจกำลังยุ่งกับงานอื่น นี่ไม่ใช่บั๊ก แต่เป็นการออกแบบโดยเจตนาที่ป้องกันการแข่งกัน Swift ทำให้ getter และ setter ของพร็อพเพอร์ตี้ของ actor เป็น async โดยปริยาย ดังนั้นการอ่านพร็อพเพอร์ตี้ก็จำเป็นต้องมี await เช่นกัน

ความแตกต่างหลักระหว่าง Actor และคลาส

Actor และคลาสเป็นชนิดอ้างอิงทั้งคู่ แต่พฤติกรรมของพวกมันในสภาพแวดล้อมแบบหลายเธรดแตกต่างกันอย่างมาก คลาสไม่ให้การป้องกันอัตโนมัติใด ๆ ต่อการแข่งกัน ในขณะที่ actor ฝังมันไว้ในระดับคอมไพเลอร์ผ่านระบบชนิด

การสืบทอดของ Actor

Actor สามารถสืบทอดจาก actor อื่นเท่านั้นและไม่สามารถสืบทอดจากคลาสได้ นี่เป็นความตั้งใจเพราะคลาสขาดกลไก การแยกของ actor และการผสมชนิดจะทำให้การรับประกันความปลอดภัยเสียหาย

actor SavingsAccount: BankAccount {
    func applyInterest(rate: Double) {
        let interest = balance * rate
        balance += interest
    }
}

การเรียกเมธอดของ Actor แบบอะซิงโครนัส

การเรียกแบบอะซิงโครนัส เป็นกลไกสำหรับโต้ตอบกับ actor จากโค้ดภายนอก เนื่องจาก actor แยกสถานะของมัน การเข้าถึงสมาชิกของมันจากภายนอกจึงจำเป็นต้องมี await ซึ่งช่วยให้ Swift รับประกันว่าโค้ดที่เรียกไม่บล็อกเธรดและ actor สามารถประมวลผลคำขออื่น ๆ ได้

Actor ทั่วโลกและท้องถิ่น

นอกจากชนิดของ actor ที่ประกาศแล้ว Swift รองรับ actor ทั่วโลก — คุณลักษณะ @MainActor ซึ่งทำเครื่องหมายคลาส พร็อพเพอร์ตี้ หรือเมธอดว่าสามารถดำเนินการบนเธรดหลักได้ ซึ่งมีประโยชน์อย่างยิ่งสำหรับโค้ด UI ในแอปพลิเคชัน iOS

@MainActor
class ViewModel: ObservableObject {
    @Published var title: String = ""
    
    func updateTitle() {
        // โค้ดนี้รับประกันว่าจะทำงานบนเธรดหลัก
        title = "New Title"
    }
}

การใช้ @MainActor ช่วยขจัดความจำเป็นในการเรียก DispatchQueue.main.async ด้วยตนเอง ทำให้โค้ดสะอาดและปลอดภัยยิ่งขึ้น คอมไพเลอร์ตรวจสอบว่าการสลับไปยังเธรดหลักเกิดขึ้นอย่างถูกต้อง

บริบท Nonisolated และ Actor-Isolated

Nonisolated เป็นคำหลักที่อนุญาตให้ทำเครื่องหมายเมธอดหรือพร็อพเพอร์ตี้ที่คำนวณของ actor ว่าไม่ได้ถูกแยก สมาชิกดังกล่าวไม่สามารถเข้าถึงสถานะที่ถูกแยกของ actor แต่สามารถเรียกได้โดยไม่ต้อง await จากภายนอก actor

ฟังก์ชัน Nonisolated

เมธอด nonisolated มีประโยชน์สำหรับการคำนวณที่ไม่ขึ้นอยู่กับสถานะที่เปลี่ยนแปลงได้ของ actor ตัวอย่างเช่น เมธอด formatBalance ไม่ได้เข้าถึง balance โดยตรง แต่เพียงจัดรูปแบบค่าที่ส่งมา — เมธอดเช่นนี้ปลอดภัยที่จะทำให้เป็น nonisolated

actor BankAccount {
    private var balance: Double = 0
    
    nonisolated func formatBalance(amount: Double) -> String {
        return "$\(amount)"
    }
}

สมาชิก nonisolated ดำเนินการแบบซิงโครนัสและไม่ต้องการ await อย่างไรก็ตาม พวกมันไม่สามารถอ่านพร็อพเพอร์ตี้ที่ถูกแยกของ actor ได้โดยตรง หากเมธอด nonisolated ต้องการค่าจาก actor จะต้อง ส่งเป็นพารามิเตอร์

Reentrancy และการเข้าซ้ำ

Reentrancy เป็นกลไกที่อนุญาตให้เข้า actor ซ้ำในระหว่างรอการเรียกแบบอะซิงโครนัส หากไม่มี reentrancy actor อาจตายแบบตลอดไปหากหนึ่งในเมธอดของมันรออีกเมธอดที่รอเมธอดแรก

Reentrancy ทำงานอย่างไร

เมื่อโค้ดภายใน actor ดำเนินการ await actor จะระงับงานปัจจุบันและสามารถ ประมวลผลงานอื่น ที่อยู่ในคิวได้ หลังจาก await เสร็จสมบูรณ์ งานจะกลับมาดำเนินการต่อ สิ่งนี้ป้องกันการตายแบบแต่ต้องใช้ความระมัดระวัง: สถานะของ actor ระหว่างจุด await อาจเปลี่ยนแปลง

actor DataProcessor {
    var cache: [Int: String] = [:]
    
    func process(id: Int) async -> String {
        if let cached = cache[id] {
            return cached
        }
        // await — จุดเข้าซ้ำ
        let result = await fetchData(id: id)
        // แคชอาจเปลี่ยนแปลงหลังจาก await — ตรวจสอบอีกครั้ง
        cache[id] = result
        return result
    }
}

นักพัฒนาต้องคำนึงถึงการเข้าซ้ำและตรวจสอบสถานะของ actor หลังจากจุด await ข้อผิดพลาดทั่วไปคือการสันนิษฐานว่าการแยกของ actor ยังคงอยู่ตลอด จุดพัก แบบอะซิงโครนัส ในทางปฏิบัติ ระหว่าง await และคำสั่งถัดไป สถานะอาจแตกต่างจากที่คาดไว้