Gcdqueue encapsulation

1. DispatchQueue It's actually an abstract concept , Not a queue in a data structure

• demand ： To create a queue , Add synchronous serial task

• Code encapsulation ：

class GCDQueue: NSObject {
    var syncQueue: DispatchQueue?
    var head: SingalLinkList = SingalLinkList()
    var count: Int = 0
    let lock: NSLock = NSLock()
    
    init(_ queueLabel: String) {
        syncQueue = DispatchQueue(label: queueLabel)
    }
    
    public func clear() {
        count = 0
        head.next = nil
    }
    
    public func getNode(index: Int) -> SingalLinkList? {
        var curIndex = index
        checkIndex(index: &curIndex)
        
        var node = head.next
        for _ in 0..<index {
            node = node?.next
        }
        
        return node
    }
    
    public func add<T>(task: T, _ index: Int = -1) {
        lock.lock()
        
        var curIndex = index == -1 ? count : index
        checkIndex(index: &curIndex)
        
        if count == 0 {
            head.next = SingalLinkList(ele: task, nextL: nil)
        } else {
            let pre = getNode(index: curIndex - 1)
            let node = getNode(index: curIndex)
            pre?.next = SingalLinkList(ele: task, nextL: node)
        }
        
        count += 1
        lock.unlock()
    }
    
    
    public func doTask() {
        //  Implementation subclass 
    }
    
    private func checkIndex(index: inout Int) {
        if index < 0 || index > count {
            print(" The subscript crossing the line , Put it last ")
            index = count
        }
    }
}

class SingalLinkList {
    var next: SingalLinkList?
    var element: AnyObject?
     
    init() {
        element = nil
        next = nil
    }
    init<T>(ele: T?, nextL: SingalLinkList?) {
        element = ele as AnyObject
        next = nextL
    }
}

• Specific tasks should be done , Need to inherit GCDQueue, rewrite doTask Method

class taskQueue: GCDQueue {
    override func doTask() {
        if count == 0 {
            return
        }
        guard let temp = head.next?.element as? testTask else {
            return
        }
        
        print("doTask--",temp.val)
        
        count -= 1
        let node = head.next?.next
        head.next = node
        
        doTask()
    }
}

• Use cases

class ViewController: UIViewController {

    var queue: taskQueue = taskQueue("testQueue")
    
    override func viewDidLoad() {
        super.viewDidLoad()
		
        for i in 0..<5 {
            let task = testTask(value: i)
            queue.add(task: task)
            
        }
        let temp = testTask(value: 100)
        queue.add(task: temp, 9)
        
        queue.doTask()
    } 
}

• Print the results

doTask-- 0
doTask-- 1
doTask-- 2
doTask-- 100
doTask-- 3
doTask-- 4