實戰需求

新業務可以停止之前舊業務

實戰代碼

import Foundation

/*
 consumerModel.forceEnd()
 consumerModel = ConsumerModel()
 consumerModel.addNew(taskData: self.items[t])

 */
class ConsumerModel: ObservableObject {
    @Published var operateFlag = false
    @Published var taskData = ""
    @Published var rsData = ""
    let lock = NSLock()
    let lock2 = NSLock()
    static var taskID = 0
    var op_worker:DispatchWorkItem? = nil
    var watch_worker:DispatchWorkItem? = nil
    var countNum = 0
    //最多不能超過10秒
    var maxTTS = 10
    
    func setTaskData(ts:String){
        lock2.lock()
        self.taskData = ts
        lock2.unlock()
    }
    func getTaskFlag()->String{
        return "#@\(ConsumerModel.taskID)@#"
    }
    func getTaskFlags()->[String]{
        return [
            "＃@ \(ConsumerModel.taskID) @＃"
           
        ]
    }
    func clearFlags(ts:String) -> String{
        var nstr = ts
        for item in self.getTaskFlags(){
           nstr = nstr.replacingOccurrences(of: item, with: "")
        }
        return nstr
    }
    //添加新業務
    func addNew(taskData:String){
        //self.taskData = taskData
        self.setTaskData(ts: taskData)
        //如果有在進行業務，終止
        print("添加新業務")
        if isOperate(){
            forceEnd()
            endOperate()
        }
        //開始業務
        startOperate()
        
    }
    //判斷業務是否在處理
    func isOperate()-> Bool{
        return operateFlag
    }
    // 開始處理業務
    func startOperate(){
        print("開始處理業務")
        lock.lock()
        self.operateFlag = true
        self.countNum = 0
        ConsumerModel.taskID =  ConsumerModel.taskID + 1
        let data = self.getTaskFlag() + self.taskData
        lock.unlock()
        //實際處理業務
        self.op_worker = DispatchWorkItem {
            webModel.getHTMLItemByID(ts:data)
        }
        
       
        //開啟輪詢
     
        self.watch_worker = DispatchWorkItem {
             self.startLoop()
        }
        DispatchQueue.main.async(execute:self.op_worker!)
        DispatchQueue.global().async(execute:self.watch_worker!)
        
    }
    // 終止業務
    func endOperate(){
        self.operateFlag = false
        self.taskData = ""
        self.rsData = ""
        
    }
    // 啟動輪詢
    func startLoop(){
        //建個一段時間進行監控
        while (self.isOperate() && (self.countNum < self.maxTTS))
        {
            
            self.countNum = self.countNum + 1
            
            print("每一秒執行\(self.countNum)")
            if isCanFinish(){
                //完成業務
                finished()
                return
            }
            sleep(1)
            
        }
        if isCanFinish(){
            //完成業務
            finished()
            return
        }
        
        timeout()
        
    }
    //是否強制停止
    func forceEnd(){
        if self.op_worker != nil {
            if !self.op_worker!.isCancelled{
            
                self.op_worker?.cancel()
            }
        }
        if self.watch_worker != nil {
            if !self.watch_worker!.isCancelled{
                self.op_worker?.cancel()
            }
        }
    }
    //是否達到某個條件完成
    func isCanFinish()-> Bool{
        DispatchQueue.main.async{
        webModel.getTranslate2()
        }
        let cstr = webModel.translateStr
        let flags = self.getTaskFlags()
        for item in flags {
            if cstr.contains(item){
                //DispatchQueue.main.async{
                self.rsData = self.clearFlags(ts: cstr)
               // }
                print("rsData:\(rsData)")
                return true
            }
        }
        return false
    }
    
    //完成業務，通知其他組件
    func finished(){
        print("完成業務，通知其他組件")
        self.operateFlag = false
        DispatchQueue.main.async{
        gModel.translateText = self.rsData
        }
        
    }
    //超時
    func timeout(){
        self.operateFlag = false
        print("超時")
        
    }
}