多线程之GCD使用

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

GCD 的使用步骤

创建一个队列（串行队列或并发队列）
将任务追加到任务的等待队列中，然后系统会根据任务类型执行任务（同步执行或异步执行）

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并发队列）；组合起来就有四种不同的方式：

同步执行 + 并发队列
异步执行 + 并发队列
同步执行 + 串行队列
异步执行 + 串行队列

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

同步执行 + 主队列
异步执行 + 主队列

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使用

GCD 的使用步骤

1.队列的创建

2. 任务的创建

3.GCD的基本使用

3.1 同步执行 + 并发队列

3.2 异步执行 + 并发队列

3.3 同步执行 + 串行队列

3.4 异步执行 + 串行队列

3.5 同步执行 + 主队列

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

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

4.6 异步执行 + 主队列

5.线程死锁

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

3.`GCD`的基本使用

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

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