多线程   是一个应用程序内多个代码的执行路径，执行线程，同时在同一时间里执行不同的任务。

三种：

1、NSTread

2、Cocoa NSOperation (NSOperation,NSOperationQueue)

3、GrandCentralDispatch:GCD

1\NSTread

相对最简单，需要自己管理线程的生命周期和线程同步（加锁会有一定的系统开销）

两种应用方式：

需要传递三个参数：

selector:线程执行方法""

target:方法所在的对象

argument:传递给方法的参数，可选nil

一、直接创建线程，自动运行线程

// Class Method

class func detachNewThreadSelector(selector:Selector,toTarget target:AnyObject,withObject argument:AnyObject?)

二、先创建一个线程对象，手动运行线程，在运行之前可设置线程优先级等信息。

convenience init(target:AnyObject,selector:Selector,object argument:AnyObject?)

for example

// download image method

func downloadImage()

{

var imageUrl = "https://www.baidu.com/img/bdlogo.png"

var data = NSData.dataWithContentsOfURL(NSURL.URLWithString(imageUrl),options:nil,error:nil)

println(data.length)

}

override func viewDidLoad(){

super.viewDidLoad()

// 第一种方式

NSThread.detachNewThreadSelector("downloadImage",toTarget:self,withObject:nil)

// 第二种方式

var downloadImageThread = NSThread(target:self,selector:"downloadImage",object:nil)

dowloadImageThread.start()

}

线程同步，通过锁来实现，每个线程有一个锁，锁 与 特定的线程关联。

for example

// 定义两个线程

var thread1,thread2:NSThread?

// 线程条件

let condition1 = NSCodition()

let condition2 = NSCodition()

// two method for thread 

func method1（sender: AnyObject）

{

　　for var i = 0; i <10; i++

　　{

　　println("thread 1 running \(i)")

　　sleep(1)

　　if i == 2

　　{

　　thread2!.start()

// lock

condition1.lock()

condition1.wait()

condition1.unlock()

　　}

　　}

println(thread 1 over)

//

condition2.signal()

}

// 

func method2(sender:AnyObject)

{

　　for var i=0;i<10;i++

　　{

　　println("thread 2 running \(i)")

　　sleep(1)

　　if i ==2

　　{

//  active thread 1

　　condition1.signal()

// lock 

condition2.lock()

condition2.wait()// stop waitting

condition2.unlock()

　　}

　　}

println("thread 2 over")

}

// RUN

thread2 = NSThread (target:self , selector:"method2:",object:nil)

thread1 = NSThread(target:self,selector:"method1",object:nil)

控制台输出

thread 1 running 0

thread 1 running 1

thread 1 running 2

thread 2 running 0

thread 2 running 1

thread 2 running 2

thread 1 running 3

thread 1 running 4

thread 1 running 5

thread 1 running 6

thread 1 running 7

thread 1 running 8

thread 1 running 9

thread 1 over

thread 2 running 3

thread 2 running 4

thread 2 running 5

thread 2 running 6

thread 2 running 7

thread 2 running 8

thread 2 running 9

线程1 2是同步关系，启动2，挂起 1，激活1，挂起2，有效避免了线程1占用一个资源时，引起线程2不能访问的问题。

NSOperation 两种方式

一  两个子类 NSInvocationOperation   NSBlockOperation

// creat instance

var operation = NSInvocationOperation(target:self,selector:"dowloadImage",object:nil)

var queue = NSOperationQueue()

queue.addOperation(operation)

后台建立一个线程

Queue队列中可以加入很多个operation 可以把它看做是一个线程池子，可以设置线程池中的线程数，即并发操作数。

默认是：-1，-1表示没有限制，同时运行队列中的全部操作。

queue.maxConcurrentOperationCount = 6

// ervery operation come to an end   

var completionBlock:(()->Void)?

operation.completionBlock = completionBlock

dispatch_after(dispatch_time(DISPATCH_TIME_NOW,4),dispatch_get_main_queue(),{println("complete")})

// cancell

queue.cancelAllOperations()

二  继承NSOperation   把子类的对象放到NSOperationQueue队列中 ，一旦加入，就处理这个，直到操作完成，队列被释放。

// creat DrinkOperation.swift 继承 NSOperation   且  实现main方法   

import UIKit

class DrinkOperation:NSOperation{

　　override func main()

　　{

　　println("drink")

　　}

} 

// e.g.

// creat a  instance

var queue1 = NSOperationQueue()

// creat a operation

var drinkOperation = DrinkOperation()

// add 

queue1.addOperation(drinkOperation)

Grand Central Dispatch

多核编程

底层也是用线程实现，queue可以接受任务，先到先执行顺序来执行，也可以并发或串行执行。

同步或异步

优点多多：基于C，融入面向对象，Block,易用，性能上自动根据系统负载来增减线程数量，无需加锁。

三种方法：

一 自己创建队列

func dispatch_queue_create(label:UnsafePointer<Int8>,attr:dispation_queue_attr_t!)->dispatch_queue_t!

label:参数代表队列名称，可以任意名

DISPATCH_QUEUE_CONCURRENT  并行

DISPATCH_QUEUE_SERIAL 串行  

//e.g.

var serialQueue = dispatch_queue_create("serialQueue_1",DISPATCH_QUEUE_SERIAL)

var concurrentQueue = dispatch_queue_create("concurrentQueue_1",DISPATCH_QUEUE_CONCURRENT)

二  获取系统的全局队列

func dispatch_get_global_queue(identifier:Int,flags:UInt)->dispatch_gueue_t!

参数 identifier   执行优先级  ，4个优先级

DISPATCH_QUEUE_PRIORITY_HIGH

DISPATCH_QUEUE_PRIORITY_DEFAULT

DISPATCH_QUEUE_PRIORITY_LOW

DISPATCH_QUEUE_PRIORITY_BACKGROUND    非常低的有相机，用于不太关心的后台任务

// e.g.

var globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

三 在主线程的Main dispatch queue

在主线程里执行的队列（只有一个主线程）

一切跟UI相关的操作都放到主线程中执行

func dispatch_get_main_queue()->dispatch_queue_t!

// e.g.

var mainQueue = dispatch_get_main_queue()

追加任务到队里的  两个方法：
一 dispatch_async  异步追加Block

async = asynchronous 异步

func dispatch_async(queue:dispatch_queue_t!,block:dispatch_block_t!)

第一个参数：GCD队列
第二个参数：block

// e.g.

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),{()->Void in

//  耗时代码块

//执行完  调用主线程刷新界面

dispatch_async(dispatch_get_main_queue(),{()->Void in

//通知主线程刷新

})

})

二 dispatch_sync 同步追加Block

与之前相反，block结束之前，dispatch_sync会一直等待，等待队列前面的所有任务完成后才执行追加的任务。

func dispatch_sync()

// e.g.

dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),{()->Void in

println("sync1")

})

加到 global_queue异步队列中，不会造成锁死，但会一直等待代码执行完毕。

如果加到main_queue中，在主线程中添加任务操作，就会引起死锁。

// e.g.

dispatch_sync(dispatch_get_main_queue(),{()->Void in

print("sync2")

})

暂停和继续执行队列

func  dispatch_suspend() 暂停

func dispatch_resume() 继续

suspend  使 suspension reference count +1

resume    -1

count>0  queue就保持挂起状态

如果挂起了  一个 queue   或者  source    那么销毁他之前，先对其进行恢复。

var concurrentQueue = dispatch_queue_create("concurrentQueue_1",DISPATCH_QUEUE_CONCURRENT)

// stop

dispatch_suspend(concurrentQueue)

// go on

dispatch_resume(concurrentQueue)

只执行一次 用于单例

dispatch_once

延时:指定时间后把任务追加到 dispatch queue里面

dispatch_after

func dispatch_time(when:XX,delta:Int64)->dispatch_time_t

delta单位非常小，到秒要乘以  NSEC_PER_SEC

let deltaT = 2.0 *Double(NSEC_PER_SEC)

let  dTime =dispatch_time(DISPATCH_TIME_NOW,Int64(deltaT))

dispatch_after(dTime,dispatch_get_global-global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

{()->Viod in

println("延时2秒执行")

})

多个任务都结束的一个全部结束：dispatch_barrier_async

当执行任务更新数据时，会出现数据不一样的情况。

for i in 1...100

{

dispatch_async(queue,{()->Void in

println("\(i)")

})

}

虽然使用dispatch_barrier_async可以避免

但是有另一方法，  semaphore 信号量

var semaphore = dispatch_semaphore_creat(1)//初始值为1

for i in 1...100

{

dispatch_async(queue,{()->Void in

dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER)

println("\(i)")

dispatch_semaphore_signal(semaphore)

})

}