iOS-线程之GCD方式---之同步异步和串行队列并行队列之间的关系

GCD方式是Apple官方推荐实现多线程的方式

但在这之前必须理清楚同步,异步,串行队列,并行队列之间的概念.

同步:即当前的执行程序块不会创建一个新的线程,只能在当前线程中执行.

异步:会在当前的线程之外创建一个新的线程,并在新的线程中执行代码块.

首先声明一点,队列是用来存放即将执行的线程体的.

串行队列:串行队列中的线程满足FIFO(First In First Out),并且只有在先出的线程执行完,后续的线程才能出队列执行.(很可能造成APP的假死状态)

并行队列:并行队列也满足FIFO,只有利用并行队列和异步的方式配合才能实现多线程同时执行(后面会讲到)

下面的代码部分的四种情况

1.串行队列和同步方式(不推荐使用)

//1.同步方式向串行队列提交代码
//前面的线程执行完成后,才会开始执行后面的线程
- (void)testSyncWithSerialQueue
{
    //串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
    
    //线程一
    dispatch_sync(serialQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程一:%d",i);
        }
    });
    
    //线程二
    dispatch_sync(serialQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程二:%d",i);
        }
    });
}

执行结果及结论:---前面的线程执行完成后,才会开始执行后面的线程

2015-08-08 19:59:35.730 TestAsyncAndSync[3187:141197] 线程一:96

2015-08-08 19:59:35.730 TestAsyncAndSync[3187:141197] 线程一:97

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程一:98

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程一:99

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程二:0

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程二:1

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程二:2

2015-08-08 19:59:35.731 TestAsyncAndSync[3187:141197] 线程二:3

 

2.串行队列和异步方式

- (void)testAsyncWithSerialQueue
{
    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
    //异步,线程一
    dispatch_async(serialQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程1:%d",i);
        }
    });
    
    //异步:线程二
    dispatch_async(serialQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程2:%d",i);
        }
    });
}

执行结果及结论:串行队列前面的线程执行完才能执行后面的线程

2015-08-08 20:03:28.391 TestAsyncAndSync[3225:143307] 线程1:97

2015-08-08 20:03:28.391 TestAsyncAndSync[3225:143307] 线程1:98

2015-08-08 20:03:28.391 TestAsyncAndSync[3225:143307] 线程1:99

2015-08-08 20:03:28.391 TestAsyncAndSync[3225:143307] 线程2:0

2015-08-08 20:03:28.391 TestAsyncAndSync[3225:143307] 线程2:1

2015-08-08 20:03:28.392 TestAsyncAndSync[3225:143307] 线程2:2

 

3.并行队列和同步方式创建线程

- (void)testSyncWithConcurrentQueue
{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    //线程一
    dispatch_sync(concurrentQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程一:%d",i);
        }
    });
    
    //线程一
    dispatch_sync(concurrentQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程二:%d",i);
        }
    });
}

结果和结论:先执行线程一,再执行线程二

2015-08-08 20:06:19.111 TestAsyncAndSync[3257:144554] 线程一:97

2015-08-08 20:06:19.111 TestAsyncAndSync[3257:144554] 线程一:98

2015-08-08 20:06:19.111 TestAsyncAndSync[3257:144554] 线程一:99

2015-08-08 20:06:19.112 TestAsyncAndSync[3257:144554] 线程二:0

2015-08-08 20:06:19.112 TestAsyncAndSync[3257:144554] 线程二:1

2015-08-08 20:06:19.112 TestAsyncAndSync[3257:144554] 线程二:2

 

4.并行队列和异步方式

- (void)testAsyncWithConcurrentQueue
{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    //异步,线程一
    dispatch_async(concurrentQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程1:%d",i);
        }
    });
    
    //异步:线程二
    dispatch_async(concurrentQueue, ^(void){
        for (int i=0; i<100; i++) {
            NSLog(@"线程2:%d",i);
        }
    });
    
}

执行结果及结论:线程一和线程二同时执行

2015-08-08 20:07:48.318 TestAsyncAndSync[3283:145696] 线程1:0

2015-08-08 20:07:48.318 TestAsyncAndSync[3283:145693] 线程2:0

2015-08-08 20:07:48.319 TestAsyncAndSync[3283:145693] 线程2:1

2015-08-08 20:07:48.319 TestAsyncAndSync[3283:145693] 线程2:2

2015-08-08 20:07:48.319 TestAsyncAndSync[3283:145693] 线程2:3

2015-08-08 20:07:48.319 TestAsyncAndSync[3283:145696] 线程1:1

 

再解释上述的四种情况:不得不说,线程队列是一种神奇的东西,似乎无法控制,又有迹可循...

为什么会造成上面的四种情况呢:

首先来说说第四种情况,异步方式创建线程并使用并行队列存放.主要是因为并行队列允许队列中的线程体出队列后,立马下一个线程体就可以出队列.而使用异步的方式,每一个出来的线程体会创建一个新的线程执行对应的代码块.所以就产生两个线程同时执行的情况.(但是也有让你感到无力的,你无法完全的控制两个线程,即使先出队列线程,也不一定先执行完,线程执行的快慢主要在于两个线程抢占系统资源获得的多少)

第一种和第二种情况:由于串行只允许先进队列的线程,出队列后执行完才能再下一个线程出队列,所以一定是有序(根据进队列的先后)

第三种情况:并行同步方式:虽然并行队列允许多个线程同时出队列(还是先进先出的方式),但是先出的线程不会创建新的线程,只能在当前线程中执行任务,由于当前线程只有一个,所有即使同时出队列多个线程,也只能出于等待.