1: 创建队列：

var commandExcuteQuene = OperationQueue()
commandExcuteQuene.maxConcurrentOperationCount = 2    // 队列并发数量

2: 将自定义Operation 加入队列 ：

let op = ExcuteOperation()      
commandExcuteQuene.addOperation(op)

3: 自定义Operation类别， start 和 main 区别

1: 同步执行：只需要重写 main 函数（要线程执行的代码），系统执行完main 函数后会自动将该Operation从队列中移除；

说明： 重写了main 函数，系统则认为是同步执行，不管任务是否结束，函数执行完自动移除队列， 如果想自己管理状态，可以用异步执行；

2:异步执行：重写 start 函数和要管理的状态，如结束状态（isFinished）；

说明：重写了start函数（要线程执行的代码），系统则认为是异步执行，函数执行完不会自动从队列中移除； 开发人员需要手动通知系统 isFinished 状态的变更；

class ExcuteOperation: Operation {
    var finishOver: Bool = false
    override var isFinished: Bool {
        get {
            // 发送 kvo didChangeValue 通知后，系统会回调询问该属性， return true 表示任务已结束
            return finishOver
        }
    }
    deinit {
        print("deinit")
    }
    override func start() {
        // 异步任务执行完后，执行这两行代码，告知系统任务结束 例如： 请求网络完成的回调中
        finishOver = true
        self.didChangeValue(forKey: "isFinished")
    }
}

3 :取消

说明：提供的cancelAllOperations 函数并不能将Operation 从队列中移除；

自己实现了清除队列（强制 finish）

protocol OperationCancelable {
    var manualFinish: Bool {
        get set
    }
    var manualCancel: Bool {
        get set
    }
    
    func removeFromQueue()
}

class ExcuteOperation : Operation, OperationCancelable {
    
    var manualFinish: Bool = false
    var manualCancel: Bool = false
    
    override var isFinished: Bool {
        get {
            // 如果被手动取消，finish 返回 true
            if manualCancel {
                return true
            }
            return manualFinish
        }
    }
    
    override var isCancelled: Bool {
        get {
            return manualCancel
        }
    }
    
    func removeFromQueue() {
        print("执行手动完成队列")
        manualCancel = true
        self.willChangeValue(forKey: "isFinished")
        self.didChangeValue(forKey: "isFinished")
    }
    
    deinit {
        print("任务被释放")
    }
    
    override func start() {
        print("执行任务")
    }
}