多线程之GCD使用

上文已经介绍了GCD的一些基本概念多线程操作之GCD概述

GCD 的使用步骤

  1. 创建一个队列(串行队列或并发队列)
  2. 将任务追加到任务的等待队列中,然后系统会根据任务类型执行任务(同步执行或异步执行)

1.队列的创建

可以使用dispatch_queue_create来创建队列,需要传入两个参数,参数一表示:队列的唯一标识符,用于 DEBUG,可为空;参数二:用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列,DISPATCH_QUEUE_CONCURRENT 表示并发队列。

    // 串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);
    // 并发队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_CONCURRENT);
    
  • 对于串行队列,GCD提供了一个特殊的串行队列,主队列Main Dispatch Queue
  • 所有放在主队列中的任务,都会放到主线程中执行,不会开辟新的线程。
  • 可使用dispatch_get_main_queue()获得主队列。
    //主队列的获取方法
    dispatch_get_main_queue()
  • 对于并发队列,GCD默认提供了全局并发队列
  • 可以使用dispatch_get_global_queue来获取。参数一:表示队列优先级,一般用DISPATCH_QUEUE_PRIORITY_DEFAULT或者0,参数二: 一般用0即可
    //全局并发队列的获取方法
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
    

2. 任务的创建

  • GCD提供了同步执行任务的创建方法为:dispatch_sync
  • 异步执行任务的创建方法为:dispatch_async
// 同步执行任务创建方法
dispatch_sync(queue, ^{
    // 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
    // 这里放异步执行任务代码
});

在这里可以看出,执行任务的时候需要添加相应的队列(串行队列or并发队列);组合起来就有四种不同的方式:

  1. 同步执行 + 并发队列
  2. 异步执行 + 并发队列
  3. 同步执行 + 串行队列
  4. 异步执行 + 串行队列

注意这里还有上面说的两种队列:全局并发队列和主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊,加一起就6种不同的组合方式了

  1. 同步执行 + 主队列
  2. 异步执行 + 主队列

3.GCD的基本使用

先来讲讲并发队列的两种执行方式。

3.1 同步执行 + 并发队列

在当前线程中执行任务,不会开启新线程,执行完一个任务之后再执行下一个任务。

/**
 * 同步执行 + 并发队列
 * 特点:在当前线程中执行任务,不会开启新线程,执行完一个任务,再执行下一个任务。
 */
- (void)syncConcurrent {
    
    NSLog(@"currentThread--->%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"--->begin");
    dispatch_sync(self.concurrentQueue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(self.concurrentQueue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

currentThread--->{number = 1, name = main}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end

同步执行 + 并发队列中可看到:

  • 所有任务都在当前线程(主线程)中执行,没有开启新的线程(同步执行不具备开启新线程的能力)
  • 所有任务都在打印的---begin---end之间执行的(同步任务需要等待队列的任务执行结束,才能执行下一个)
  • 任务按顺序执行的。不能同时被执行。按顺序执行的原因:虽然 并发队列可以开启多个线程,并且同时执行多个任务。但是因为本身不能创建新线程,只有当前线程这一个线程(同步任务不具备开启新线程的能力),所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后,才能继续接着执行下面的操作(同步任务需要等待队列的任务执行结束)。所以任务只能一个接一个按顺序执行,不能同时被执行。

3.2 异步执行 + 并发队列

可以开启多个线程,任务交替(同时)执行。

/**
 * 异步执行 + 并发队列
 * 特点:可以开启多个线程, 任务交替 (同时) 执行。
 */
- (void)asyncConcurrent {
    // 打印当前线程
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    NSLog(@"--->>begin");
    dispatch_async(self.concurrentQueue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_async(self.concurrentQueue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

 currentThread--->{number = 1, name = main}
--->>begin
--->end
1--->{number = 3, name = (null)}
2--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}
1--->{number = 3, name = (null)}

异步执行+并发队列中可以看出

  • 除了当前线程(主线程),系统又新开启了个新线程,并且任务是 同时/交替 执行的(异步执行具备开启新线程的能力,且并发队列可开启多个线程,同时执行多个任务)
  • 所有任务都是从打印---begin---end之后才执行的,说明当前线程没有等待,而是直接开启了新的线程,在新线程中执行任务(异步执行不做等待,可以继续执行任务)

接下来再来说说串行队列的两种执行方式。

3.3 同步执行 + 串行队列

不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。

/*
 * 同步执行 + 串行队列
 * 特点: 不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。
 */
- (void)syncSerial {
    // 打印当前线程
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    NSLog(@"--->begin");
    dispatch_sync(self.serialQueue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(self.serialQueue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
             // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

currentThread--->{number = 1, name = main}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end

同步执行 + 串行队列可以看到:

  • 同步执行 + 并发队列类似
  • 所有任务都在当前线程(主线程)中执行,没有开启新的线程(同步执行不具备开启新线程的能力)
  • 所有任务都在打印的---begin---end之间执行的(同步任务需要等待队列的任务执行结束,才能执行下一个)
  • 任务按顺序执行的,只能一个接一个按顺序执行(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)

3.4 异步执行 + 串行队列

会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务

/**
 * 异步执行 + 串行队列
 * 特点:会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务。
 */
- (void)asyncSerial {
     // 打印当前线程
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    NSLog(@"--->begin");
    dispatch_async(self.serialQueue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
             // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_async(self.serialQueue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

currentThread--->{number = 1, name = main}
--->begin
--->end
1--->{number = 4, name = (null)}
1--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}

异步执行 + 串行队列中可以看到:

  • 只开启了一个新线程(异步执行具备开启新线程的能力,串行队列只开启一个线程)。
  • 所有任务都在打印的---begin---end之后执行的(异步执行不需要任何等待,可以继续执行任务)
  • 任务是按顺序执行的(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)。

主队列

主队列是GCD自带的一种特殊的串行队列

我们再来看看主队列的两种组合方式。

3.5 同步执行 + 主队列

同步执行 + 主队列 在不同线程中调用结果也是不一样,在主线程中调用会出现 死锁 ,而在其他线程中则不会。

3.5.1 在主线程中调用 同步执行 + 主队列

互相等待卡住不可行

/**
 * 同步执行 + 主队列
 * 特点(主线程调用):互等卡主不执行。
 * 特点(其他线程调用):不会开启新线程,执行完一个任务,再执行下一个任务。
 */
- (void)syncMain {
    // 打印当前线程
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    NSLog(@"--->begin");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
              // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
             // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
             // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

currentThread--->{number = 1, name = main}
--->begin
(lldb) 

同步执行 + 主队列中可以发现

  • 在主线程中使用同步执行 + 主队列,追加到主线程的任务1任务2都不再执行了,而且--end也没有打印,在XCode 9上还会报崩溃。这是为什么呢?

这是因为我们在主线程中执行syncMain方法,相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕,才会接着执行。那么当我们把任务1追加到主队列中,任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕,才能接着执行。形成了相互等待!

所以,现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待,所以就卡住了,所以我们的任务执行不了,而且---end也没有打印。

要是如果不在主线程中调用,而在其他线程中调用会如何呢?

3.5.2 在其他线程中调用 同步执行 + 主队列

不会开启新线程,执行完一个任务,再执行下一个任务。

    // 使用 NSThread 的 detachNewThreadSelector 方法会创建线程,并自动启动线程执行selector 任务
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

输出结果

currentThread--->{number = 4, name = (null)}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end

在其他线程中使用同步执行 + 主队列 可看到:

  • 所有任务都是在主线程(非当前线程)中执行的,没有开启新的线程(所有放在主队列中的任务,都会放到主线程中执行)。
  • 所有任务都在打印的---begin---end之间执行(同步任务需要等待队列的任务执行结束)。
  • 任务是按顺序执行的(主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)。

为什么现在就不会卡住了呢?
因为syncMain 任务放到了其他线程里,而任务1、任务2都在追加到主队列中,这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中,因为主队列现在没有正在执行的任务,所以,会直接执行主队列的任务1,等任务1执行完毕,再接着执行任务2,所以这里不会卡住线程。

4.6 异步执行 + 主队列

只在主线程中执行任务,执行完一个任务,再执行下一个任务。

/**
 * 异步执行 + 主队列
 * 特点:只在主线程中执行任务,执行完一个任务,再执行下一个任务
 */
- (void)asyncMain {
    // 打印当前线程
    NSLog(@"currentThread--->%@",[NSThread currentThread]); 
    NSLog(@"--->begin");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
            // 打印当前线程
            NSLog(@"1--->%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
             // 模拟耗时操作
            [NSThread sleepForTimeInterval:2];
             // 打印当前线程
            NSLog(@"2--->%@",[NSThread currentThread]);
        }
    });
    NSLog(@"--->end");
}

输出结果

currentThread--->{number = 1, name = main}
--->begin
--->end
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}

异步执行 + 主队列 可以看到:

  • 所有任务都是在当前线程(主线程)中执行的,并没有开启新的线程(虽然异步执行具备开启线程的能力,但因为是主队列,所以所有任务都在主线程中)。
  • 所有任务是在打印的---begin---end之后才开始执行的(异步执行不会做任何等待,可以继续执行任务)。
  • 任务是按顺序执行的(因为主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)

5.线程死锁

  • 主线程中使用 同步执行 + 主队列
  • 串行异步嵌套同步
  • NSOperation相互依赖
// 主线程中使用 同步执行 + 主队列*
- (void)deadlock1 {
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    dispatch_sync(dispatch_get_main_queue(), ^{
       for (int i = 0; i < 2; ++i) {
           // 打印当前线程
           NSLog(@"1--->%@",[NSThread currentThread]);
       }
    });
    NSLog(@"--->end");
}
// 串行异步嵌套同步(当前线程是主线程还是子线程都一样)
- (void)deadlock2 {
    NSLog(@"currentThread--->%@",[NSThread currentThread]);
    dispatch_async(self.serialQueue, ^{
        NSLog(@"1--->%@",[NSThread currentThread]);
        dispatch_sync(self.serialQueue, ^{
            NSLog(@"2--->%@",[NSThread currentThread]);
        });
        NSLog(@"3--->%@",[NSThread currentThread]);
    });
    NSLog(@"--->end");
}

串行异步嵌套同步造成死锁的原因:因为串行队列任务是一个一个的执行完成,而同步任务也是要求任务上一个任务完成以后,才能继续进行下一个,这样就造成了相互等待。

Demo地址

你可能感兴趣的:(多线程之GCD使用)