这里包括了Queue, Group, Barrier, Semaphore等内容。基本上常用的GCD对象和方法在Swift3.0的改变都囊括其中。

代码在这里:https://github.com/future-challenger/Swift3.0/tree/master/GCD

This project is "forked" from raywenderlich GCD tutorial. It's really a good tutorial where I learned what I wanted. But it's kinda out of date. In Swift 3.0, lots of API in iOS SDK have been modified. Including how GCD APIs are called. So I update the tutorial to swift 3.0

Create a block

before:

      let block = dispatch_block_create(DISPATCH_BLOCK_INHERIT_QOS_CLASS) { // 3
// things to do in this block
}

swift 3.0

      let block = DispatchWorkItem{
let index = Int(i)
let address = addresses[index]
let url = URL(string: address)
let photo = DownloadPhoto(url: url!) {
image, error in
if let error = error {
storedError = error
}
downloadGroup.leave()
}
PhotoManager.sharedManager.addPhoto(photo)
}

Create a Queue

Concurrent Queue

before:

let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_CONCURRENT)

swift 3.0

let concurrentQueue = DispatchQueue(label: "com.swift3.imageQueue", attributes: .concurrent)
concurrentQueue.async {
print("async task")
}

Serial Queue

before:

let concurrentQueue = dispatch_queue_create("com.swift3.imageQueue", DISPATCH_QUEUE_SERIAL)

swift 3.0

let concurrentQueue = DispatchQueue(label: "com.swift3.imageQueue")
concurrentQueue.sync {
print("sync task")
}

Main Queue

dispatch_get_main_queue => DispatchQueue.main

Global Queue

dispatch_get_global_queue => DispatchQueue.global(qos:)

before:

dispatch_get_global_queue(Int(QOS_CLASS_USER_INTERACTIVE.value), 0)

Swift 3.0

DispatchQueue.global(qos: .userInteractive)

Here's a easy one. Before we always do things like this:

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
// do something background
dispatch_async(dispatch_get_main_queue(), ^{
// update UI in main thread(or UI thread)
});
});

In swift 3.0, we do it this way.

DispatchQueue.global(qos: .userInitiated).async {
// background things
DispatchQueue.main.async {
print("main thread dispatch")
}
}

Dispatch After & Once

Dispatch After

before you do dispatch after like this:

var dispatchTime: dispatch_time_t = dispatch_time(DISPATCH_TIME_NOW, Int64(0.1 * Double(NSEC_PER_SEC)))
dispatch_after(dispatchTime, dispatch_get_main_queue(), {
// your function here
})

In swift 3.0

let dispatchTime: DispatchTime = DispatchTime.now() + Double(Int64(0.1 * Double(NSEC_PER_SEC))) / Double(NSEC_PER_SEC)
DispatchQueue.main.asyncAfter(deadline: dispatchTime, execute: {
// your function here
})

or even more simply:

DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
// your function here
}

Disaptch Once

This dispatch_once on longer exists in Swift 3.0.

According to Apple's migration guide:

The free function dispatch_once is no longer available in Swift. In Swift, you can use lazily initialized globals or static properties and get the same thread-safety and called-once guarantees as dispatch_once provided.

You can use lazy initialized global or static properties instead of dispatch once. eg:

// global constant: SomeClass initializer gets called lazily, only on first use
let foo = SomeClass() // global var, same thing happens here
// even though the "initializer" is an immediately invoked closure
var bar: SomeClass = {
let b = SomeClass()
b.someProperty = "whatever"
b.doSomeStuff()
return b
}() // ditto for static properties in classes/structures/enums
class MyClass {
static let singleton = MyClass()
init() {
print("foo")
}
}

Dispatch Once Is Still Needed

Global var or static property can not meet our needs when we just need some code run once in app. And this code has a reference to self. Static property makes this not possible. Let's checkout some other ways to use "dispatch onde" in Swift 3.0.

It fits Singleton very well, but not the run-once thing.

The first one:

public extension DispatchQueue {
private static var _onceTracker = [String]() /**
Executes a block of code, associated with a unique token, only once. The code is thread safe and will
only execute the code once even in the presence of multithreaded calls. - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
- parameter block: Block to execute once
*/
public class func once(token: String, block:@noescape(Void)->Void) {
objc_sync_enter(self); defer { objc_sync_exit(self) } if _onceTracker.contains(token) {
return
} _onceTracker.append(token)
block()
}
}

How to use the once function:

DispatchQueue.once(token: "com.vectorform.test") {
print( "Do This Once!" )
}

or:

private let _onceToken = NSUUID().uuidString

DispatchQueue.once(token: _onceToken) {
print( "Do This Once!" )
}

NOTE: You have to use your own tracker to prevent your code run more than once.

Let's make some improvement:

public extension DispatchQueue {
private static var _onceTracker = [String]() public class func once(file: String = #file, function: String = #function, line: Int = #line, block:(Void)->Void) {
let token = file + ":" + function + ":" + String(line)
once(token: token, block: block)
} /**
Executes a block of code, associated with a unique token, only once. The code is thread safe and will
only execute the code once even in the presence of multithreaded calls. - parameter token: A unique reverse DNS style name such as com.vectorform.<name> or a GUID
- parameter block: Block to execute once
*/
public class func once(token: String, block:(Void)->Void) {
objc_sync_enter(self)
defer { objc_sync_exit(self) } if _onceTracker.contains(token) {
return
} _onceTracker.append(token)
block()
}
}

How to use it:

DispatchQueue.once {
setupUI()
}

or:

DispatchQueue.once(token: "com.me.project") {
setupUI()
}

You can use a string tracker, you also can use the default tracker.

But there's another way. You can define another name for dispatch_once in an ObjC file, and use it in swift 3.0 with the "Bridege Header" imported.

// in header
typedef dispatch_once_t mxcl_dispatch_once_t;
void mxcl_dispatch_once(mxcl_dispatch_once_t *predicate, dispatch_block_t block); // in source file
void mxcl_dispatch_once(mxcl_dispatch_once_t *predicate, dispatch_block_t block) {
dispatch_once(predicate, block);
}

You can use mxcl_dispatch_once in swift.

Create Dispatch Source

before:

    let queue = dispatch_get_main_queue()
self.signalSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL,
UInt(SIGSTOP), 0, queue) // 3
if let source = self.signalSource { // 4
dispatch_source_set_event_handler(source) { // 5
NSLog("Hi, I am: \(self.description)")
}
dispatch_resume(source) // 6
}

Swift 3.0:

    let queue = DispatchQueue.main
self.signalSource = DispatchSource.makeSignalSource(signal: 0, queue: queue) // 3
if let source = self.signalSource { // 4
source.setEventHandler(handler: { // 5
print("Hi, I am: \(self.description)")
})
source.resume() // 6
}

Dispatch Barrier

When you add things in a multithreaded enviroment, you have to prevent more than one thread try to add things in the same time. You can use Barrier to do this.

before:

  dispatch_barrier_async(currentQueue) { // NOTE: barrier, requires exclusive access for write
//...
}

Swift 3.0

    concurrentPhotoQueue.async(flags: .barrier, execute: { // 1
self._photos.append(photo) // 2
GlobalMainQueue.async { // 3
self.postContentAddedNotification()
}
})

Dispatch Group

How to create one:

var downloadGroup = dispatch_group_create()

Swift 3.0

let downloadGroup = DispatchGroup()

Sometimes we want to start a new queue when tasks running in other background queues all finished. Dispatch group help us with that. There're two ways to achieve this.

  1. dispatch_group_wait => DispatchGroup#wati
  2. dispatch_group_notify => DispatchGroup#notify

Let's see how they work.

You want dispatch group wait work, there're other tow methods you have to know: dispatch_group_enter, dispatch_group_leave. The enter method manually notify the group that a task has started. The leave method has to be called the same time as the enter method has called. Or you app may crash.

Dispatch Group Wait

// some unrelevant code is removed.
@IBAction func groupWaitAction(_ sender: AnyObject) {
let concurrentQueue = DispatchQueue(label: "com.gcd.demo.concurrent", attributes: .concurrent)
concurrentQueue.async {
let taskGroup = DispatchGroup()
for i in 0..<100 {
taskGroup.enter() print("###task \(i) \n")
Thread.sleep(forTimeInterval: 0.5) taskGroup.leave()
} taskGroup.wait() DispatchQueue.main.async {
print("It's on main queue now")
}
}
}

First of all, dispatch group in this example is run in a concurrent queue. I did not notice this in the beginning. And you should notice that the wait method would block all thread. If any of the tasks takes a lot of time, things will be bad. Fortunally, dispatch group can wait with a timeout parameter. If the time expires before all tasks are done, it will return a non-zero value. With dispatch group wait, you have to dispatch to another queue (mostly the main queue) manually.

Dispatch Group notify

  @IBAction func groupWaitAction(_ sender: AnyObject) {
let concurrentQueue = DispatchQueue(label: "com.gcd.demo.concurrent", attributes: .concurrent)
concurrentQueue.async {
let taskGroup = DispatchGroup()
for i in 0..<100 {
taskGroup.enter() print("###task \(i) \n")
Thread.sleep(forTimeInterval: 0.5) taskGroup.leave()
} taskGroup.notify(queue: DispatchQueue.main, work: DispatchWorkItem(block: {
print("It's on main queue now")
}))
}
}

The best way to use DispatchGroup is to send a group in a concurrent queue then wait or notifiy. @hen all things are done, dispatch to Main queue to update UI.

Dispatch Apply

Before Swift 3.0, there's a very good method to handle iterations. It's dispatch_apply. This method ia a sync method, not return until all tasks in its loop are done. But tasks in the method to iterate are executed concurrently. Now in swift 3.0, it got a new name: DispatchQueue.concurrentPerform.

It's always a good option to use DispatchQueue.concurrentPerform in a concurrent queue but not a good one in a serial queue.

But how to use DispatchQueue.concurrentPerform to improve the Dispatch Group Wait code? Let's give it a shot.

  @IBAction func dispatchApplyAction(_ sender: AnyObject) {
let concurrentQueue = DispatchQueue(label: "com.apply.gcd", attributes: .concurrent)
let taskGroup = DispatchGroup() concurrentQueue.async {
DispatchQueue.concurrentPerform(iterations: 50, execute: {index in
taskGroup.enter()
print(">>>task \(index) \n")
Thread.sleep(forTimeInterval: 0.5)
taskGroup.leave()
}) taskGroup.notify(queue: DispatchQueue.main, work: DispatchWorkItem(block: {
print(">>>It's on main queue now")
}))
}
}

Run DispatchQueue.concurrentPerform code in a background thread, this will not block the main thread while tasks are running. When all work is done, DispatchGroup wil use notify to update the UI thread.

Semaphore

  @IBAction func semaphoreAction(_ sender: AnyObject) {
let semaphore = DispatchSemaphore(value: 0) Thread.sleep(forTimeInterval: 1);
semaphore.signal() let returnVal = semaphore.wait(timeout: DispatchTime(uptimeNanoseconds: 800000000))
if (returnVal == .timedOut) {
print("%%%Semaphore timeout")
}
}

Here's how to create one, how to single it and wait until semaphore is available.

reference:

http://stackoverflow.com/questions/37801407/whither-dispatch-once-in-swift-3

http://stackoverflow.com/questions/37801436/how-do-i-write-dispatch-after-gcd-in-swift-3

http://stackoverflow.com/questions/37886994/dispatch-once-in-swift-3

GCD in Swfit 3.0的更多相关文章

  1. 浅入了解GCD 并发 并行 同步 异步 多线程

     什么是 GCD?! GCD就是一个函数库(废话) 用来压榨系统的资源,解决多线程处理中一些问题的库(知道这个就够了,很多电影角色都是因为知道太多死得很惨!!!!!) 1.并发与并行 Concurre ...

  2. 创建线程方式-GCD

    *:first-child { margin-top: 0 !important; } body > *:last-child { margin-bottom: 0 !important; } ...

  3. Swift 2.0初探

    转眼间,Swift已经一岁多了,这门新鲜.语法时尚.类型安全.执行速度更快的语言已经渐渐的深入广大开发者的心. 今年6月,一年一度的WWDC大会如期而至,在大会上Apple发布了Swift 2.0,引 ...

  4. (转载)关于gcd的8题

    发现其实有关gcd的题目还是挺多的,这里根据做题顺序写出8题. [bzoj2818: Gcd] gcd(x,y)=质数, 1<=x,y<=n的对数 做这题的时候,懂得了一个非常重要的转化: ...

  5. iOS开发——新特性OC篇&Swift 2.0新特性

    Swift 2.0新特性     转眼间,Swift已经一岁多了,这门新鲜.语法时尚.类型安全.执行速度更快的语言已经渐渐的深入广大开发者的心.我同样也是非常喜爱这门新的编程语言. 今年6月,一年一度 ...

  6. Zoj 3868 GCD Expectation

    给一个集合,大小为n , 求所有子集的gcd 的期望和 . 期望的定义为 这个子集的最大公约数的K次方 : 每个元素被选中的概率是等可能的 即概率 p = (发生的事件数)/(总的事件数); 总的事件 ...

  7. Swift 2.0初探:值得注意的新特性

    转眼间,Swift已经一岁多了,这门新鲜.语法时尚.类型安全.执行速度更快的语言已经渐渐的深入广大开发者的心.我同样也是非常喜爱这门新的编程语言. 今年6月,一年一度的WWDC大会如期而至,在大会上A ...

  8. hdu1695 GCD

    http://acm.hdu.edu.cn/showproblem.php?pid=16951 /** 大意: a<=x<=b , c<= y <= d ,求在此范围内 有多少 ...

  9. Revenge of GCD HDU5019

    Description In mathematics, the greatest common divisor (gcd), also known as the greatest common fac ...

随机推荐

  1. hbase scan 的例子

    /** * Created by han on 2016/1/28. */ import org.apache.hadoop.conf.Configuration; import org.apache ...

  2. 抢凳子日数据sql

    --先找到档期select * from hv_item_info a where a.report_begdate > '2016-07-28' and a.report_begdate &l ...

  3. java查看当前项目所有线程列表界面

    java查看当前项目所有线程列表界面 1.TestThread(测试类) package com.isoftstone.pcis.isc.job.king.panel; public class Te ...

  4. char类型输出地址

    问题描述: 当输出char的地址时,发现输出的是一个字符: char ch = 'a'; cout<<&ch<<endl;//a @ 因为cout得到一个char类型的 ...

  5. Flash Builder 调试器无法连接到正在运行的应用程序(57%)

    Flash Builder 调试器无法连接到正在运行的应用程序(57%),可能原因:     1,flashplayer不是debug版.     2,调试器(用debug版flashplayer随便 ...

  6. jQuery Mobile 网格布局

    jQuery Mobile 布局网格 jQuery Mobile 提供了一套基于 CSS 的列布局方案.不过,一般不推荐在移动设备上使用列布局,这是由于移动设备的屏幕宽度所限. 但是有时你需要定位更小 ...

  7. 转:HIBERNATE一些_方法_@注解_代码示例---写的非常好

    HIBERNATE一些_方法_@注解_代码示例操作数据库7步骤 : 1 创建一个SessionFactory对象 2 创建Session对象 3 开启事务Transaction : hibernate ...

  8. Python编写邮件群发(qq邮箱)

    #电子邮件操作 import poplib import smtplib from email.header import decode_header from email.mime.text imp ...

  9. CyclicBarrier在多线程同步运行后相互访问的问题。

    CyclicBarrier的介绍 一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point).在涉及一组固定大小的线程的程序中,这些线程必须不时地互相 ...

  10. 第三章 springboot + jedisCluster(转载)

    本编博客转发自:http://www.cnblogs.com/java-zhao/p/5347703.html 如果使用的是redis2.x,在项目中使用客户端分片(Shard)机制. 如果使用的是r ...