GCD方式的多线程

GCD方式的多线程

概念讲解

//MARK: － 两个概念:
//1.任务: 想要执行的操作(想要做的事情)
//2.队列: 用来存储任务的容器(先进先出)

//GCD的使用步骤:
//1.创建队列(需要确定队列的类型)
//2.创建任务，并且将任务添加到队列中.(确定任务的执行方式)
//GCD会自动将任务从队列中取出，放到对应的线程中去执行

//MARK: － 四个术语
//任务的执行方式:
//1.同步:在当前线程中执行(不会去创建新的线程)，需要马上执行任务
//2.异步:在另外一个线程中执行(会创建新的线程)

//队列的类型:
//1.并发:队列中的任务可以同时执行(前提是能有多个线程)
//2.串行:队列中的任务一个一个顺序执行

class ViewController: UIViewController {

    @IBOutlet weak var imageView: UIImageView!
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        //self.test1()
        self.test9()
    }
    
    
    //MARK: - 队列组
    //队列组的作用,解决问题:想要让多个任务同时执行，然后所有的任务全部执行结束才回到主线程
    func test9() {
        
        //1.创建队列组
        let group = dispatch_group_create()
        
        //2.将任务添加到队列中，然后将队列添加到队列组
        //参数1:组
        //参数2:队列
        //参数3:任务
        dispatch_group_async(group, dispatch_get_global_queue(0, 0)) { () -> Void in
            
            NSThread.sleepForTimeInterval(2)
            print("下载图片A")
           
        }
         dispatch_group_async(group, dispatch_get_global_queue(0, 0)) { () -> Void in
            NSThread.sleepForTimeInterval(2)
            print("下载图片B")
        }
        //3.当group的队列中的所有的任务都执行完成后再回到主队列
        //在指定组中的任务都完成以后，去执行指定队列中的指定任务
        //参数1:指定的队列组
        //参数2:指定队列
        //参数3:指定的任务
        dispatch_group_notify(group, dispatch_get_main_queue()) { () -> Void in
            
            print(NSThread.currentThread())
            print("回到主线程")
        }
    }
    
    
    
    //MARK: －!!! 线程间通信
    func test8() {
        
        //在子线程中去下载图片
        dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
            print("下载：\(NSThread.currentThread())")
            //下载图片
            let path = "http://i1.073img.com/160509/4230327_100603_1_lit.jpg"
            let url = NSURL.init(string: path)
            let data = NSData.init(contentsOfURL: url!)
            let image = UIImage.init(data: data!)
            
            //回到主线程中将图片显示出来(拿到主队列)
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                
                print("显示:\(NSThread.currentThread())")
                self.imageView.image = image
            })
        }
    }
    
    
    //MARK: - 主队列
    //主队列是在ios程序启动成功后系统自动创建的一个和主线程关联的队列.在主队列中的任务都是在主线程中执行的。
    
    //2.同步执行主队列中的任务
    //结果:死锁
    func test7() {
        
        for item in 0...10 {
            
            dispatch_sync(dispatch_get_main_queue(), { () -> Void in
                self.operationAction(item)
                
            })
        }
    }
    
    
    //1.异步执行主队列中的任务
    //结果: 在主线程中按顺序执行
    func test6() {
        
        //1.拿到主队列
        let queue = dispatch_get_main_queue()
        //2.异步执行
        for item in 0...10 {
            
            dispatch_async(queue, { () -> Void in
                self.operationAction(item)
            })
        }
    }
    
    
    
    //MARK: - 全局队列
    //在ios进程中，系统会自动创建一个全局队列，这个对列是并发的。目的是方便程序员快速的创建一个并发队列
    //全局队列:就是系统自动创建的一个并发队列，在使用的时候只需要获取这个队列
    //1.异步执行全局队列中的任务
    //结果:多个线程同时执行多个任务
    func test5() {
        
        //1.获取全局队列(在整个进程中只有一个)
        //参数1:优先级(不设置)
        //参数2:预留参数
        let queue = dispatch_get_global_queue(0, 0)
        //将任务添加到全局队列中，异步执行
        for item in 0...10 {
            
            dispatch_async(queue, { () -> Void in
                self.operationAction(item)
            })
        }
        print("结束")
    }
    
    
    //MARK: - 基本运用
    
    
    //4.异步并行
    //异步:在另外的线程中执行
    //并发:多个任务同时执行
    //结果:多个线程中，多个任务同时执行
    
    func test4() {
        
        //1.创建并发队列
        let queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT)
        //2.将任务添加到队列中，异步执行
        for item in 0...10 {
            
            dispatch_async(queue, { () -> Void in
                self.operationAction(item)
            })
        }
        print("结束")
    }
    
    //3.异步串行
    //异步:在另外的线程中执行
    //串行:按顺序一个一个的执行
    //结果:在一个子线程中按顺序一个一个的执行，先打印"结束"，再执行任务
    
    func test3() {
        //1.创建串行队列
        let queue = dispatch_queue_create("", DISPATCH_QUEUE_SERIAL)
        //2.将任务添加到队列中，异步执行
        for item in 0...10 {
            
            dispatch_async(queue, { () -> Void in
                self.operationAction(item)
            })
        }
        print("结束")
    }
    
    
    
    
    
    //2.同步并行
    //同步:在当前线程中执行（不会开新的线程）
    //并行:多个任务同时执行（前提：的有多个线程）
    //结果:在主线程中，按顺序一个一个的执行;先执行任务再打印的"结束"
    func test2() {
        
        //1. 创建并行对列
        //DISPATCH_QUEUE_CONCURRENT ->并行
        let queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT)
        //2.将任务添加到队列中，同步执行
        for item in 0...10 {
            
            dispatch_sync(queue, { () -> Void in
                self.operationAction(item)
            })
        }
        print("结束")
    }
    
    //1.同步串行
    //同步:在当前线程中执行
    //串行:一个一个按顺序执行
    //结果:在主线程中按顺序执行;先执行任务再打印的"结束"
   
    func test1() {
        //1.创建队列变量
        //参数1:队列的标签，用来区分不同的队列;(c字符串类型)
        //参数2:队列属性(类型)，要么是串行要么是并行
        //DISPATCH_QUEUE_SERIAL -> 串行
        let queue = dispatch_queue_create("", DISPATCH_QUEUE_SERIAL)
        //2.将指定的任务添加到指定的队列中，并且确定任务的执行方式是同步执行
        //参数1:指定的队列
        //参数2:指定的任务
        dispatch_sync(queue) { () -> Void in
            self.operationAction(0)
        }
        
        //3.在队列中添加多个任务
        for item in 1...10 {
            
            dispatch_sync(queue, { () -> Void in
                self.operationAction(item)
            })
        }
        print("结束")
    }
    
    //MARK: - 操作
    func operationAction(i: Int) {
        
        print(NSThread.currentThread(),i)
    }
    
}

NSOperation方式实现多线程

//MARK: － 两个核心概念
//1.任务(操作)(NSOperation):确定要做的事情 -> 需要封装成一个任务/操作对象
//2.队列(NSOperationQueue):用来存放任务的容器

//使用NSOperation和NSOperationqueue实现多线程的步骤:
//1.创建任务对象
//2.创建队列对象
//3.将任务添加到队列
//系统会自动将队列中的任务取出来放到一个新的线程中执行

class ViewController: UIViewController {
    
    @IBOutlet weak var imageView: UIImageView!
    //MARK: - 属性
    
    lazy var queue: NSOperationQueue = {
      
        
        return NSOperationQueue()
    }()
    
    //MARK: - UITouch
    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        self.test5()
    }
    
    //MARK: - 高级应用
    
    //4.依赖关系
    //解决的问题:如果要求必须是任务A执行完成后才能执行任务B，那么就可以让任务B去依赖任务A
    func test5() {
        
        //1.创建任务
        //任务A
        let operationA = NSBlockOperation.init { () -> Void in
            
            NSThread.sleepForTimeInterval(1)
            print("登录成功")
        }
        //任务B
        let operationB = NSBlockOperation.init { () -> Void in
            NSThread.sleepForTimeInterval(1)
            print("下载电影")
        }
        //任务C
        let operationC = NSBlockOperation.init { () -> Void in
            NSThread.sleepForTimeInterval(1)
            print("显示广告")
        }
        
        //2.建立依赖关系
        //注意: a.任务之间的依赖关系一定要在任务被添加到队列中之前建立，否则无效 b.依赖关系不可以形成循环
        //让任务B，依赖任务A(任务A执行结束后才会执行任务B)
        operationB.addDependency(operationA)
        
        //3.在队列中同时添加多个任务
        self.queue.addOperations([operationA,operationB,operationC], waitUntilFinished: false)
    }
    
    //3. 队列的取消
    //队列的取消:指的是调用cancelAllOperation的方法的瞬间，销毁队列中所有的任务。如果任务已经从队列中取出来了，就不能被这个方法销毁。如果队列已经取消，那么销毁的队列中的任务就不能再复原。
    @IBAction func btnAction1(sender: AnyObject) {
        
        self.queue.cancelAllOperations()
    }
    
    
    //2. 队列的挂起和取消(暂停和取消暂停)
    //队列的暂停:指的是暂停从队列中取出任务，但是已经从队列中取出来的任务任然会继续执行
    @IBAction func btnAction(sender: UIButton) {
        
        if sender.currentTitle == "暂停" {
            
            //1.暂停队列
            self.queue.suspended = true
            
            sender.setTitle("继续", forState: .Normal)
        }
        else {
            //2.取消暂停
            self.queue.suspended = false
            sender.setTitle("暂停", forState: .Normal)
        }
    }
    
    //1.最大并发数
    func test4() {
        
        //1.设置最大并发数(设置同一时刻同时能够执行的最多的任务的个数)
        self.queue.maxConcurrentOperationCount = 3
       
        //2.添加任务
        for item in 0...30 {
            
            self.queue.addOperationWithBlock({ () -> Void in
                
                self.longTimeOperation(item)
            })
        }
    }
    
    
    //MARK: - !!!线程间通信
    func  test3() {
        
        //1.去子线程中下载图片
        self.queue.addOperationWithBlock { () -> Void in
            
            let data = NSData.init(contentsOfURL: NSURL.init(string: "http://i1.073img.com/160509/4230327_100603_1_lit.jpg")!)
            let image = UIImage.init(data: data!) 
            
            //2.回到主线程去显示图片(将任务添加到主队列中)
            //强调:所有的UI操作必须在主线程中执行
            NSOperationQueue.mainQueue().addOperationWithBlock({ () -> Void in
                //显示图片
                self.imageView.image = image
            })
        }
    }
    
    
    
    //MARK: - 基本使用
    
    //2.快速的在队列中添加任务
    func test2() {
        //向队列中添加任务
        for item in 0...10 {
            
            self.queue.addOperationWithBlock { () -> Void in
                self.longTimeOperation(item)
            }

        }
    }
    
    
    func test1() {
        
        //1.创建队列对象
        let queue = NSOperationQueue.init()
        
        //2.创建任务对象
        let operation = NSBlockOperation.init { () -> Void in
            
            self.longTimeOperation(0)
        }
        
        //3.将任务添加到队列中
        queue.addOperation(operation)
        
        //4.在队列中天再添加多个任务
        for item in 1...10 {
            
            let operation2 = NSBlockOperation.init(block: { () -> Void in
                self.longTimeOperation(item)
            })
            queue.addOperation(operation2)
        }
        
    }
    
    //MARK: - 操作
    func longTimeOperation(i: Int) {
        
        NSThread.sleepForTimeInterval(1)
        print(NSThread.currentThread(),i)
    }
    
}