2，本文着重介绍Cocoa NSOperation
Cocoa NSOperation不需要关心线程管理和数据同步的事情，可以把精力放在自己需要执行的操作上。相关的类有NSOperation和NSOperationQueue。其中NSOperation是个抽象类，使用它必须用它的子类，可以实现它或者使用它定义好的子类：NSBlockOperation。创建NSOperation子类的对象，把对象添加到NSOperationQueue队列里执行。
3，使用NSOperation的两种方式
（1）直接用定义好的子类：NSBlockOperation。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
import
UIKit
class
ViewController
:
UIViewController
{
override
func
viewDidLoad() {
super
.viewDidLoad()
var
operation:
NSBlockOperation
=
NSBlockOperation
(block: { [
weak
self
]
in
?.downloadImage()
return
})
queue:
NSOperationQueue
=
NSOperationQueue
()
queue.addOperation(operation)
}
//定义一个下载图片的方法，线程调用
downloadImage(){
imageUrl =
"http://hangge.com/blog/images/logo.png"
data =
NSData
(contentsOfURL:
NSURL
nil
)
println
(data?.length)
}
didReceiveMemoryWarning() {
.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
|
（2）继承NSOperation
然后把NSOperation子类的对象放入NSOperationQueue队列中，一旦这个对象被加入到队列，队列就开始处理这个对象，直到这个对象的所有操作完成，然后它被队列释放。
26
| //创建线程对象
downloadImageOperation:
DownloadImageOperation
()
//创建一个NSOperationQueue实例并添加operation
()
queue.addOperation(downloadImageOperation)
}
didReceiveMemoryWarning() {
.didReceiveMemoryWarning()
}
}
NSOperation
{
main(){
"http://hangge.com/blog/images/logo.png"
data =
NSData
(contentsOfURL:
NSURL
)
(data?.length)
}
}
|
4，设置运行队列并发数
NSOperationQueue队列里可以加入很多个NSOperation，可以把NSOperationQueue看做一个线程池，可往线程池中添加操作（NSOperation）到队列中。
可以设置线程池中的线程数，也就是并发操作数。默认情况下是-1，-1表示没有限制，这样可以同时运行队列中的全部操作。
2
|
queue.maxConcurrentOperationCount = 5
|
5，取消队列所有操作
//取消所有线程操作
queue.cancelAllOperations()
6，每个NSOperation完成都会有一个回调表示任务结束
7
| //定义一个回调
completionBlock:(() ->
Void
)?
//给operation设置回调
operation.completionBlock = completionBlock
dispatch_after(dispatch_time(
DISPATCH_TIME_NOW
(
"Complete"
)
})
|
2，本文着重介绍Grand Central Dispath（GCD）
GCD是Apple开发的一个多核编程的解决方法，基本概念就是dispatch queue（调度队列），queue是一个对象，它可以接受任务，并将任务以先到先执行的顺序来执行。dispatch queue可以是并发的或串行的。GCD的底层依然是用线程实现，不过我们可以不用关注实现的细节。其优点有如下几点：
（1）易用：GCD比thread更简单易用。基于block的特效使它能极为简单地在不同代码作用域之间传递上下文。
（2）效率：GCD实现功能轻量，优雅，使得它在很多地方比专门创建消耗资源的线程更加实用且快捷。
（3）性能：GCD自动根据系统负载来增减线程数量，从而减少了上下文切换并增加了计算效率。
（4）安全：无需加锁或其他同步机制。
3，GCD三种创建队列的方法
（1）自己创建一个队列
第一个参数代表队列的名称，可以任意起名
第二个参数代表队列属于串行还是并行执行任务
串行队列一次只执行一个任务。一般用于按顺序同步访问，但我们可以创建任意数量的串行队列，各个串行队列之间是并发的。
并行队列的执行顺序与其加入队列的顺序相同。可以并发执行多个任务，但是执行完成的顺序是随机的。
5
| //创建串行队列
serial:dispatch_queue_t = dispatch_queue_create(
"serialQueue1"
DISPATCH_QUEUE_SERIAL
)
//创建并行队列
concurrent:dispatch_queue_t = dispatch_queue_create(
"concurrentQueue1"
DISPATCH_QUEUE_CONCURRENT
)
|
（2）获取系统存在的全局队列
Global Dispatch Queue有4个执行优先级：
DISPATCH_QUEUE_PRIORITY_HIGH 高
DISPATCH_QUEUE_PRIORITY_DEFAULT 正常
DISPATCH_QUEUE_PRIORITY_LOW 低
DISPATCH_QUEUE_PRIORITY_BACKGROUND 非常低的优先级（这个优先级只用于不太关心完成时间的真正的后台任务）
1
globalQueue:dispatch_queue_t = dispatch_get_global_queue(
DISPATCH_QUEUE_PRIORITY_DEFAULT
（3）运行在主线程的Main Dispatch Queue
正如名称中的Main一样，这是在主线程里执行的队列。应为主线程只有一个，所有这自然是串行队列。一起跟UI有关的操作必须放在主线程中执行。
|
1
|
var
mainQueue:dispatch_queue_t = dispatch_get_main_queue()
|
4，添加任务到队列的两种方法
（1）dispatch_async异步追加Block块（dispatch_async函数不做任何等待）
1
2
3
4
5
6
7
8
9
10
dispatch_async(dispatch_get_global_queue(
DISPATCH_QUEUE_PRIORITY_DEFAULT
Void
in
println
(
"do work"
)
//操作完成，调用主线程来刷新界面
dispatch_async(dispatch_get_main_queue(),153)!important; background:none!important">in
"main refresh"
)
})
})
|
（2）dispatch_sync同步追加Block块
同步追加Block块，与上面相反。在追加Block结束之前，dispatch_sync函数会一直等待，等待队列前面的所有任务完成后才能执行追加的任务。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
//不会造成死锁，当会一直等待代码块执行完毕
dispatch_sync(dispatch_get_global_queue(
DISPATCH_QUEUE_PRIORITY_DEFAULT
Void
in
println
(
"sync1"
)
})
"end1"
)
//添加同步代码块到dispatch_get_main_queue队列
//会引起死锁
//因为在主线程里面添加一个任务，因为是同步，所以要等添加的任务执行完毕后才能继续走下去。但是新添加的任务排在
//队列的末尾，要执行完成必须等前面的任务执行完成，由此又回到了第一步，程序卡死
dispatch_sync(dispatch_get_main_queue(),{ () ->
Void
in
"sync2"
)
})
"end2"
)
|
这两个函数是异步的，而且只在不同的blocks之间生效，对已经正在执行的任务没有影响。
dispatch_suspend后，追加到Dispatch Queue中尚未执行的任务在此之后停止执行。
而dispatch_resume则使得这些任务能够继续执行。
6
| //创建并行队列
conQueue:dispatch_queue_t = dispatch_queue_create(
"concurrentQueue1"
DISPATCH_QUEUE_CONCURRENT
)
//暂停一个队列
dispatch_suspend(conQueue)
//继续队列
dispatch_resume(conQueue)
|
6，dispatch_once 一次执行
保证dispatch_once中的代码块在应用程序里面只执行一次，无论是不是多线程。因此其可以用来实现单例模式，安全，简洁，方便。
//往dispatch_get_global_queue队列中添加代码块，只执行一次
predicate:dispatch_once_t = 0
dispatch_once(&predicate,{ () ->
Void
in
//只执行一次，可用于创建单例
"work"
)
})
7，dispatch_after 延迟调用
dispatch_after并不是在指定时间后执行任务处理，而是在指定时间后把任务追加到Dispatch Queue里面。因此会有少许延迟。注意，我们不能（直接）取消我们已经提交到dispatch_after里的代码。
//延时2秒执行
let
delta = 2.0 *
Double
(
NSEC_PER_SEC
dtime = dispatch_time(
DISPATCH_TIME_NOW
Int64
(delta))
dispatch_after(dtime,dispatch_get_global_queue(
in
"延时2秒执行"
}
8，多个任务全部结束后做一个全部结束的处理
dispatch_group_async：用来监视一组block对象的完成，你可以同步或异步地监视
dispatch_group_notify：用来汇总结果，所有任务结束汇总，不阻塞当前线程
dispatch_group_wait：等待直到所有任务执行结束，中途不能取消，阻塞当前线程
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//获取系统存在的全局队列
queue:dispatch_queue_t = dispatch_get_global_queue(
//定义一个group
group:dispatch_group_t = dispatch_group_create()
//并发任务，顺序执行
dispatch_group_async(group,queue,{() ->
in
"block1"
)
})
in
"block2"
)
})
in
"block3"
)
})
//所有任务执行结束汇总，不阻塞当前线程
dispatch_group_notify(group,153)!important; background:none!important">in
"group done"
)
})
//永久等待，直到所有任务执行结束，中途不能取消，阻塞当前线程
result = dispatch_group_wait(group,147)!important; background:none!important">DISPATCH_TIME_FOREVER
)
if
result == 0{
"任务全部执行完成"
)
}
else
{
"某个任务还在执行"
)
}
|
8，dipatch_apply 指定次数的Block最加到指定队列中
dipatch_apply函数是dispatch_sync函数和Dispatch Group的关联API。按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束。
因为dispatch_apply函数也与dispatch_sync函数一样，会等待处理结束，因此推荐在dispatch_async函数中异步执行dispatch_apply函数。dispatch_apply函数可以实现高性能的循环迭代。
16
|
//定义一个一步代码块
dispatch_async(queue,153)!important; background:none!important">in
//通过dispatch_apply，循环变量数组
dispatch_apply(6,{(index) ->
in
(index)
})
//执行完毕，主线程更新
in
"done"
)
})
})
|
9，信号，信号量
dispatch_semaphore_create：用于创建信号量，可以指定初始化信号量计数值，这里我们默认1.
dispatch_semaphore_waite：会判断信号量，如果为1，则往下执行。如果是0，则等待。
dispatch_semaphore_signal：代表运行结束，信号量加1，有等待的任务这个时候才会继续执行。
24
| //当并行执行的任务更新数据时，会产生数据不一样的情况
for
i
in
1...20
{
"(i)"
}
//使用信号量保证正确性
//创建一个初始计数值为1的信号
semaphore:dispatch_semaphore_t = dispatch_semaphore_create(1)
1...20
{
//永久等待，直到Dispatch Semaphore的计数值 >= 1
dispatch_semaphore_wait(semaphore,monospace!important; min-height:auto!important; background:none!important">)
)
//发信号，使原来的信号计数值+1
dispatch_semaphore_signal(semaphore)
})
}
|
原文出自：
www.hangge.com
转载请保留原文链接：
http://www.hangge.com/blog/cache/detail_745.html （编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
|
