Swift基础（十一）多线程

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 创建NSOperation的实例，并调用实例方法
        let operation = Operation();
        operation.createOperation();
        
        // Do any additional setup after loading the view, typically from a nib.
           // 多线程：实现单个应用程序内多个代码的执行路径。在每个应用程序的内部都会存在一个或多个执行线程，他同时或几乎在同一时间里执行不同的任务。Swift中并没有使用新一套线程，而是继续使用Objective-C原有的一套线程，包括3种多线程编程技术。
        // NSThread，轻量级最轻，但需要自己管理线程生命周期和线程同步。线程同步对数据的加锁会有一定的系统开销
        // Cocoa NSOperation（NSOperation和NSOperationQueue）
        // Cocoa NSOperation不需要关心线程管理和数据同步的事情，可以把精力放在自己需要执行的操作上。相关的类有NSOperation和NSOperationQueue。其中，NSOperation是个抽象类，使用它必须使用它的子类，可以实现它或者使用它定义好的两个子类：NSInvocationOperation和NSBlockOperation。创建NSOperation子类的对象，把对象添加到NSOperationQueue队列里执行。
        // Grand Central Dispatch（GCD）
        // GCD是Apple开发的一个多核编程的解决方法，在macOS 10.6雪豹中首次推出，并随后被引入到了iOS 4.0中。GCD是一个替代NSThread、NSOperationQueue、NSInvocationOperation等技术的一种高效强大的技术。其抽象度最高，使用简单，是Apple最推荐使用的。
        
        // NSThread的使用
        // 类方法
        NSThread.detachNewThreadSelector(#selector(ViewController.downloadImage), toTarget: self, withObject: nil);
        
        // 实例方法-便利构造器
        let myThread: NSThread = NSThread(target: self, selector: #selector(ViewController.downloadImage), object: nil);
        myThread.start();
        
        // 线程同步方法通过锁来实现，每个线程都只有一个锁，这个锁与一个特定的线程关联。下面的代码演示两个线程之间的同步
        // 定义两个线程
        var thread1: NSThread?
        var thread2: NSThread?
        
        // 定义两个线程条件，用于锁住线程：
        let condition1 = NSCondition();
        let condition2 = NSCondition();
        
        // 定义两个方法，用于两个线程调用：
        // 方法1
        func method1(sender : AnyObject) {
            for (var i = 0; i < 10; i++) {
                print("NSThread 1 running \(i)");
                sleep(1);
                
                if(i == 2) {
                    thread2!.start() // 启动线程2
                    
                    // 本线程（thread1）锁定
                    condition1.lock();
                    condition1.wait();
                    condition1.unlock();
                }
            }
            print("NSThread 1 over.")
            
            // 线程2激活
            condition2.signal()
        }
        
        // 方法2
        func method2(sender: AnyObject) {
            for (var i = 0; i < 10; i++) {
                print("NSThread 2 running \(i)")
                sleep(1);
                
                if(i == 2) {
                    // 线程1激活
                    condition1.signal();
                    
                    // 本线程（thread2）锁定
                    condition2.lock();
                    condition2.wait(); // 暂停线程，等待
                    condition2.unlock();
                }
            }
            
            print("NSThread 2 over")
        }
        
        // 两个线程实例化，并开启第一个线程
        thread2 = NSThread(target: self, selector: "method2:", object: nil)
        thread1 = NSThread(target: self, selector: "method1:", object: nil)
        thread1!.start();
        
    }
    
   
    func downloadImage() {
        var imageUrl = "http://www.iphonetrain.com/core/res/images/logo.png";
//        var data: NSData = NSData.dataWithContentsOfURL(NSURL.URLWithString(imageUrl)!, options: nil, error: nil)
//        print(data.length);
        

    }

}

NSOperation

class Operation {
    // 方法一：
    func createOperation() {
        // 创建一个NSInvocationOperation实例
//        var operation: NSInvocationOperation = NSInvocationOperation(target: self, selector: "downloadImage", object: nil); 这个语句会爆红，因为NSInvocationOperation类是Objective-C语言，不能再Swift中使用
        
        // 但是Swift中提供了NSBlockOperation类
        // 创建一个NSBlockOperation实例
        let operation: NSBlockOperation = NSBlockOperation();
        
        //创建一个NSOperationQueue实例
        var queue: NSOperationQueue = NSOperationQueue();
        
        // operation添加到queue队列中
        queue.addOperation(operation);
        
        queue.maxConcurrentOperationCount = 6;
        
        // 每个NSOperation完成都会有一个回调表示任务结束：
        // 定义一个回调
        var completionBlock: (() -> Void)?
        // operation设置回调
        operation.completionBlock = completionBlock;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 4), dispatch_get_main_queue(), {
            print("Complete")
        })
        
        // 创建线程对象
        var drinkOperation: DrinkOperation = DrinkOperation() // 创建喝水对象
        
        // 将线程对象加入到队列中
        queue.addOperation(drinkOperation)
        
        // 取消队列所有操作代码：
        queue.cancelAllOperations();
        
    }
    
    func BolckString() -> Void {
        
    }
}

// 方法2：继承NSOperation方式
// 创建一个类DrinkOperation，继承NSOperation，并实现main方法，
class DrinkOperation: NSOperation {
    
    override func main() {
        print("在这里喝水...")
    }
}

GCD
GCD实在是太多，博主了解的也不是太多，就不写了。

 // 往dispatch_get_global_queue队列中添加代码块，只执行一次
        var predicate: dispatch_once_t = 0;
        dispatch_once(&predicate, { () -> Void in
            // dispatch_once创建代码块，只执行一次，可用于创建单例
        })