初探GCD

UI相关

ui相关的任务需要使用主线程来运行。

import UIKit

class ViewController: UIViewController {
  
  override func viewDidLoad() {
    super.viewDidLoad()
    
    dispatch_async(dispatch_get_main_queue(), {
      print("Current thread = \(NSThread.currentThread())")
      print("Main thread = \(NSThread.mainThread())")
    })
    print("hello")
    
  }
  
}

主线程在异步执行时会把需要执行的任务放在主队列队尾。

此程序将闭包内的程序放在队列末尾先打印“hello”，打印结束后开始执行闭包。

import UIKit

class ViewController: UIViewController {

  override func viewDidLoad() {
    super.viewDidLoad()

    dispatch_async(dispatch_get_main_queue(), {[weak self] in

      let alertController = UIAlertController(title: "GCD",
        message: "GCD is amazing!",
        preferredStyle: .Alert)

      alertController.addAction(UIAlertAction(title: "OK",
        style: .Default,
        handler: nil))

      self!.presentViewController(alertController,
        animated: true,
        completion: nil)

      })

    }

}

UI无关

UI无关的任务通常使用并发队列异步执行，这样不会阻塞主线程。

若使用并发队列同步执行，则还是不会开启新线程，依旧会使用当前线程（主线程）来执行。

import UIKit

class ViewController: UIViewController {

  func printFrom1To1000(){

    for counter in 0..<1000{
      print("Counter = \(counter) - Thread = \(NSThread.currentThread())")
    }

  }

  override func viewDidLoad() {
    super.viewDidLoad()

    let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    dispatch_sync(queue, printFrom1To1000)
    dispatch_sync(queue, printFrom1To1000)

  }

}

结果如下：

import UIKit

class ViewController: UIViewController {
  
  override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)
    
    let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    dispatch_async(queue, {[weak self] in
      
      var image: UIImage?
      
      dispatch_sync(queue, {
        /* Download the image here */
        
        /* Put your own URL here */
        let urlAsString = "http://pic.nipic.com/2007-11-09/2007119122519868_2.jpg"
        
        let url = NSURL(string: urlAsString)
        let urlRequest = NSURLRequest(URL: url!)
        var downloadError: NSError?
        
        let imageData: NSData?
        do {
          imageData = try NSURLConnection.sendSynchronousRequest(urlRequest,
            returningResponse: nil)
        } catch let error as NSError {
          downloadError = error
          imageData = nil
        } catch {
          fatalError()
        }
        
        if let error = downloadError{
          print("Error happened = \(error)")
        } else if let imageData = imageData{
          
          if imageData.length > 0{
            image = UIImage(data: imageData)
            /* Now we have the image */
          } else {
            print("No data could get downloaded from the URL")
          }
          
        }
        
      })
      
      dispatch_sync(dispatch_get_main_queue(), {
        /* Show the image to the user here on the main queue */
        
        if let theImage = image{
          let imageView = UIImageView(frame: self!.view.bounds)
          imageView.contentMode = .ScaleAspectFit
          imageView.image = theImage
          self!.view.addSubview(imageView)
        }
        
      })
      
      })
  }
  
}

这个例子使用并发队列异步执行，不会阻塞主线程。

效果如下：

import UIKit

class ViewController: UIViewController {

  func fileLocation() -> String?{

    /* Get the document folder(s) */
    let folders = NSSearchPathForDirectoriesInDomains(.DocumentDirectory,
      .UserDomainMask,
      true) as [String]

    /* Did we find anything? */
    if folders.count == 0{
      return nil
    }

    /* Get the first folder */
    let documentsFolder = folders[0]

    /* Append the filename to the end of the documents path */
    return documentsFolder.stringByAppendingPathComponent("list.txt")

  }

  func hasFileAlreadyBeenCreated() -> Bool{
    let fileManager = NSFileManager()
    if let theLocation = fileLocation(){
      return fileManager.fileExistsAtPath(theLocation)
    }
    return false
  }

  override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)

    let concurrentQueue =
      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

    /* If we have not already saved an array of 10,000
    random numbers to the disk before, generate these numbers now
    and then save them to the disk in an array */
    dispatch_async(concurrentQueue, {[weak self] in

      let numberOfValuesRequired = 10000


      if self!.hasFileAlreadyBeenCreated() == false{
        dispatch_sync(concurrentQueue, {

          var arrayOfRandomNumbers = [Int]()

          for _ in 0..<numberOfValuesRequired{
            let randomNumber = Int(arc4random())
            arrayOfRandomNumbers.append(randomNumber)
          }

          /* Now let's write the array to disk */
          let array = arrayOfRandomNumbers as NSArray
          array.writeToFile(self!.fileLocation()!, atomically: true)

          })
      }

      var randomNumbers: NSMutableArray?

      /* Read the numbers from disk and sort them in an
      ascending fashion */
      dispatch_sync(concurrentQueue, {
        /* If the file has now been created, we have to read it */
        if self!.hasFileAlreadyBeenCreated(){
          randomNumbers = NSMutableArray(
            contentsOfFile: self!.fileLocation()!)

          /* Now sort the numbers */
          randomNumbers!.sortUsingComparator({
            (obj1: AnyObject!, obj2: AnyObject!) -> NSComparisonResult in
            let number1 = obj1 as! NSNumber
            let number2 = obj2 as! NSNumber
            return number1.compare(number2)
            })
        }
        })


      dispatch_async(dispatch_get_main_queue(), {
        if let numbers = randomNumbers{

          if numbers.count > 0{
            /* Refresh the UI here using the numbers in the
            randomNumbers array */
            print("The sorted array was read back from disk = \(numbers)")
          } else {
            print("The numbers array is emtpy")
          }

        }
        })

      })

  }

}

延时一段时间

import UIKit

class ViewController: UIViewController {
  
  override func viewDidLoad() {
    super.viewDidLoad()
    
    let delayInSeconds = 2.0
    
    let delayInNanoSeconds =
    dispatch_time(DISPATCH_TIME_NOW,
      Int64(delayInSeconds * Double(NSEC_PER_SEC)))
    
    let concurrentQueue =
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    
    dispatch_after(delayInNanoSeconds, concurrentQueue, {
        print("hello")
      })
    
  }
  
}

延时2秒后并发队列异步执行打印语句。

只执行一次

import UIKit

class ViewController: UIViewController {
  
  var token: dispatch_once_t = 0
  var numberOfEntries = 0
  
  func executedOnlyOnce(){
    numberOfEntries++;
    print("Executed \(numberOfEntries) time(s)")
    
  }
                            
  override func viewDidLoad() {
    super.viewDidLoad()
    
    dispatch_once(&token, executedOnlyOnce)
    dispatch_once(&token, executedOnlyOnce)
    
  }
  
}

效果如下：

群组

import UIKit

class ViewController: UIViewController {
                            
  func reloadTableView(){
    /* Reload the table view here */
    print(__FUNCTION__)
  }
  
  func reloadScrollView(){
    /* Do the work here */
    print(__FUNCTION__)
  }
  
  func reloadImageView(){
    /* Reload the image view here */
    print(__FUNCTION__)
  }
  
  override func viewDidLoad() {
    super.viewDidLoad()
    
    let taskGroup =  dispatch_group_create()
    let mainQueue =  dispatch_get_main_queue()
    
    /* Reload the table view on the main queue */
    dispatch_group_async(taskGroup, mainQueue, {[weak self] in
      self!.reloadTableView()
      });
    
    /* Reload the scroll view on the main queue */
    dispatch_group_async(taskGroup, mainQueue, {[weak self] in
      self!.reloadScrollView()
      });
    
    /* Reload the image view on the main queue */
    dispatch_group_async(taskGroup, mainQueue, {[weak self] in
      self!.reloadImageView()
      });
    
    /* At the end when we are done, dispatch the following block */
    dispatch_group_notify(taskGroup, mainQueue, {[weak self] in
      /* Do some processing here */
      
      let controller = UIAlertController(title: "Finished",
        message: "All tasks are finished",
        preferredStyle: .Alert)
      
      
      controller.addAction(UIAlertAction(title: "OK",
        style: .Default,
        handler: nil))
      
      self!.presentViewController(controller, animated: true, completion: nil)
      
      });
    
  }

}

当所有群组的任务执行完之后执行group_notify任务。

小结：

1.主队列和全局队列

主队列

<1>串行队列，一次只执行一个任务

<2>队列所有任务都是在主线程执行

<3>所有UI更新的任务都需要放在主队列由主线程执行

全局队列

<1>并发队列，一次执行多个任务

<2>队列内任务可以由主线程完成也可以由其他线程完成，看具体的同步或异步执行方式。(在主线程执行区域内进行全局队列同步执行，则还是由当前线程(主线程)来执行)

2.同步执行和异步执行

同步执行

1.由当前线程执行（除了主队列的任务，需要主线程执行）

2.阻塞当前线程，必须等闭包执行完毕后在执行下面的任务（主线程执行区域内进行主队列的同步执行会造成死锁）

(串行队列的线程在执行过程中，遇到给该串行队列增加同步任务都会造成死锁)

异步执行

1.将任务放到队列尾就立刻返回，不会阻塞当前线程

2.交给其他线程进行任务

主线程外执行下载任务后更新界面的一般模式即为：

全局队列异步执行任务{    //不会阻塞主线程

//task  完成后

主队列异步执行更新UI任务{}

}

其中的主队列异步执行任务 也可以换成主队列同步执行任务，区别就是是否会阻塞当前执行下载任务的某线程。

若为同步执行，下载线程会等到改UI更新任务结束后才继续运行，若为异步任务，则会直接向下运行。