1
#import <Foundation/Foundation.h>
2

3
int main(int argc, const char * argv[]) {
4
    @autoreleasepool {
5
        dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
6
        dispatch_sync(serialQueue, ^{
7
            for (int i = 0; i < 5; i++) {
8
                NSLog(@"1 %d == %@", i, [NSThread currentThread]);
9
            }
10
        });
11
        dispatch_sync(serialQueue, ^{
12
            for (int i = 0; i < 5; i++) {
13
                NSLog(@"2 %d == %@", i, [NSThread currentThread]);
14
            }
15
        });
16
    }
17
    return EXIT_SUCCESS;
18
}

1
#import <Foundation/Foundation.h>
2

3
int main(int argc, const char * argv[]) {
4
    @autoreleasepool {
5
        dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
6
        dispatch_async(serialQueue, ^{
7
            for (int i = 0; i < 5; i++) {
8
                NSLog(@"1 %d == %@", i, [NSThread currentThread]);
9
            }
10
        });
11
        dispatch_async(serialQueue, ^{
12
            for (int i = 0; i < 5; i++) {
13
                NSLog(@"2 %d == %@", i, [NSThread currentThread]);
14
            }
15
        });
16
        sleep(2);    //如果没有sleep，那么程序直接退出而没有输出
17
    }
18
    return EXIT_SUCCESS;
19
}

1
#import <Foundation/Foundation.h>
2

3
int main(int argc, const char * argv[]) {
4
    @autoreleasepool {
5
        dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
6
        dispatch_async(serialQueue, ^{
7
            for (int i = 0; i < 5; i++) {
8
                NSLog(@"1 %d == %@", i, [NSThread currentThread]);
9
            }
10
        });
11
        dispatch_async(serialQueue, ^{
12
            for (int i = 0; i < 5; i++) {
13
                NSLog(@"2 %d == %@", i, [NSThread currentThread]);
14
            }
15
        });
16
        sleep(2);    //如果没有sleep，那么程序直接退出而没有输出
17
    }
18
    return EXIT_SUCCESS;
19
}

1
int main(int argc, const char * argv[]) {
2
    @autoreleasepool {
3
        dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
4
        dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
5
        dispatch_sync(concurrentQueue, ^{
6
            for (int i = 0; i < 5; i++) {
7
                NSLog(@"1 %d == %@", i, [NSThread currentThread]);
8
                //sleep(1);
9
            }
10
        });
11
        dispatch_sync(concurrentQueue, ^{
12
            for (int i = 0; i < 5; i++) {
13
                NSLog(@"2 %d == %@", i, [NSThread currentThread]);
14
            }
15
        });
16
        //sleep(2);
17
    }
18
    return EXIT_SUCCESS;
19
}

1
int main(int argc, const char * argv[]) {
2
    @autoreleasepool {
3
        dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
4
        dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
5
        dispatch_async(concurrentQueue, ^{
6
            for (int i = 0; i < 5; i++) {
7
                NSLog(@"1 %d == %@", i, [NSThread currentThread]);
8
                //sleep(1);
9
            }
10
        });
11
        dispatch_async(concurrentQueue, ^{
12
            for (int i = 0; i < 5; i++) {
13
                NSLog(@"2 %d == %@", i, [NSThread currentThread]);
14
            }
15
        });
16
        sleep(2);
17
    }
18
    return EXIT_SUCCESS;
19
}

1
- (void)interview01{//并行队列
2
    dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
3
    NSLog(@"1");// 耗时
4
    dispatch_async(queue, ^{
5
        NSLog(@"2");
6
        dispatch_async(queue, ^{
7
            NSLog(@"3");
8
        });
9
        NSLog(@"4");
10
    });
11
    NSLog(@"5");
12
}
13
    ----------打印结果-----------
14
输出顺序为：1 5 2 4 3

1
dispatch_semaphore_t sem = dispatch_semaphore_create(0);
2
dispatch_async(dispatch_get_main_queue(), ^{
3
    dispatch_semaphore_signal(sem);
4
    NSLog(@"the sem +1");
5
});
6
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
7
NSLog(@"the sem -1");

1
dispatch_set_target_queue(serialQueue, globalDispatchQueueBackGround);

1
dispatch_semaphore_t currSingal = dispatch_semaphore_create(value);// 创建信号量,如果小于0则会返回NULL
2
dispatch_semaphore_signal(dispatch_semaphore_t  _Nonnull dsema); // 发送信号量让信号量加1
3
dispatch_semaphore_wait(dispatch_semaphore_t  _Nonnull dsema, dispatch_time_t timeout); // 可以让总信号量减1,信号量小于0的时候就会一直等待,否则就可以正常执行

1
dispatch_once
2
- (void)cjl_testOnce{
3
    /*
4
     dispatch_once保证在App运行期间，block中的代码只执行一次
5
     应用场景：单例、method-Swizzling
6
     */
7
    static dispatch_once_t onceToken;
8
    dispatch_once(&onceToken, ^{
9
        //创建单例、method swizzled或其他任务
10
        NSLog(@"创建单例");
11
    });
12
}
13
#### dispatch_apply
14

15

16
按照指定的次数将指定的任务追加到指定的队列中，快速迭代一组任务，并等待全部队列执行结束。主要用于需要快速并行处理大量相同类型任务的场景，如图像处理、数据处理或任何形式的批处理任务。
17

18

19
在串行队列中无法体现出它的作用，因为队列中的任务始终是一次执行一个。
20

21

22
在并发队列中如果开启了多个线程的话就能在多个线程中同时展开执行，效率特别高。
23

24

25
```objective-c
26
- (void)cjl_testApply{
27
    /*
28
     dispatch_apply将指定的Block追加到指定的队列中重复执行，并等到全部的处理执行结束——相当于线程安全的for循环
29

30
     应用场景：用来拉取网络数据后提前算出各个控件的大小，防止绘制时计算，提高表单滑动流畅性
31
     - 添加到串行队列中——按序执行
32
     - 添加到主队列中——死锁
33
     - 添加到并发队列中——乱序执行
34
     - 添加到全局队列中——乱序执行
35
     */
36

37
    dispatch_queue_t queue = dispatch_queue_create("CJL", DISPATCH_QUEUE_SERIAL);
38
    NSLog(@"dispatch_apply前");
39
    /**
40
         param1：重复次数
41
         param2：追加的队列
42
         param3：执行任务
43
         */
44
    dispatch_apply(10, queue, ^(size_t index) {
45
        NSLog(@"dispatch_apply 的线程 %zu - %@", index, [NSThread currentThread]);
46
    });
47
    NSLog(@"dispatch_apply后");
48
}
49
#### dispatch_group_t
50

51

52
notify的作用就是：**当 group 中所有任务完成（enter/leave 配对完或者 dispatch_group_async 内 block 执行完）时，执行 block。**
53

54

55
##### dispatch_group_async + dispatch_group_notify
56

57

58
```objective-c
59
- (void)cjl_testGroup1{
60
    /*
61
     dispatch_group_t：调度组将任务分组执行，能监听任务组完成，并设置等待时间
62

63
     应用场景：多个接口请求之后刷新页面
64
     */
65

66
    dispatch_group_t group = dispatch_group_create();
67
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
68

69
    dispatch_group_async(group, queue, ^{
70
        NSLog(@"请求一完成");
71
    });
72

73
    dispatch_group_async(group, queue, ^{
74
        NSLog(@"请求二完成");
75
    });
76

77
    // 当group内所有任务完成时，这个block会在主线程执行。很适合UI刷新，不阻塞主线程
78

79
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
80
        NSLog(@"刷新页面");
81
    });
82
}
83
##### dispatch_group_enter + dispatch_group_leave + dispatch_group_notify
84

85

86
```objective-c
87
- (void)cjl_testGroup2{
88
    /*
89
     dispatch_group_enter和dispatch_group_leave成对出现，使进出组的逻辑更加清晰
90
     */
91
    dispatch_group_t group = dispatch_group_create();
92
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
93

94
    dispatch_group_enter(group);
95
    dispatch_async(queue, ^{
96
        NSLog(@"请求一完成");
97
        dispatch_group_leave(group);
98
    });
99

100
    dispatch_group_enter(group);
101
    dispatch_async(queue, ^{
102
        NSLog(@"请求二完成");
103
        dispatch_group_leave(group);
104
    });
105

106
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
107
        NSLog(@"刷新界面");
108
    });
109
}

1
- (void)cjl_testSource{
2
    /*
3
     dispatch_source
4

5
     应用场景：GCDTimer
6
     在iOS开发中一般使用NSTimer来处理定时逻辑，但NSTimer是依赖Runloop的，而Runloop可以运行在不同的模式下。如果NSTimer添加在一种模式下，当Runloop运行在其他模式下的时候，定时器就挂机了；又如果Runloop在阻塞状态，NSTimer触发时间就会推迟到下一个Runloop周期。因此NSTimer在计时上会有误差，并不是特别精确，而GCD定时器不依赖Runloop，计时精度要高很多
7

8
     dispatch_source是一种基本的数据类型，可以用来监听一些底层的系统事件
9
        - Timer Dispatch Source：定时器事件源，用来生成周期性的通知或回调
10
        - Signal Dispatch Source：监听信号事件源，当有UNIX信号发生时会通知
11
        - Descriptor Dispatch Source：监听文件或socket事件源，当文件或socket数据发生变化时会通知
12
        - Process Dispatch Source：监听进程事件源，与进程相关的事件通知
13
        - Mach port Dispatch Source：监听Mach端口事件源
14
        - Custom Dispatch Source：监听自定义事件源
15

16
     主要使用的API：
17
        - dispatch_source_create: 创建事件源
18
        - dispatch_source_set_event_handler: 设置数据源回调
19
        - dispatch_source_merge_data: 设置事件源数据
20
        - dispatch_source_get_data： 获取事件源数据
21
        - dispatch_resume: 继续
22
        - dispatch_suspend: 挂起
23
        - dispatch_cancle: 取消
24
     */
25

26
    //1.创建队列
27
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
28
    //2.创建timer
29
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
30
    //3.设置timer首次执行时间，间隔，精确度
31
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2.0*NSEC_PER_SEC, 0.1*NSEC_PER_SEC);
32
    //4.设置timer事件回调
33
    dispatch_source_set_event_handler(timer, ^{
34
        NSLog(@"GCDTimer");
35
    });
36
    //5.默认是挂起状态，需要手动激活
37
    dispatch_resume(timer);
38

39
}
40
#### disoatch_suspend & dispatch_resume
41

42

43
这两个函数可以随时挂起某个队列，等需要执行的时候恢复即可
44

45

46
```objective-c
47
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
48
    dispatch_suspend(queue);
49
    dispatch_resume(queue);