swift版的GCD封装

swift版的GCD封装

说明

本人针对swift封装了GCD,包括GCDQueue,GCDGroup,GCDTimer以及GCDSemaphore,使用较为便利.

源码

https://github.com/YouXianMing/Swift-GCD

//
//  GCDQueue.swift
//  GCD
//
//  http://home.cnblogs.com/u/YouXianMing/
//  https://github.com/YouXianMing
//
//  Created by YouXianMing on 15/10/9.
//

import UIKit

enum QueueType {

    case SerialQueue,     // 串行线程队列
         ConcurrentQueue, // 并发线程队列
         None             // 无类型
}

class GCDQueue: NSObject {

    // MARK: 变量
    var dispatchQueue : dispatch_queue_t!

    // MARK: 初始化
    override init() {

        super.init()
        dispatchQueue = dispatch_queue_create(nil, DISPATCH_QUEUE_CONCURRENT)
    }

    init(queueType : QueueType) {

        super.init()

        switch queueType {

        case .SerialQueue:

            dispatchQueue = dispatch_queue_create(nil, DISPATCH_QUEUE_SERIAL)
            break

        case .ConcurrentQueue:

            dispatchQueue = dispatch_queue_create(nil, DISPATCH_QUEUE_CONCURRENT)
            break

        case .None:

            dispatchQueue = nil
            break
        }
    }

    // MARK: 单例
    static let mainQueue : GCDQueue = {

        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_main_queue()

        return instance
        }()

    static let globalQueue : GCDQueue = {

        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, )

        return instance
        }()

    static let highPriorityGlobalQueue : GCDQueue = {

        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, )

        return instance
        }()

    static let lowPriorityGlobalQueue : GCDQueue = {

        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, )

        return instance
        }()

    static let backgroundPriorityGlobalQueue : GCDQueue = {

        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, )

        return instance
        }()

    // MARK: 执行

    /**
    Submits a block for asynchronous execution on a dispatch queue and returns immediately.

    - parameter block: dispatch block
    */
    func excute(block : dispatch_block_t) {

        dispatch_async(dispatchQueue, block)
    }

    func excute(block : dispatch_block_t, afterDelayWithNanoseconds : Int64) {

        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, afterDelayWithNanoseconds), dispatchQueue, block)
    }

    /**
    Submits a block object for execution on a dispatch queue and waits until that block completes.

    - parameter block: dispatch block
    */
    func waitExecute(block : dispatch_block_t) {

        dispatch_sync(dispatchQueue, block)
    }

    /**
    Submits a barrier block for asynchronous execution and returns immediately.

    - parameter block: dispatch block
    */
    func barrierExecute(block : dispatch_block_t) {

        dispatch_barrier_async(dispatchQueue, block)
    }

    /**
    Submits a barrier block object for execution and waits until that block completes.

    - parameter block: dispatch block
    */
    func waitBarrierExecute(block : dispatch_block_t) {

        dispatch_barrier_sync(dispatchQueue, block)
    }

    // MARK: 便利构造器方法
    class func executeInMainQueue(block : dispatch_block_t) {

        dispatch_async(mainQueue.dispatchQueue, block)
    }

    class func executeInGlobalQueue(block : dispatch_block_t) {

        dispatch_async(globalQueue.dispatchQueue, block)
    }

    class func executeInHighPriorityGlobalQueue(block : dispatch_block_t) {

        dispatch_async(highPriorityGlobalQueue.dispatchQueue, block)
    }

    class func executeInLowPriorityGlobalQueue(block : dispatch_block_t) {

        dispatch_async(lowPriorityGlobalQueue.dispatchQueue, block)
    }

    class func executeInBackgroundPriorityGlobalQueue(block : dispatch_block_t) {

        dispatch_async(backgroundPriorityGlobalQueue.dispatchQueue, block)
    }

    class func executeInMainQueue(block : dispatch_block_t, afterDelaySeconds : Double) {

        let delayTime : Int64 = Int64(afterDelaySeconds * Double(NSEC_PER_SEC))
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayTime), mainQueue.dispatchQueue, block)
    }

    class func executeInGlobalQueue(block : dispatch_block_t, afterDelaySeconds : Double) {

        let delayTime : Int64 = Int64(afterDelaySeconds * Double(NSEC_PER_SEC))
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayTime), globalQueue.dispatchQueue, block)
    }

    class func executeInHighPriorityGlobalQueue(block : dispatch_block_t, afterDelaySeconds : Double) {

        let delayTime : Int64 = Int64(afterDelaySeconds * Double(NSEC_PER_SEC))
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayTime), highPriorityGlobalQueue.dispatchQueue, block)
    }

    class func executeInLowPriorityGlobalQueue(block : dispatch_block_t, afterDelaySeconds : Double) {

        let delayTime : Int64 = Int64(afterDelaySeconds * Double(NSEC_PER_SEC))
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayTime), lowPriorityGlobalQueue.dispatchQueue, block)
    }

    class func executeInBackgroundPriorityGlobalQueue(block : dispatch_block_t, afterDelaySeconds : Double) {

        let delayTime : Int64 = Int64(afterDelaySeconds * Double(NSEC_PER_SEC))
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delayTime), backgroundPriorityGlobalQueue.dispatchQueue, block)
    }

    // MARK: 恢复与挂起
    func suspend() {

        dispatch_suspend(dispatchQueue)
    }

    func resume() {

        dispatch_resume(dispatchQueue)
    }

    // MARK: GCDGroup相关
    func excute(block : dispatch_block_t, inGroup : GCDGroup!) {

        dispatch_group_async(inGroup.dispatchGroup, dispatchQueue, block)
    }

    func notify(block : dispatch_block_t, inGroup : GCDGroup!) {

        dispatch_group_notify(inGroup.dispatchGroup, dispatchQueue, block)
    }
}

//
//  GCDGroup.swift
//  GCD
//
//  http://home.cnblogs.com/u/YouXianMing/
//  https://github.com/YouXianMing
//
//  Created by YouXianMing on 15/10/9.
//

import UIKit

class GCDGroup: NSObject {

    // MARK: 变量
    var dispatchGroup : dispatch_group_t!

    // MARK: 初始化
    override init() {

        super.init()
        dispatchGroup = dispatch_group_create()
    }

    // MARK: 操作
    func enter() {

        dispatch_group_enter(dispatchGroup)
    }

    func leave() {

        dispatch_group_leave(dispatchGroup)
    }

    func wait() {

        dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER)
    }

    func waitWithNanoseconds(nanoseconds : Int64) -> Bool {

        return dispatch_group_wait(dispatchGroup, dispatch_time(DISPATCH_TIME_NOW, nanoseconds)) ==
    }
}

//
//  GCDTimer.swift
//  GCD
//
//  http://home.cnblogs.com/u/YouXianMing/
//  https://github.com/YouXianMing
//
//  Created by YouXianMing on 15/10/9.
//

import UIKit

class GCDTimer: NSObject {

    // MARK: 变量
    var dispatchSource : dispatch_source_t!

    // MARK: 初始化
    override init() {

        super.init()
        dispatchSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, , , dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, ))
    }

    init(inQueue : GCDQueue) {

        super.init()
        self.dispatchSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, , , inQueue.dispatchQueue)
    }

    // MARK: 执行
    func event(block : dispatch_block_t, timeIntervalWithNanoseconds : UInt64) {

        dispatch_source_set_timer(dispatchSource, dispatch_time(DISPATCH_TIME_NOW, ), timeIntervalWithNanoseconds, )

        dispatch_source_set_event_handler(dispatchSource) { () -> Void in

            block()
        }
    }

    func event(block : dispatch_block_t, timeIntervalWithSeconds : Double) {

        let timeInterval : UInt64 = UInt64(timeIntervalWithSeconds * Double(NSEC_PER_SEC))
        dispatch_source_set_timer(dispatchSource, dispatch_time(DISPATCH_TIME_NOW, ), timeInterval, )
        dispatch_source_set_event_handler(dispatchSource) { () -> Void in

            block()
        }
    }

    func start() {

        dispatch_resume(dispatchSource)
    }

    func destroy() {

        dispatch_source_cancel(dispatchSource)
    }
}

//
//  GCDSemaphore.swift
//  GCD
//
//  http://home.cnblogs.com/u/YouXianMing/
//  https://github.com/YouXianMing
//
//  Created by YouXianMing on 15/10/9.
//

import UIKit

class GCDSemaphore: NSObject {

    // MARK: 变量
    var dispatchSemaphore : dispatch_semaphore_t!

    // MARK: 初始化
    override init() {

        super.init()
        dispatchSemaphore = dispatch_semaphore_create()
    }

    init(withValue : Int) {

        super.init()
        dispatchSemaphore = dispatch_semaphore_create(withValue)
    }

    // 执行
    func signal() -> Bool {

        return dispatch_semaphore_signal(dispatchSemaphore) !=
    }

    func wait() {

        dispatch_semaphore_wait(dispatchSemaphore, DISPATCH_TIME_FOREVER)
    }

    func wait(withNanoseconds : Int64) -> Bool {

        return dispatch_semaphore_wait(dispatchSemaphore, dispatch_time(DISPATCH_TIME_NOW, withNanoseconds)) ==
    }
}

//
//  ViewController.swift
//  GCD
//
//  Created by YouXianMing on 15/10/9.
//  Copyright © 2015年 YouXianMing. All rights reserved.
//

import UIKit

class ViewController: UIViewController {

    var queue     : GCDQueue!
    var group     : GCDGroup!
    var timer     : GCDTimer!
    var semaphore : GCDSemaphore!

    override func viewDidLoad() {

        super.viewDidLoad()

        timerUse()
    }

    // MARK: 各种用法

    /**
    普通用法
    */
    func normalUse() {

        GCDQueue.globalQueue.excute { () -> Void in

            // 子线程执行操作

            GCDQueue.mainQueue.excute({ () -> Void in

                // 主线程更新UI
            })
        }

        GCDQueue.executeInGlobalQueue { () -> Void in

            // 子线程执行操作

            GCDQueue.executeInMainQueue({ () -> Void in

                // 主线程更新UI
            })
        }
    }

    /**
    延时用法
    */
    func delayUse() {

        GCDQueue.executeInGlobalQueue({ () -> Void in

            // 延时 2s 执行

            }, afterDelaySeconds: )
    }

    func waitExecute() {

        queue = GCDQueue(queueType: .ConcurrentQueue)

        queue.waitExecute { () -> Void in

            print("")
            sleep()
        }

        queue.waitExecute { () -> Void in

            print("")
            sleep()
        }

        queue.waitExecute { () -> Void in

            print("")
            sleep()
        }

        queue.waitExecute { () -> Void in

            print("")
        }
    }

    /**
    设置屏障
    */
    func barrierExecute() {

        queue = GCDQueue(queueType: .ConcurrentQueue)

        queue.excute { () -> Void in

            print("")
        }

        queue.excute { () -> Void in

            print("")
        }

        queue.excute { () -> Void in

            print("")
            sleep()
        }

        queue.barrierExecute { () -> Void in

            print("barrierExecute")
        }

        queue.excute { () -> Void in

            print("")
        }

        queue.excute { () -> Void in

            print("")
        }

        queue.excute { () -> Void in

            print("")
        }
    }

    /**
    GCDGroup的使用
    */
    func groupUse() {

        group = GCDGroup()
        queue = GCDQueue()

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.excute({ () -> Void in

            print("")

            }, inGroup: group)

        queue.notify({ () -> Void in

            print("都完成了")

            }, inGroup: group)
    }

    /**
    GCDTimer的使用
    */
    func timerUse() {

        timer = GCDTimer(inQueue: GCDQueue.globalQueue)
        timer.event({ () -> Void in

            print("timer event")

            }, timeIntervalWithSeconds: )
        timer.start()
    }

    /**
    GCD信号量的使用
    */
    func semaphoreUse() {

        semaphore = GCDSemaphore()
        queue     = GCDQueue(queueType: .ConcurrentQueue)

        queue.excute { () -> Void in

            print("")
            self.semaphore.signal()
        }

        queue.excute { () -> Void in

            print("")
            self.semaphore.signal()
        }

        queue.excute { () -> Void in

            print("")
            self.semaphore.signal()
        }

        queue.excute { () -> Void in

            print("")
            self.semaphore.signal()
        }

        queue.excute { () -> Void in

            self.semaphore.wait()
            self.semaphore.wait()
            self.semaphore.wait()
            self.semaphore.wait()

            print("都完成了")
        }
    }
}

细节