【iOS】多线程与GCD

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重复提交到指定队列，并等待全部迭代结束；并发迭代访问共享可变数据时仍需自行同步。
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被阻塞时，回调可能推迟。GCD定时器不依赖RunLoop，但仍受系统调度和leeway影响，不能保证准时触发。
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
`dispatch_suspend` / `dispatch_resume` 用于暂停和恢复应用拥有的队列或 source；挂起与恢复必须配对。不要对系统提供的 global queue 使用它们。
44

45

46
```objective-c
47
dispatch_queue_t queue = dispatch_queue_create("com.example.suspendable", DISPATCH_QUEUE_SERIAL);
48
dispatch_suspend(queue);
49
dispatch_resume(queue);