swift版的GCD封装

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› 移动开发›Swift 教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

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, 0)
        
        return instance
        }()
    
    static let highPriorityGlobalQueue : GCDQueue = {
        
        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0)
        
        return instance
        }()
    
    static let lowPriorityGlobalQueue : GCDQueue = {
        
        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0)
        
        return instance
        }()
    
    static let backgroundPriorityGlobalQueue : GCDQueue = {
        
        let instance           = GCDQueue(queueType: .None)
        instance.dispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0)
        
        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)) == 0
    }
}

//
//  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, 0, 0, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0))
    }
    
    init(inQueue : GCDQueue) {
        
        super.init()
        self.dispatchSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, inQueue.dispatchQueue)
    }
    
    // MARK: 执行
    func event(block : dispatch_block_t, timeIntervalWithNanoseconds : UInt64) {
    
        dispatch_source_set_timer(dispatchSource, dispatch_time(DISPATCH_TIME_NOW, 0), timeIntervalWithNanoseconds, 0)
        
        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, 0), timeInterval, 0)
        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(0)
    }
    
    init(withValue : Int) {
        
        super.init()
        dispatchSemaphore = dispatch_semaphore_create(withValue)
    }
    
    // 执行
    func signal() -> Bool {
    
        return dispatch_semaphore_signal(dispatchSemaphore) != 0
    }
    
    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)) == 0
    }
}

//
//  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: 2)
    }
    
    func waitExecute() {
        
        queue = GCDQueue(queueType: .ConcurrentQueue)
        
        queue.waitExecute { () -> Void in
            
            print("1")
            sleep(1)
        }
        
        queue.waitExecute { () -> Void in
            
            print("2")
            sleep(1)
        }
        
        queue.waitExecute { () -> Void in
            
            print("3")
            sleep(1)
        }
        
        queue.waitExecute { () -> Void in
            
            print("4")
        }
    }
    
    /**
    设置屏障
    */
    func barrierExecute() {
        
        queue = GCDQueue(queueType: .ConcurrentQueue)
        
        queue.excute { () -> Void in
            
            print("1")
        }
        
        queue.excute { () -> Void in
            
            print("2")
        }
        
        queue.excute { () -> Void in
            
            print("3")
            sleep(1)
        }
        
        queue.barrierExecute { () -> Void in
            
            print("barrierExecute")
        }
        
        queue.excute { () -> Void in
            
            print("4")
        }
        
        queue.excute { () -> Void in
            
            print("5")
        }
        
        queue.excute { () -> Void in
            
            print("6")
        }
    }
    
    /**
    GCDGroup的使用
    */
    func groupUse() {
        
        group = GCDGroup()
        queue = GCDQueue()
        
        queue.excute({ () -> Void in
            
            print("1")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("2")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("3")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("4")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("5")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("6")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("7")
            
            }, inGroup: group)
        
        queue.excute({ () -> Void in
            
            print("8")
            
            }, 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: 1)
        timer.start()
    }
    
    /**
    GCD信号量的使用
    */
    func semaphoreUse() {
        
        semaphore = GCDSemaphore()
        queue     = GCDQueue(queueType: .ConcurrentQueue)
        
        queue.excute { () -> Void in
            
            print("1")
            self.semaphore.signal()
        }
        
        queue.excute { () -> Void in
            
            print("2")
            self.semaphore.signal()
        }
        
        queue.excute { () -> Void in
            
            print("3")
            self.semaphore.signal()
        }
        
        queue.excute { () -> Void in
            
            print("4")
            self.semaphore.signal()
        }
        
        queue.excute { () -> Void in
            
            self.semaphore.wait()
            self.semaphore.wait()
            self.semaphore.wait()
            self.semaphore.wait()
            
            print("都完成了")
        }
    }
}