ios多线程之NSThread,GCD,NSOperation以及线程同步

概述

大家都知道,我们在很多app的使用中很关注的一个体验就是app的流畅性以及用户等待时间.而这两点其实最根本就的就是让程序已最少的时间完成运算.无论是哪种语言开发的程序最终往往转换成汇编语言进而解释成机器码来执行.但是机器码是按顺序执行的,一个复杂的多步操作只能一步步按顺序逐个执行.所以我们就会引入这个线程技术.然后这里初学者很容易有一个误区是:(“多线程技术会提高单个算法本身的执行效率.”这是非常严重的一个错误.多线程技术并不会和程序本身的执行效率有关系,只是将一些耗时的任务分配到其他线程执行,进行一个”并行”运算).对于单核处理器,可以将多个步骤放到不同的线程,这样一来用户完成UI操作后其他后续任务在其他线程中,当CPU空闲时会继续执行,而此时对于用户而言可以继续进行其他操作;对于多核处理器,如果用户在UI线程中完成某个操作之后,其他后续操作在别的线程中继续执行,用户同样可以继续进行其他UI操作,与此同时前一个操作的后续任务可以分散到多个空闲CPU中继续执行（当然具体调度顺序要根据程序设计而定）,既解决了线程阻塞又提高了运行效率.苹果从iPad2 开始使用双核A5处理器(iPhone中从iPhone 4S开始使用),A7中还加入了协处理器，如何充分发挥这些处理器的性能确实值得思考.

多线程

介绍

当用户播放音频、下载资源、进行图像处理时往往希望做这些事情的时候其他操作不会被中断或者希望这些操作过程中更加顺畅。在单线程中一个线程只能做一件事情，一件事情处理不完另一件事就不能开始，这样势必影响用户体验。早在单核处理器时期就有多线程，这个时候多线程更多的用于解决线程阻塞造成的用户等待（通常是操作完UI后用户不再干涉，其他线程在等待队列中，CPU一旦空闲就继续执行，不影响用户其他UI操作），其处理能力并没有明显的变化。如今无论是移动操作系统还是PC、服务器都是多核处理器，于是“并行运算”就更多的被提及。一件事情我们可以分成多个步骤，在没有顺序要求的情况下使用多线程既能解决线程阻塞又能充分利用多核处理器运行能力。

下图反映了一个包含8个操作的任务在一个有两核心的CPU中创建四个线程运行的情况。假设每个核心有两个线程，那么每个CPU中两个线程会交替执行，两个CPU之间的操作会并行运算。单就一个CPU而言两个线程可以解决线程阻塞造成的不流畅问题，其本身运行效率并没有提高，多CPU的并行运算才真正解决了运行效率问题，这也正是并发和并行的区别。当然，不管是多核还是单核开发人员不用过多的担心，因为任务具体分配给几个CPU运算是由系统调度的，开发人员不用过多关心系统有几个CPU。开发人员需要关心的是线程之间的依赖关系，因为有些操作必须在某个操作完成完才能执行，如果不能保证这个顺序势必会造成程序问题。

进程

进程是指在系统中正在运行的一个应用程序,每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内

(通过“活动监视器”可以查看Mac系统中所开启的进程)

如图所示打开QQ、Xcode，Finder等系统就会分别启动n个进程..

线程

当一个进程要想执行任务，必须得有线程(每1个进程至少要有1条线程,这条线程也称之为”主线程”).线程是进程的基本执行单元,一个进程(程序)的所有任务都在线程中执行.

如图所示,谷歌浏览器开辟了35条线程之多,比如谷歌浏览器的查看网页,下载,播放Flash等所有的操作都需要在线程中执行.

并且线程是无法手动杀死的,只能暂停(或者叫休眠线程).

使用线程的目的就是为了开启一条新的执行路径，运行指定的代码，与主线程中的代码实现”同时运行”.

线程的串行

1个线程中任务的执行是串行的(要在1个线程中执行多个任务,那么只能一个一个地按顺序执行这些任务)

也就是说，在同一时间内，1个线程只能执行1个任务.此时是线程的串行,请勿于队列的串行和并发混淆.

如图所示,现在有3个下载任务,但是只有单一的线程.首先讲下载任务1丢进去,当下载任务1执行完毕后在丢入下载任务2.

多线程的并行

1个进程中可以开启多条线程，每条线程可以”并行”（”同时”）执行不同的任务

多线程技术可以提高程序的执行效率,使程序更加流畅,用户体验更好.(再次降调一次:多线程技术并不会提高单个算法本身的执行效率)

比如同时开启3条线程分别下载3个文件（分别是下载任务1、下载任务2、下载任务3）

如图所示,我们在这个进程中开辟3条线程,并且把下载任务1,2,3分别丢入线程中.这时3个下载任务就可以通过多任务系统调度后”并行”(“同时”)下载了.

多任务系统调度

• windows多任务

它是指用户可以在同一时间内运行多个应用程序,每个应用程序被称作一个任务。Windows就是一个支持多任务的操作系统,比起DOS的单任务系统,确实方便了许多。Windows多任务处理采用的是被称为虚拟机(Virtual Machine)的技术。虚拟机实际上指的是由Windows在内存中创建的逻辑微机,由它来运行应用程序。当Windows接受到由鼠标器、键盘、定时器信号或某些I/O操作产生的”事件”后,为该任务分配CPU时间。每个任务使用由Windows分配的短暂的时间片(Timeslice)轮流使用CPU,由于CPU对每个时间片的处理速度非常快,在用户看来好像这些任务在同时执行
ios的多程序和windows的多任务类似.具体关于多可以资料可以查看”各种系统以及构架多任务的讨论(x86、arm、unix、windows其他)“.

大家可能注意到了,我之前的说的所有并且及同时都有引号,因为:每个应用程序由操作系统分配的非常短暂的时间片(Timeslice)轮流使用CPU,由于CPU对每个时间片的处理速度非常快.因此,用户看来好像这些任务在同时执行的.所以并行其实是指两个或多个任务在同一时间间隔内发生.(但是在任意一个时刻点上,CPU只会处理一个任务.)

多线程的优缺点

多线程的优点

1. 能适当提高程序的执行效率
2. 当硬件处理器的数量增加,程序会运行更快,而程序无需做任何调整
3. 将耗时的任务分配到其他线程执行,由主线程负责统一更新界面会使应用程序更加流畅，用户体验更好
4. 充分发挥多核处理器优势,将不同线程任务分配给不同的处理器,真正进入“并行运算”状态.提高资源利用率(CPU,内存利用率)

多线程的缺点

1. 开启线程需要占用一定的内存空间(默认情况下:主线程占用1M,子线程占用512KB.注意:实际测试中,主线程也是512k),如果开启大量的线程,会占用大量的内存空间,降低程序的性能
2. 线程越多,CPU在调度线程上的开销就越大
3. 比如线程之间的通信,多线程的数据共享

ios中的多线程

在iOS中每个进程启动后都会建立一个主线程（UI线程），这个线程是其他线程的父线程。

主线程作用:显示\刷新UI界面以及处理UI事件（比如点击事件、滚动事件、拖拽事件等)

由于在iOS中除了主线程，其他子线程是独立于Cocoa Touch的，所以只有主线程可以更新UI界面（新版iOS中，使用其他线程更新UI可能也能成功，但是不推荐）。

iOS中多线程使用并不复杂，关键是如何控制好各个线程的执行顺序、处理好资源竞争问题。常用的多线程开发有三种方式：

NSThread

使用NSThread对象建立一个线程非常方便

使用NSThread管理多个线程非常困难.(不推荐使用)

NSOperation

使用GCD实现的一套Objective-C的API,简单说就是封装好的GCD.

是面向对象的线程技术

提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系等

使用[NSThread currentThread]来跟踪任务所在线程，适用于这三种技术,并且非常好用!

GCD

是基于C语言的底层API

用Block定义任务，使用起来非常灵活便捷

提供了更多的控制能力以及操作队列中所不能使用的底层函数

充分利用了多核处理器的运算性能

自动管理线程的生命周期(创建线程,调度任务,销毁线程)

三种方式是随着iOS的发展逐渐引入的，所以相比而言后者比前者更加简单易用，并且GCD也是目前苹果官方比较推荐的方式（它充分利用了多核处理器的运算性能）。

GCD

GCD的基本思想是就将操作(任务)放在队列(调度)中去执行.

介绍

GCD是什么

Grand Central Dispatch 简称（GCD）是苹果公司开发的技术，以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统。这建立在任务并行执行的线程池模式的基础上的。它首次发布在Mac OS X 10.6 ，iOS 4及以上也可用。

设计

术语

dispath queue**(调度队列)**

队列就是专门用来存放任务(操作)的.

Serial(串行队列)

又称为private dispatch queues,同时只执行一个任务.Serial queue通常用于同步访问特定的资源或数据.只有一个线程,加入到队列中的操作按添加顺序依次执行.

Concurrent(并行队列)

有多个线程,操作进来之后它会将这些队列安排在可用的处理器上,同时保证先进来的任务优先处理.(和全局队列类似,只是创建后可以调试时观察”const char *label“来确定线程.)

Global dispatch queue(全局队列)

是所有应用程序都能够使用的Concurrent.一般不用刻意的去创建一个Concurrent 的Queue.只要获得系统的这个即可.

Main dispatch queue(主队列)

将任务放在主线程中去执行,可以将一些更新UI的任务追加到该Queue中,这个和NSObject类提供的performSelectorOnMainThread方法执行的效果一样.(其实在NSOperation中也有一个主队列)

Queue Types (队列类型)

/!
  @function dispatch_get_global_queue
 
  @abstract
  Returns a well-known global concurrent queue of a given quality of service
  class.
 
  @discussion
  The well-known global concurrent queues may not be modified. Calls to
  dispatch_suspend(), dispatch_resume(), dispatch_set_context(), etc., will
  have no effect when used with queues returned by this function.
 
  @param identifier
  A quality of service class defined in qos_class_t or a priority defined in
  dispatch_queue_priority_t.
 
  It is recommended to use quality of service class values to identify the
  well-known global concurrent queues:
   - QOS_CLASS_USER_INTERACTIVE
   - QOS_CLASS_USER_INITIATED
   - QOS_CLASS_DEFAULT
   - QOS_CLASS_UTILITY
   - QOS_CLASS_BACKGROUND
 
  The global concurrent queues may still be identified by their priority,
  which map to the following QOS classes:
   - DISPATCH_QUEUE_PRIORITY_HIGH:         QOS_CLASS_USER_INITIATED
   - DISPATCH_QUEUE_PRIORITY_DEFAULT:      QOS_CLASS_DEFAULT
   - DISPATCH_QUEUE_PRIORITY_LOW:          QOS_CLASS_UTILITY
   - DISPATCH_QUEUE_PRIORITY_BACKGROUND:   QOS_CLASS_BACKGROUND
 
  @param flags
  Reserved for future use. Passing any value other than zero may result in
  a NULL return value.
 
  @result
  Returns the requested global queue or NULL if the requested global queue
  does not exist.
 /
OSX_AVAILABLE_STARTING(MAC_10_6,__IPHONE_4_0)
DISPATCH_EXPORT DISPATCH_CONST DISPATCH_WARN_RESULT DISPATCH_NOTHROW
dispatch_queue_t
dispatch_get_global_queue(long identifier, unsigned long flags);

    dispatch_queue_t q = dispatch_get_global_queue(0, 0);

操作(任务)

同步

执行完这一句代码,再执行后续的代码

就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。换句话说，就是由调用者主动等待这个调用的结果。

你打电话问书店老板有没有 <<BirdMichael的GCD讲解>> 这本书，如果是同步通信机制—书店老板会说:”你稍等,我查一下”,然后开始查啊查,等查好了(可能是5秒,也可能是一天)告诉你结果（返回结果）.这其中你电话不可以挂断.(等待返回结果).接收不到返回结果,不继续下面的操作(淘宝买).

在当前线程中执行任务，不具备开启新线程的能力

异步

不必等待这一句代码执行完,就执行下一句代码

调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用.

你打电话问书店老板有没有 <<BirdMichael的GCD讲解>> 这本书，如果是异步通信机制—可能你你正在执行某个操作(通过淘宝查询),然后拿起电话给书店老板打了一个电话.书店老板直接告诉你:”我查一下啊,查好了打电话给你”,然后直接挂了电话(不返回结果).你继续该干哈干哈.等老板然后查好了,他会主动打电话给你,在这里老板通过“回电”这种方式来回调.

在新的线程中执行任务，具备开启新线程的能力

函数指针调度任务

也就是dispatch_sync_f函数和dispatch_async_f函数.函数指针的传递类属于pthread.

函数指针调度几乎不用!!只为面试了解即可.

Deadlock 死锁

// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create(“com.birdmichael.concurrent”, DISPATCH_QUEUE_CONCURRENT);
// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create(“com.birdmichael.serial”, DISPATCH_QUEUE_SERIAL);
// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();

dispatch_sync(q, ^{
    NSLog(@”同步任务 %@”, [NSThread currentThread]);
    dispatch_sync(q, ^{
        NSLog(@”同步任务 %@”, [NSThread currentThread]);
    });
});

#### Context Switch 上下文切换

一个上下文切换指当你在单个进程里切换执行不同的线程时存储与恢复执行状态的过程.这个过程在编写多任务应用时很普遍，但会带来一些额外的开销。

Concurrency vs Parallelism 并发与并行

并发和并行通常被一起提到,所以值得花些时间解释它们之间的区别.

并发代码的不同部分可以“同步”执行.然而,该怎样发生或是否发生都取决于系统.多核设备通过并行来同时执行多个线.然而,为了使单核设备也能实现这一点,它们必须先运行一个线程,执行一个上下文切换,然后运行另一个线程或进程.这通常发生地足够快以致给我们并发执行地错觉.如下图所示：

虽然你可以编写代码在 GCD 下并发执行,但 GCD 会决定有多少并行的需求.并行要求并发,但并发并不能保证并行.

更深入的观点是并发实际上是关于构造.当你在脑海中用 GCD 编写代码,你组织你的代码来暴露能同时运行的多个工作片段,以及不能同时运行的那些.如果你想深入此主题.看看 this excellent talk by Rob Pike .

>

简单的说,并发和并行其实一个东西.在多核中,使用并行.每个核处理不同任务.而在单核中,为了打消同样的效果,就通过上面讲到的时间片的方式通过伪多任务实现.

创建和管理dispatch queue(队列)

创建串行Dispatch Queue

应用的任务需要按特定顺序执行时,就需要使用串行Dispatch Queue,串行queue每次只能执行一个任务。你可以使用串行queue来替代锁,保护共享资源 或可变的数据结构。和锁不一样的是,串行queue确保任务按可预测的顺序执行。而且只要你异步地提交任务到串行queue,就永远不会产生死锁

你必须显式地创建和管理所有你使用的串行queue,应用可以创建任意数量的串行queue,但不要为了同时执行更多任务而创建更多的串行queue。如果你需要并发地执行大量任务,应该把任务提交到全局并发queue

利用dispatch_queue_create函数创建串行queue,两个参数分别是queue名和一组queue属性

dispatch_queue_t queue = dispatch_queue_create("com.birdmichael.serial, NULL);

dispatch_queue_t queue = dispatch_queue_create("com.birdmichael.serial, DISPATCH_QUEUE_SERIAL);

/*!
 * @const DISPATCH_QUEUE_SERIAL
 * @discussion A dispatch queue that invokes blocks serially in FIFO order.
 */
#define DISPATCH_QUEUE_SERIAL NULL

/*!
 * @const DISPATCH_QUEUE_CONCURRENT
 * @discussion A dispatch queue that may invoke blocks concurrently and supports
 * barrier blocks submitted with the dispatch barrier API.
 */
#define DISPATCH_QUEUE_CONCURRENT \
        DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t, \
        _dispatch_queue_attr_concurrent)
__OSX_AVAILABLE_STARTING(__MAC_10_7,__IPHONE_4_3)
DISPATCH_EXPORT
struct dispatch_queue_attr_s _dispatch_queue_attr_concurrent;

创建并行Dispatch Queue

与全局获取到得并行队列区别是多了一个queue名

dispatch_queue_t q = dispatch_queue_create("com.birdmichael.concurrent", DISPATCH_QUEUE_CONCURRENT);

// 获取默认优先级的全局并发dispatch queue
    dispatch_queue_t  queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 获取主队列串行dispatch queue
    dispatch_queue_t  queue = dispatch_get_main_queue();

// 将一个异步调用放入队列中
    dispatch_async(<#dispatch_queue_t queue#>, ^{
        <#code#>
    })

// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create("com.birdmichael.concurrent", DISPATCH_QUEUE_CONCURRENT);
// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create("com.birdmichael.serial", DISPATCH_QUEUE_SERIAL);
// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();

dispatch_sync(q, ^{
    NSLog(@"同步任务 %@", [NSThread currentThread]);
    dispatch_sync(q, ^{
        NSLog(@"同步任务 %@", [NSThread currentThread]);
    });
});

//
//  ViewController.m
//  GCD
//
//  Created by 李 阳 on 15/7/31.
//  Copyright (c) 2015年 BirdMIchael. All rights reserved.
//

#import “ViewController.h”

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    for (int i = 0;i < 10 ;++i)
    {
        NSLog(@”主进程(UI进程)%@ ->%d”,[NSThread currentThread],i);
    }
}
@end

2015-08-01 16:47:53.018 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->0
2015-08-01 16:47:53.018 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->1
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->2
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->3
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->4
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->5
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->6
2015-08-01 16:47:53.019 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->7
2015-08-01 16:47:53.032 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->8
2015-08-01 16:47:53.034 GCD[98013:323175] 主进程(UI进程)<NSThread: 0x7f8a52d289a0>{number = 1, name = main} ->9

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest];
}
// 串行 异步
- (void)gcdtest
{
    dispatch_queue_t q = dispatch_queue_create(“com.birdmichael”, DISPATCH_QUEUE_SERIAL);
    for (int i = 0;i < 10 ;++i){
        dispatch_async(q, ^{
            NSLog(@”串行队列,异步调用%@ ->%d”,[NSThread currentThread],i);
            });
        }
}

2015-08-01 16:57:01.707 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->0
2015-08-01 16:57:01.728 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->1
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->2
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->3
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->4
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->5
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->6
2015-08-01 16:57:01.729 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->7
2015-08-01 16:57:01.734 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->8
2015-08-01 16:57:01.734 GCD[99504:330237] 串行队列,异步调用<NSThread: 0x7fa3094438f0>{number = 2, name = (null)} ->9

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest2];
}
// 并行 异步
- (void)gcdtest2
{
    dispatch_queue_t q = dispatch_queue_create(“com.birdmichael2”, DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0;i < 20 ;++i){
    dispatch_async(q, ^{
            NSLog(@”并行队列,异步调用%@ ->%d”,[NSThread currentThread],i);
    });
    }
}

2015-08-01 17:16:33.626 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->0
2015-08-01 17:16:33.626 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->1
2015-08-01 17:16:33.630 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->2
2015-08-01 17:16:33.632 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->3
2015-08-01 17:16:33.643 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->5
2015-08-01 17:16:33.643 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->6
2015-08-01 17:16:33.643 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->7
2015-08-01 17:16:33.644 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->8
2015-08-01 17:16:33.644 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->9
2015-08-01 17:16:33.644 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->10
2015-08-01 17:16:33.645 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->11
2015-08-01 17:16:33.645 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->12
2015-08-01 17:16:33.642 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->4
2015-08-01 17:16:33.646 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->13
2015-08-01 17:16:33.646 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->14
2015-08-01 17:16:33.646 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->15
2015-08-01 17:16:33.647 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->16
2015-08-01 17:16:33.647 GCD[2997:344440] 并行队列,异步调用<NSThread: 0x7fd758dabe20>{number = 4, name = (null)} ->17
2015-08-01 17:16:33.648 GCD[2997:344437] 并行队列,异步调用<NSThread: 0x7fd758d9c0d0>{number = 3, name = (null)} ->18
2015-08-01 17:16:33.649 GCD[2997:344435] 并行队列,异步调用<NSThread: 0x7fd758dab5e0>{number = 2, name = (null)} ->19

串行队列同步调用

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest3 ];
}

// 串行 同步
- (void)gcdtest3
{
    dispatch_queue_t q = dispatch_queue_create("com.birdmichael", DISPATCH_QUEUE_SERIAL);
    for (int i = 0;i < 10 ;++i){
        dispatch_sync(q, ^{
            NSLog(@"串行队列,同步调用%@ ->%d",[NSThread currentThread],i);
        });
    }
}

2015-08-01 17:24:15.133 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->0
2015-08-01 17:24:15.139 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->1
2015-08-01 17:24:15.139 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->2
2015-08-01 17:24:15.139 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->3
2015-08-01 17:24:15.139 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->4
2015-08-01 17:24:15.139 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->5
2015-08-01 17:24:15.140 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->6
2015-08-01 17:24:15.140 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->7
2015-08-01 17:24:15.145 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->8
2015-08-01 17:24:15.145 GCD[4215:349141] 串行队列,同步调用<NSThread: 0x7fb1c1c28200>{number = 1, name = main} ->9

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest4];
}
// 并行 同步
- (void)gcdtest4
{
    dispatch_queue_t q = dispatch_queue_create("com.birdmichael2", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0;i < 20 ;++i){
        dispatch_sync(q, ^{
            NSLog(@"并行队列,同步调用%@ ->%d",[NSThread currentThread],i);
        });
    }
}

2015-08-01 17:33:49.704 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->0
2015-08-01 17:33:49.704 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->1
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->2
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->3
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->4
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->5
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->6
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->7
2015-08-01 17:33:49.705 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->8
2015-08-01 17:33:49.706 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->9
2015-08-01 17:33:49.706 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->10
2015-08-01 17:33:49.706 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->11
2015-08-01 17:33:49.706 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->12
2015-08-01 17:33:49.706 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->13
2015-08-01 17:33:49.707 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->14
2015-08-01 17:33:49.707 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->15
2015-08-01 17:33:49.707 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->16
2015-08-01 17:33:49.707 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->17
2015-08-01 17:33:49.707 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->18
2015-08-01 17:33:49.717 GCD[5743:355585] 并行队列,同步调用<NSThread: 0x7faa8ad11760>{number = 1, name = main} ->19

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest5];
}
// 并行 同步后异步
- (void)gcdtest5
{
    dispatch_queue_t q = dispatch_queue_create("com.birdmichael2", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0;i < 20 ;++i){
        dispatch_sync(q, ^{
            NSLog(@"并行队列,同步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }
    for (int i = 0;i < 20 ;++i){
        dispatch_async(q, ^{
            NSLog(@"并行队列,异步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }

}

2015-08-01 17:46:39.480 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->0
2015-08-01 17:46:39.480 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->1
2015-08-01 17:46:39.480 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->2
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->3
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->4
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->5
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->6
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->7
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->8
2015-08-01 17:46:39.481 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->9
2015-08-01 17:46:39.482 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->10
2015-08-01 17:46:39.482 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->11
2015-08-01 17:46:39.482 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->12
2015-08-01 17:46:39.482 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->13
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->14
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->15
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->16
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->17
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->18
2015-08-01 17:46:39.483 GCD[7782:362965] 并行队列,同步 <调用<NSThread: 0x7fd308c28160>{number = 1, name = main} ->19
2015-08-01 17:46:39.488 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->0
2015-08-01 17:46:39.489 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->1
2015-08-01 17:46:39.489 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->2
2015-08-01 17:46:39.490 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->3
2015-08-01 17:46:39.491 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->4
2015-08-01 17:46:39.492 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->5
2015-08-01 17:46:39.492 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->6
2015-08-01 17:46:39.493 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->7
2015-08-01 17:46:39.494 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->8
2015-08-01 17:46:39.494 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->9
2015-08-01 17:46:39.494 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->10
2015-08-01 17:46:39.494 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->11
2015-08-01 17:46:39.495 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->12
2015-08-01 17:46:39.495 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->13
2015-08-01 17:46:39.502 GCD[7782:363061] 并行队列,异步 <调用<NSThread: 0x7fd308d4d510>{number = 4, name = (null)} ->16
2015-08-01 17:46:39.502 GCD[7782:363061] 并行队列,异步 <调用<NSThread: 0x7fd308d4d510>{number = 4, name = (null)} ->17
2015-08-01 17:46:39.502 GCD[7782:363061] 并行队列,异步 <调用<NSThread: 0x7fd308d4d510>{number = 4, name = (null)} ->18
2015-08-01 17:46:39.502 GCD[7782:363061] 并行队列,异步 <调用<NSThread: 0x7fd308d4d510>{number = 4, name = (null)} ->19
2015-08-01 17:46:39.501 GCD[7782:363054] 并行队列,异步 <调用<NSThread: 0x7fd308d643d0>{number = 2, name = (null)} ->14
2015-08-01 17:46:39.501 GCD[7782:363057] 并行队列,异步 <调用<NSThread: 0x7fd308c52be0>{number = 3, name = (null)} ->15

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest5];
}
// 并行 同步后异步
- (void)gcdtest5
{
    dispatch_queue_t q = dispatch_queue_create("com.birdmichael2", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0;i < 20 ;++i){
        dispatch_async(q, ^{
            NSLog(@"并行队列,异步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }
    for (int i = 0;i < 20 ;++i){
        dispatch_sync(q, ^{
            NSLog(@"并行队列,同步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }
}

2015-08-01 17:50:20.686 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->0
2015-08-01 17:50:20.686 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->1
2015-08-01 17:50:20.686 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->0
2015-08-01 17:50:20.687 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->1
2015-08-01 17:50:20.687 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->3
2015-08-01 17:50:20.687 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->4
2015-08-01 17:50:20.686 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->2
2015-08-01 17:50:20.687 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->2
2015-08-01 17:50:20.687 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->6
2015-08-01 17:50:20.687 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->7
2015-08-01 17:50:20.687 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->5
2015-08-01 17:50:20.688 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->3
2015-08-01 17:50:20.689 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->9
2015-08-01 17:50:20.689 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->10
2015-08-01 17:50:20.688 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->8
2015-08-01 17:50:20.690 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->4
2015-08-01 17:50:20.690 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->11
2015-08-01 17:50:20.690 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->12
2015-08-01 17:50:20.691 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->13
2015-08-01 17:50:20.691 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->5
2015-08-01 17:50:20.691 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->14
2015-08-01 17:50:20.693 GCD[8368:366651] 并行队列,异步 <调用<NSThread: 0x7f94b3d96430>{number = 3, name = (null)} ->15
2015-08-01 17:50:20.693 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->16
2015-08-01 17:50:20.694 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->17
2015-08-01 17:50:20.694 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->6
2015-08-01 17:50:20.694 GCD[8368:366648] 并行队列,异步 <调用<NSThread: 0x7f94b3d94450>{number = 2, name = (null)} ->18
2015-08-01 17:50:20.694 GCD[8368:366650] 并行队列,异步 <调用<NSThread: 0x7f94b3d97670>{number = 4, name = (null)} ->19
2015-08-01 17:50:20.694 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->7
2015-08-01 17:50:20.694 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->8
2015-08-01 17:50:20.695 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->9
2015-08-01 17:50:20.695 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->10
2015-08-01 17:50:20.695 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->11
2015-08-01 17:50:20.695 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->12
2015-08-01 17:50:20.697 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->13
2015-08-01 17:50:20.697 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->14
2015-08-01 17:50:20.697 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->15
2015-08-01 17:50:20.697 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->16
2015-08-01 17:50:20.697 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->17
2015-08-01 17:50:20.698 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->18
2015-08-01 17:50:20.698 GCD[8368:366567] 并行队列,同步 <调用<NSThread: 0x7f94b3c28bd0>{number = 1, name = main} ->19

- (void)viewDidLoad {
    [super viewDidLoad];

    [self gcdtest6];
}
// 主线程 异步任务
- (void)gcdtest6
{
    dispatch_queue_t q = dispatch_get_main_queue();
    for (int i = 0;i < 10 ;++i){
        dispatch_async(q, ^{
            NSLog(@"主线程,异步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }
}

2015-08-01 18:03:18.321 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->0
2015-08-01 18:03:18.322 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->1
2015-08-01 18:03:18.322 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->2
2015-08-01 18:03:18.322 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->3
2015-08-01 18:03:18.322 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->4
2015-08-01 18:03:18.323 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->5
2015-08-01 18:03:18.323 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->6
2015-08-01 18:03:18.323 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->7
2015-08-01 18:03:18.323 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->8
2015-08-01 18:03:18.324 GCD[10410:374539] 主线程,异步 <调用<NSThread: 0x7f8d10d28ab0>{number = 1, name = main} ->9

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"是否被柱塞了?");
    [self gcdtest7];
    NSLog(@"是");
}
// 主线程 同步任务
- (void)gcdtest7
{
    dispatch_queue_t q = dispatch_get_main_queue();
    for (int i = 0;i < 10 ;++i){
        dispatch_sync(q, ^{
            NSLog(@"主线程,异步 <调用%@ ->%d",[NSThread currentThread],i);
        });
    }
}

2015-08-01 18:07:14.994 GCD[11042:377997] 是否被柱塞了?

void dispatch_after ( dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block );

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

<#delayInSeconds#>:从现在开始经过多少秒

<#code to be executed after a specified delay#>:代码块

示例程序(主线程):

- (void)viewDidLoad {
    [super viewDidLoad];
    [self delay2];
}
- (void)delay2
{
    NSLog(@"It is begin.");
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"open:birdmichael.com,The thread is%@",[NSThread currentThread]);
});
    NSLog(@"it is next.");
}

2015-08-03 01:05:05.445 GCD[88456:650588] It is begin.
2015-08-03 01:05:05.446 GCD[88456:650588] it is next.
2015-08-03 01:05:07.643 GCD[88456:650588] open:birdmichael.com,The thread is<NSThread: 0x7f86b9c28b80>{number = 1, name = main}

示例程序(子线程):

- (void)delay3
{
    NSLog(@"It is begin.");
    // 获取全局队列
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), q, ^{
        NSLog(@"open:birdmichael.com,The thread is%@",[NSThread currentThread]);
});

    NSLog(@"it is next.");
}

2015-08-03 01:08:13.233 GCD[88947:653122] It is begin.
2015-08-03 01:08:13.233 GCD[88947:653122] it is next.
2015-08-03 01:08:15.234 GCD[88947:653225] open:birdmichael.com,The thread is<NSThread: 0x7ff60a524240>{number = 2, name = (null)}

performSelector

[self performSelector:(SEL) withObject:(id) afterDelay:(NSTimeInterval)];

- (void)viewDidLoad {
    [super viewDidLoad];
    [self delay1];
}

// 延时执行
- (void)delay1
{
    NSLog(@"It is begin.");
    [self performSelector:@selector(openMyWeb:) withObject:@"birdmichael.com" afterDelay:3];
    NSLog(@"it is next.");
}
-(void)openMyWeb:(NSString *)url
{
    NSLog(@"open:%@,The thread is %@", url,[NSThread currentThread]);
}

2015-08-03 00:53:47.945 GCD[86660:641006] It is begin.
2015-08-03 00:53:47.946 GCD[86660:641006] it is next.
2015-08-03 00:53:50.947 GCD[86660:641006] open:birdmichael.com,The thread is <NSThread: 0x7ff419c11c50>{number = 1, name = main}

调度(队列)组

有时候会出现需要等待多个耗时操作执行完毕以后,在执行后续的处理.

通过下面的例子,来感受调度组的好处:

不使用调度组,主线程串行执行:

1.我们需要用3秒下载图片1

2.我们需要用4秒下载图片2

3.我们需要2秒把图片2画到图片1上.

总结:我们需要通过9秒.

不使用调度组,子线程并行执行:

1.我们需要3秒下载图片1,需要4秒下载图片2

2.判断是否图片1和图片2都下载完毕

3.需要2秒把图片2画在图片1上.

总结:我们只需要6秒.

缺点:1.我们需要手动判断是否图片1和图片2都下载完毕了.2.整个代码执行过程中,可能会引入多个辅助桥接的变量.

使用调度组,字线程并行执行:

1.创建调度组

2.把3秒下载图片1和4秒下载图片2丢入调度组

3.获得调度组执行结束通知后,执行2秒吧图片2画在图片1上(自动)

优点:我们不需要判断是否图片1和图片2是否都下载完毕了.

示例代码:

dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
// 并行执行的线程一
});
dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
// 并行执行的线程二
});
dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{
// 汇总结果
});

手动管理运行状态（或计数）

AFNetworking框架中会使用,了解就行,几乎不使用.

dispatch_group_enter(group);

dispatch_group_leave(group);

提示:进入和退出group次数必须匹配,有进入就必须有退出

示例代码:

// 自动
dispatch_group_async(group, queue, ^{ 

　　// 执行代码

}); 

// 手动,等价于自动

dispatch_group_enter(group);

dispatch_async(queue, ^{

　　//执行代码

　　dispatch_group_leave(group);

});

void dispatch_once ( dispatch_once_t *predicate, dispatch_block_t block );

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    <#code to be executed once#>
});

- (void)viewDidLoad {
    [super viewDidLoad];
    for (int i = 0;i < 10; ++i){
        [self once1];
    }
}
-(void)once1
{
    NSLog(@”< 重复测试 >”);
    static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@”hello,birdmichael”);
});
}

2015-08-03 01:23:31.058 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.058 GCD[91307:661637] hello,birdmichael
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.059 GCD[91307:661637] < 重复测试 >
2015-08-03 01:23:31.060 GCD[91307:661637] < 重复测试 >

void dispatch_apply ( size_t iterations, dispatch_queue_t queue, void (^block)(size_t) );

- (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument;

// 初始化线程
NSThread thread = [[NSThread alloc] initWithTarget:self selector:@selector(downImage) object:nil];
// 设置线程的优先级(0.0 - 1.0，1.0最高级)
thread.threadPriority = 1;
// 开启线程
[thread start];

+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;

[NSThread detachNewThreadSelector:@selector(downImage) toTarget:self withObject:nil];
// 调用完毕后，会马上创建并开启新线程

    [self performSelectorInBackground:<#(SEL)#> withObject:<#(id)#>]

    [self performSelector:<#(SEL)#> onThread:<#(NSThread )#> withObject:<#(id)#> waitUntilDone:<#(BOOL)#>];
    [self performSelector:<#(SEL)#> onThread:<#(NSThread )#> withObject:<#(id)#> waitUntilDone:<#(BOOL)#> modes:<#(NSArray )#>]

[self performSelectorInBackground:@selector(downIamge) withObject:nil];

+ (void)exit

// 休眠指定时常:2s
[NSThread sleepForTimeInterval:2];

// 休眠到指定时间:从现在开始后的2s
NSDate date = [NSDate dateWithTimeInterval:2 sinceDate:[NSDate date]];
[NSThread sleepUntilDate:date];

+ (NSThread )currentThread;

+ (NSThread )mainThread

+ (double)threadPriority;
+ (BOOL)setThreadPriority:(double)p;

@property double threadPriority NS_AVAILABLE(10_6, 4_0); // To be deprecated; use qualityOfService below

@property NSQualityOfService qualityOfService NS_AVAILABLE(10_10, 8_0); // read-only after the thread is started

/ The following Quality of Service (QoS) classifications are used to indicate to the system the nature and importance of work.  They are used by the system to manage a variety of resources.  Higher QoS classes receive more resources than lower ones during resource contention. /
typedef NS_ENUM(NSInteger, NSQualityOfService) {
    / UserInteractive QoS is used for work directly involved in providing an interactive UI such as processing events or drawing to the screen. /
    NSQualityOfServiceUserInteractive = 0x21,

    / UserInitiated QoS is used for performing work that has been explicitly requested by the user and for which results must be immediately presented in order to allow for further user interaction.  For example, loading an email after a user has selected it in a message list. /
    NSQualityOfServiceUserInitiated = 0x19,

    / Utility QoS is used for performing work which the user is unlikely to be immediately waiting for the results.  This work may have been requested by the user or initiated automatically, does not prevent the user from further interaction, often operates at user-visible timescales and may have its progress indicated to the user by a non-modal progress indicator.  This work will run in an energy-efficient manner, in deference to higher QoS work when resources are constrained.  For example, periodic content updates or bulk file operations such as media import. /
    NSQualityOfServiceUtility = 0x11,

    / Background QoS is used for work that is not user initiated or visible.  In general, a user is unaware that this work is even happening and it will run in the most efficient manner while giving the most deference to higher QoS work.  For example, pre-fetching content, search indexing, backups, and syncing of data with external systems. /
    NSQualityOfServiceBackground = 0x09,

    / Default QoS indicates the absence of QoS information.  Whenever possible QoS information will be inferred from other sources.  If such inference is not possible, a QoS between UserInitiated and Utility will be used. /
    NSQualityOfServiceDefault = -1
} NS_ENUM_AVAILABLE(10_10, 8_0);

    NSOperationQueue queue = [[NSOperationQueue alloc] init];

    [queue addOperationWithBlock:^{
        NSLog(@”耗时操作 %@”, [NSThread currentThread]);

        // 主线程更新 UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSLog(@”更新 UI %@”, [NSThread currentThread]);
        }];
    }];

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;

- (void)performSelector:(SEL)aSelector onThread:(NSThread )thr withObject:(id)arg waitUntilDone:(BOOL)wait;

- (void)touchesBegan:(NSSet )touches withEvent:(UIEvent )event
{

    NSLog(@”点击屏幕,确认开始执行–%@”,[NSThread currentThread]);
    // 串行异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@”开始下载图片,%@”,[NSThread currentThread]);

        NSLog(@”提示’图片正在下载,请等待’,%@”,[NSThread currentThread]);
        NSURL url = [NSURL URLWithString:@”http://birdmichael.com/wp-content/uploads/2015/07/GCD1.png“];
        NSData date = [NSData dataWithContentsOfURL:url];
        UIImage image = [UIImage imageWithData:date];

        NSLog(@”图片下载完成,%@”,[NSThread currentThread]);

    // 主线程异步>因为涉及到UI
        dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@”设置控件的背景为需要下载的图片(%@)-%@”,image,[NSThread currentThread]);
        });
    });

}

2015-08-02 14:45:08.039 GCD[72660:594772] 点击屏幕,确认开始执行–<NSThread: 0x7fd820d02b00>{number = 1, name = main}
2015-08-02 14:45:08.040 GCD[72660:594851] 开始下载图片,<NSThread: 0x7fd820d17740>{number = 2, name = (null)}
2015-08-02 14:45:08.040 GCD[72660:594851] 提示’图片正在下载,请等待’,<NSThread: 0x7fd820d17740>{number = 2, name = (null)}
2015-08-02 14:46:02.067 GCD[72660:594851] 图片下载完成,<NSThread: 0x7fd820d17740>{number = 2, name = (null)}
2015-08-02 14:46:02.068 GCD[72660:594772] 设置控件的背景为需要下载的图片(<UIImage: 0x7fd820cf5f20>, {2297, 2417})-<NSThread: 0x7fd820d02b00>{number = 1, name = main}

#import “ViewController.h”
@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView iconView;
@end

@implementation YYViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
}

-(void)touchesBegan:(NSSet )touches withEvent:(UIEvent )event
{

// 在子线程中调用download方法下载图片
    [self performSelectorInBackground:@selector(download) withObject:nil];
}
-(void)download
{
    //1.根据URL下载图片
    //从网络中下载图片
    NSURL urlstr=[NSURL URLWithString:@”http://birdmichael.com/wp-content/uploads/2015/07/GCD1.png“];

    //把图片转换为二进制的数据
    NSData data=[NSData dataWithContentsOfURL:urlstr];
    //把数据转换成图片
    UIImage image=[UIImage imageWithData:data];

    //2.回到主线程中设置图片
    [self performSelectorOnMainThread:@selector(settingImage:) withObject:image waitUntilDone:NO];
}

//设置显示图片
-(void)settingImage:(UIImage )image
{
    self.iconView.image=image;
}

#import “ViewController.h”
#import <NSData.h>

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView iconView;
@end

@implementation YYViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
}

-(void)touchesBegan:(NSSet )touches withEvent:(UIEvent )event
{
// 在子线程中调用download方法下载图片

    [self performSelectorInBackground:@selector(download) withObject:nil];
}

-(void)download
{

    //1.根据URL下载图片
    //从网络中下载图片
    NSURL urlstr=[NSURL URLWithString:@”fdsf”];

    //把图片转换为二进制的数据
    NSData data=[NSData dataWithContentsOfURL:urlstr];//这一行操作会比较耗时

    //把数据转换成图片
    UIImage image=[UIImage imageWithData:data];

    //2.回到主线程中设置图片
    //第一种方式
//    [self performSelectorOnMainThread:@selector(settingImage:) withObject:image waitUntilDone:NO];

    //第二种方式
    //    [self.imageView performSelector:@selector(setImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:NO];

    //第三种方式
   [self.iconView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:NO];
}

//设置显示图片
//-(void)settingImage:(UIImage )image
//{
//    self.iconView.image=image;
//}

@end

@synchronized(self){
        if (_imageNames.count>0) {
           // 加锁代码
        }
    }

dispatch_sync(_queue, ^{
  dispatch_sync(_queue, ^{
      //do something
  });
})

main() {
dispatch_sync(dispatch_get_main_queue(), ^{
  //do something
});
}

方法

NSInvocationOperation

start

start 方法 会在当前线程执行 @selector 方法,所以毫无意义,等价于直接self调用- (void)downloadImage:方法

-(void)bmDemo1{
    /*创建一个调用操作
     object:调用方法参数
    */
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"Invocation"];
    //创建完NSInvocationOperation对象并不会调用，它由一个start方法启动操作，但是注意如果直接调用start方法，则此操作会在主线程中调用，一般不会这么操作,而是添加到NSOperationQueue中
//    [invocationOperation start];

}
- (void)downloadImage:(id)obj {

    NSLog(@"%@ %@", [NSThread currentThread], obj);
}

添加到队列

将操作添加到队列，会异步执行 selector 方法

- (void)bmDemo2 {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"queue"];

    [queue addOperation:invocationOperation];
}

添加多个操作

会开启多条线程，而且不是顺序执行。与GCD中并发队列&异步执行效果一样！

- (void)bmDemo3 {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    for (int i = 0; i < 5; ++i) {
        NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@(i)];

        [queue addOperation:invocationOperation];
    }
}

结论

操作 -> 异步执行的任务

队列 -> 全局队列

提示:一般不使用,因为考虑到效率和便捷角度,这个方法都没任何意义.

NSBlockOperation

NSBlockOperation比NSInvocationOperation更加灵活,并且不需要准备一个被调用的方法.

将任务添加到操作

- (void)bmDemo1 {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSBlockOperation *NSBlockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];

    [queue addOperation:NSBlockOperation];
}

向队列中添加不同的操作

- (void)opDemo5 {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"block %@", [NSThread currentThread]);
    }];
    [queue addOperation:operation1];

    NSInvocationOperation *operation2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"invocation"];
    [queue addOperation:operation2];
}

- (void)demo1 
{
    BOOL isDone = NO;
    while (![self isCancelled] && !isDone) {     
        // ..code..
        if([self isCancelled]){
            return ;      
        }
        // ..code..
    }
}

NSOperation依赖关系

前面使用GCD很难在并行中控制线程的执行顺序,但是使用NSOperation就容易多了,每个NSOperation可以设置依赖线程.调用addDependency: 方法可以建立两个operation对象间的依赖关系.该方法创建了目标对象到当前对象之间的单向依赖关系.这个单向关系表明当前operation对象只有在目标operation对象执行完成之后才能执行.调用removeDependency:可以移除2个operation对象间的依赖关系.

operation对象的依赖关系不限于同一个操作队列.有依赖关系的operation对象可以添加到不同的操作队列中.但是operation之间不能添加循环依赖关系(A依赖于B,B依赖于A).

operation的依赖关系建立在operation对象间KVO消息的发送.自定义的operation对象需要在自定义代码中的合适位置来添加KVO通知.

换一句话说,设置依赖关系就是设置线程的执行顺序,并且采用蛇形结构,也就是说:我们想要先执行A,再执行B,最后执行C.那么就C依赖B,B依赖A.

示例代码

- (void)dependency {
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"登录 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"软件付费 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"获取下载链接 %@", [NSThread currentThread]);
    }];
    NSBlockOperation *operation4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"通知用户正在下载中 %@", [NSThread currentThread]);
    }];

    [operation2 addDependency:operation1];
    [operation3 addDependency:operation2];
    [operation4 addDependency:operation3];
    // 注意不要循环依赖
    //    [operation1 addDependency:operation4]; // 严重错误!!!

    [queue addOperations:@[operation1, operation2, operation3] waitUntilFinished:NO];
    [[NSOperationQueue mainQueue] addOperation:operation4];

    NSLog(@"欢迎界面,让用户下载");
}

输出结果

2015-08-07 05:33:06.812 NSThread[58353:1941467] 欢迎界面,让用户下载
2015-08-07 05:33:06.812 NSThread[58353:1941581] 登录 <NSThread: 0x7f875acaf660>{number = 2, name = (null)}
2015-08-07 05:33:06.820 NSThread[58353:1941581] 软件付费 <NSThread: 0x7f875acaf660>{number = 2, name = (null)}
2015-08-07 05:33:06.821 NSThread[58353:1941581] 获取下载链接 <NSThread: 0x7f875acaf660>{number = 2, name = (null)}
2015-08-07 05:33:06.822 NSThread[58353:1941467] 通知用户正在下载中 <NSThread: 0x7f875ac17380>{number = 1, name = main}

其他方法

Initialization

Executing the Operation

Waiting for Completion

队列中Operations的执行顺序

对于添加到queue中的operations，它们的执行顺序取决于2点：

1.首先看看NSOperation是否准备好了依赖关系.

2.然后再根据所有NSOperation的相对优先级来确定.优先级等级则是operation对象本身的一个属性.默认所有operation都拥有“普通”优先级,不过可以通过setQueuePriority:方法来提升或降低operation对象的优先级.优先级只能应用于相同queue中的operations.如果应用有多个operation queue,每个queue的优先级等级是互相独立的.因此不同queue中的低优先级操作仍然可能比高优先级操作更早执行.

注意：优先级不能替代依赖关系,优先级只是对已经准备好的 operations确定执行顺序.先满足依赖关系,然后再根据优先级从所有准备好的操作中选择优先级最高的那个执行.(多个operations单纯设计优先级无法精准控制)

最大并发操作数量

队列的最大并发操作数量,意思是队列中最多同时运行几条线程,默认情况下是-1,也就是没有限制,同时运行队列中的全部操作(但不一定有多少操作,就会开启多少线程,具体开启多少线程由系统来决定).

虽然NSOperationQueue类设计用于并发执行Operations,你也可以强制单个queue一次只能执行一个Operation.setMaxConcurrentOperationCount:方法可以配置queue的最大并发操作数量.设为1就表示queue每次只能执行一个操作.不过operation执行的顺序仍然依赖于其它因素,比如operation是否准备好和operation的优先级等.因此串行化的operation queue并不等同于GCD中的串行dispatch queue.

示例代码

// 每次只能执行一个操作  
queue.maxConcurrentOperationCount = 1;  
// 或者这样写  
[queue setMaxConcurrentOperationCount:1];

全局队列

方便操作队列,同一冠以所有异步操作(可以有效避免多次创建)

@property (nonatomic, strong) NSOperationQueue *queue;

- (NSOperationQueue *)queue {
    if (_queue == nil) {
        _queue = [[NSOperationQueue alloc] init];
    }
    return _queue;
}

暂停和继续

如果你想临时暂停Operations的执行,可以使用queue的setSuspended:方法暂停queue.不过暂停一个queue不会导致正在执行的operation在任务中途暂停,只是简单地阻止调度新Operation执行.你可以在响应用户请求时,暂停一个queue来暂停等待中的任务.稍后根据用户的请求,可以再次调用setSuspended:方法继续queue中operation的执行

比如用户滚动cell,立马暂停.滚动停止,立马恢复.

// 暂停queue
[queue setSuspended:YES];  

// 继续queue
[queue setSuspended:NO];

挂起和回复队列

调用NSOperationQueue对象的setSuspended: 方法可以操作队列挂起.挂起队列不会阻碍当前正在执行中的operation,它只是阻止新的operation的执行.为了响应用户请求,你可以关起任何当前正在处理的工作,因为用户可能会最终重新恢复队列执行.

取消Operations

一旦添加到operation queue,queue就拥有了这个Operation对象并且不能被删除,唯一能做的事情是取消.你可以调用Operation对象的cancel方法取消单个操作,也可以调用operation queue的cancelAllOperations方法取消当前queue中的所有操作.

比如类存警告时,就可能会用到.

示例代码

// 取消单个操作  
[operation cancel];  

// 取消queue中所有的操作  
[queue cancelAllOperations];

等待Options完成

为了最佳的性能,你应该设计你的应用尽可能地异步操作,让应用在Operation正在执行时可以去处理其它事情.如果需要在当前线程中处理operation完成后的结果,可以使用NSOperation的waitUntilFinished方法阻塞当前线程，等待operation完成.通常我们应该避免编写这样的代码,阻塞当前线程可能是一种简便的解决方案,但是它引入了更多的串行代码,限制了整个应用的并发性,同时也降低了用户体验.绝对不要在应用主线程中等待一个Operation,只能在第二或次要线程中等待.阻塞主线程将导致应用无法响应用户事件,应用也将表现为无响应。

// 会阻塞当前线程，等到某个operation执行完毕
[operation waitUntilFinished];

// 阻塞当前线程，等待queue的所有操作执行完毕
[queue waitUntilAllOperationsAreFinished];

提示:永远不能在主线程上等待一个operation结束。

开发建议

虽然可以向操作队列中添加任意数量的operation对象,但这么做其实是不现实的.如其它对象一样,NSoperation类的对象实例也是要消耗内存,并执行也会耗时.创建成千上万的完成小功能的operation对象,因过度派发和执行,会导致超出任务本身所需消耗的不良结果.如果应用程序本身的内存用量已很紧俏,那么在内存中包含了成千上万的operation对象会进一步降低你应用的性能.

使用operation对象的关键在于,在任务工作量与保证计算机时刻处于繁忙状态之间找到一个合理的平衡点.尝试确保operation对象所完成工作的合理性.例如,同时创建100个完成同样工作的operation对象,则不如分10次,每次同时创建10个该operation对象.

避免在同一个操作队列中一次添加大量的operation对象,避免添加operation的速度超过operation本身的执行速度的情况.一股脑的将所有operation对象添加到操作队列,则不如按批次添加.当一个批次完成之后,利用completion block来告诉应用程序来创建下一批次.有大量任务要处理时,尽量塞满操作队列会保证机器重复运转,但大量的operation对象会马上耗光你得内存.

总而言之,在使用operation时,尽量在效率和时间之间找到平衡点.

NSOperation.VS.GCD

1. NSOperation拥有更多的函数可用，具体查看api。NSOperationQueue 是在GCD基础上实现的，只不过是GCD更高一层的抽象。
2. 在NSOperationQueue中，可以建立各个NSOperation之间的依赖关系。
3. NSOperationQueue支持KVO。可以监测operation是否正在执行（isExecuted）、是否结束（isFinished），是否取消（isCanceld）
4. GCD 只支持FIFO 的队列，而NSOperationQueue可以调整队列的执行顺序（通过调整权重）。NSOperationQueue可以方便的管理并发、NSOperation之间的优先级。
5. 我们能够对NSOperation进行继承，在这之上添加成员变量与成员方法，提高整个代码的复用度，这比简单地将block任务排入执行队列更有自由度，能够在其之上添加更多自定制的功能。
   使用NSOperation的情况:各个操作之间有依赖关系、操作需要取消暂停、并发管理、控制操作之间优先级，限制同时能执行的线程数量.让线程在某时刻停止/继续等。

使用GCD的情况:一般的需求很简单的多线程操作,用GCD都可以了,简单高效.

从编程原则来说，一般我们需要尽可能的使用高等级,封装完美的API,在必须时才使用底层API.当需求简单,简洁的GCD或许是个更好的选择,而Operation queue 为我们提供能更多的选择.

RunLoop

在cocoa中讲到多线程，那么就不得不讲到RunLoop。 在ios/mac的编码中，我们似乎不需要过多关心代码是如何执行的，一切仿佛那么自然。比如我们知道当滑动手势时，tableView就会滚动，启动一个NSTimer之后，timer的方法就会定时执行， 但是为什么呢，其实是RunLoop在帮我们做这些事情：分发消息。

什么是RunLoop

你应该看过这样的伪代码解释ios的app中main函数做的事情：

int main(int argc, char * argv[])
{
    while (true) {
      [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    }
}

while (!complete) {
    [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
}

我们先思考一个问题： 当我们打开一个IOS应用之后，什么也不做，这时候看起来是没有代码在执行的，为什么应用没有退出呢？

我们在写c的简单的只有一个main函数的程序时就知道，当main的代码执行完，没有事情可做的时候，程序就执行完毕退出了。而我们IOS的应用是如何做到在没有事情做的时候维持应用的运行的呢? 那就是RunLoop。

RunLoop的字面意思就是“运行回路”，听起来像是一个循环。实际它就是一个循环，它在循环监听着事件源，把消息分发给线程来执行。RunLoop并不是线程，也不是并发机制，但是它在线程中的作用至关重要，它提供了一种异步执行代码的机制。

事件源

由图中可以看出NSRunLoop只处理两种源：输入源、时间源。而输入源又可以分为：NSPort、自定义源、performSelector:OnThread:delay:, 下面简单介绍下这几种源：

NSPort 基于端口的源

Cocoa和 Core Foundation 为使用端口相关的对象和函数创建的基于端口的源提供了内在支持。Cocoa中你从不需要直接创建输入源。你只需要简单的创建端口对象，并使用NSPort的方法将端口对象加入到run loop。端口对象会处理创建以及配置输入源。

NSPort一般分三种： NSMessagePort（基本废弃）、NSMachPort、 NSSocketPort。 系统中的NSURLConnection就是基于NSSocketPort进行通信的，所以当在后台线程中使用NSURLConnection 时，需要手动启动RunLoop, 因为后台线程中的RunLoop默认是没有启动的，后面会讲到。

自定义输入源

在Core Foundation程序中，必须使用CFRunLoopSourceRef类型相关的函数来创建自定义输入源，接着使用回调函数来配置输入源。Core Fundation会在恰当的时候调用回调函数，处理输入事件以及清理源。常见的触摸、滚动事件等就是该类源，由系统内部实现。

一般我们不会使用该种源，第三种情况已经满足我们的需求

performSelector:OnThread

Cocoa提供了可以在任一线程执行函数（perform selector）的输入源。和基于端口的源一样，perform selector请求会在目标线程上序列化，减缓许多在单个线程上容易引起的同步问题。而和基于端口的源不同的是，perform selector执行完后会自动清除出run loop。

此方法简单实用，使用也更广泛。

定时源

定时源就是NSTimer了，定时源在预设的时间点同步地传递消息。因为Timer是基于RunLoop的，也就决定了它不是实时的。

RunLoop观察者

我们可以通过创建CFRunLoopObserverRef对象来检测RunLoop的工作状态，它可以检测RunLoop的以下几种事件：

• Run loop入口
• Run loop将要开始定时
• Run loop将要处理输入源
• Run loop将要休眠
• Run loop被唤醒但又在执行唤醒事件前
• Run loop终止

Run Loop Modes

RunLoop对于上述四种事件源的监视，可以通过设置模式来决定监视哪些源。 RunLoop只会处理与当前模式相关联的源，未与当前模式关联的源则处于暂停状态。

cocoa和Core Foundation预先定义了一些模式（Apple文档翻译）：

Mode

Name

Description

Default

NSDefaultRunLoopMode (Cocoa) kCFRunLoopDefaultMode (Core Foundation)

缺省情况下，将包含所有操作，并且大多数情况下都会使用此模式

Connection

NSConnectionReplyMode (Cocoa)

此模式用于处理NSConnection的回调事件

Modal

NSModalPanelRunLoopMode (Cocoa)

模态模式，此模式下，RunLoop只对处理模态相关事件

Event Tracking

NSEventTrackingRunLoopMode (Cocoa)

此模式下用于处理窗口事件,鼠标事件等

Common Modes

NSRunLoopCommonModes (Cocoa) kCFRunLoopCommonModes (Core Foundation)

此模式用于配置”组模式”，一个输入源与此模式关联，则输入源与组中的所有模式相关联。



我们也可以自定义模式，可以参考ASIHttpRequest在同步执行时，自定义了 runLoop 的模式叫ASIHTTPRequestRunLoopMode。ASI的Timer源就关联了此模式。