Please enable JavaScript.

Coggle requires JavaScript to display documents.

GCD总结 (其他方法 (GCD 信号量：dispatch_semaphore GCD 中的信号量是指 Dispatch…

GCD总结

其他方法

GCD 信号量：dispatch_semaphore

GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。

dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加1
dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

用途:保持线程同步，将异步执行任务转换为同步执行任务
    保证线程安全，为线程加锁

Dispatch Semaphore 线程同步

//异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
    __block NSArray *tasks = nil;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
            tasks = dataTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
            tasks = uploadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
            tasks = downloadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
            tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
        }
        dispatch_semaphore_signal(semaphore);
    }];
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    return tasks;
}

//下面，我们来利用 Dispatch Semaphore 实现线程同步，将异步执行任务转换为同步执行任务。
- (void)semaphoreSync {
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    __block int number = 0;
    dispatch_async(dispatch_get_global_queue(0,0), ^{
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        number = 100;
        dispatch_semaphore_signal(semaphore);
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);
}

线程安全（使用 semaphore 加锁）

//create的value表示，最多几个资源可访问
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);   
dispatch_async(dispatch_get_global_queue(0,0), ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//相当于加锁
    NSLog(@"run task 1");
    sleep(1);
    NSLog(@"complete task 1");
    dispatch_semaphore_signal(semaphore);    // 相当于解锁   
});

栅栏方法：dispatch_barrier_async

//dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{

    });
    dispatch_barrier_async(queue, ^{

    });

    dispatch_async(queue, ^{
    });
}

GCD 延时执行方法：dispatch_after

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

});

GCD 一次性代码（只执行一次）：dispatch_once

- (void)sharedInstance {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行1次的代码(这里面默认是线程安全的)
    });
}

GCD 快速迭代方法：dispatch_apply

//通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

dispatch_apply(6, dispatch_get_global_queue(0,0), ^(size_t index) {

});

GCD 队列组：dispatch_group

//队列组 dispatch_group_notify监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务

dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{

});

dispatch_group_wait

//暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{

});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

队列组dispatch_group_enter、dispatch_group_leave

dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。
- (void)groupEnterAndLeave{
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_enter(group);
    dispatch_async(dispatch_get_global_queue(0,0), ^{
        // 追加任务1
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务2
        dispatch_group_leave(group);
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
    });

补充:dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async

dispatch_queue_set_specific 、dispatch_get_specific

这两个API类似于objc_setAssociatedObject跟objc_getAssociatedObject，FMDB里就用到这个来防止死锁，
static const void * const kDispatchQueueSpecificKey = &kDispatchQueueSpecificKey;
//创建一个串行队列来执行数据库的所有操作
 _queue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL);

 //通过key标示队列，设置context为self
 dispatch_queue_set_specific(_queue, kDispatchQueueSpecificKey, (__bridge void *)self, NULL);
当要执行数据库操作时，如果在queue里面的block执行过程中，又调用了 indatabase方法，需要检查是不是同一个queue，因为同一个queue的话会产生死锁情况

- (void)inDatabase:(void (^)(FMDatabase *db))block {
    FMDatabaseQueue *currentSyncQueue = (__bridge id)dispatch_get_specific(kDispatchQueueSpecificKey);
    assert(currentSyncQueue != self && "inDatabase: was called reentrantly on the same queue, which would lead to a deadlock");
}

GCD线程间通讯

1.常见的线程间通信 GCD

dispatch_async(dispatch_get_global_queue(0, 0), ^{
    //数据处理
    dispatch_async(dispatch_get_main_queue(), ^{
      //刷新UI
    });
});

2.使用系统的全局队列：一般用这个处理遍历大数据查询操作

// 全局并发队列执行处理大量逻辑时使用   
dispatch_async(dispatch_get_global_queue(0, 0), ^{

});

3.需要单线程访问的时候，我们可以采取同步线程的做法，来保证数据的正常执行

//当我们需要执行一些数据安全操作写入的时候，需要同步操作，后面所有的任务要等待当前线程的执行
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
   //同步线程操作可以保证数据的安全完整性

});

其他 - NSObject中的对象线程访问模式

1.我们介绍简单的perfermselecter选择器实现线程通信

//数据请求完毕回调到主线程，更新UI资源信息  waitUntilDone 设置YES ，代表等待当前线程执行完毕
 [self performSelectorOnMainThread:@selector(dothing:) withObject:@[@"1"] waitUntilDone:YES];

补充: waitUntilDone的含义:传入YES: 那么会等到主线程中的方法执行完毕, 才会继续执行下面其他行的代码;传入NO: 那么不用等到主线程中的方法执行完毕, 就可以继续执行下面其他行的代码

2.如果需要执行到后台线程，则直接前往后台线程执行即可

//将当前的逻辑转到后台线程去执行
[self performSelectorInBackground:@selector(dothing:) withObject:@[@"2"]];

3.自己定义线程，将当前数据转移到指定的线程内去通信操作

//支持自定义线程通信执行相应的操作
NSThread *thread = [[NSThread alloc]init];
[thread start];
//当我们需要在特定的线程内去执行某一些数据的时候，我们需要指定某一个线程操作
[self performSelector:@selector(dothing:) onThread:thread withObject:nil waitUntilDone:YES];
//支持自定义线程通信执行相应的操作
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(dothing) object:nil];
[thread start];

备注:dothing需要手动开启自动释放池
@autoreleasepool {
}

4.增加一个特殊的线程常驻RunLoop 的做法

需求：我们经常要用到常驻线程来请求数据，但是请求有时候在线程会退出，这个时候我们需要用一下方法：

//有时候需要线程单独跑一个RunLoop 来保证我们的请求对象存在，不至于会被系统释放掉
    NSThread *runLoopThread = [[NSThread alloc]initWithTarget:self selector:@selector(entryThreadPoint) object:nil];
    [runLoopThread start];
    [self performSelector:@selector(handleMutiData) onThread:runLoopThread withObject:nil waitUntilDone:YES];
    //给线程增加一个run loop 来保持对象的引用
- (void)entryThreadPoint{
    @autoreleasepool {
        [NSThread currentThread].name = @"自定义线程名字";
        NSRunLoop *runloop = [NSRunLoop currentRunLoop];
        [runloop addPort:[NSPort port] forMode:NSDefaultRunLoopMode];
        [runloop run];
    }
}
- (void)handleMutiData{
    NSLog(@"## 我是跑在runloop的线程 ##");
}

GCD概述

概念

Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OSX 10.6 雪豹中首次推出，也可在iOS4及以上版本使用

优点

GCD 可用于多核的并行运算
GCD 会自动利用更多的 CPU 内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

GCD 中两个核心概念：任务和队列

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
1.同步执行 sync
> 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
>只能在当前线程中执行任务，不具备开启新线程的能力。
2.异步执行 async：
>异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
>可以在新的线程中执行任务，具备开启新线程的能力。
注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关

任务和队列

执行

异步执行 + 并发队列

//可以开启多个线程，任务交替（同时）执行
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
   ///...
});

异步执行 + 串行队列

//会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
  ///...
});

同步执行 + 串行队列

//特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
  ///...

});

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

同步执行 + 并发队列

//特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
  ///...
});

同步和异步

| 区别        | 并发队列           | 串行队列              | 主队列            |
|-----------|----------------|-------------------|----------------|
| 同步(sync)  | 没有开启新线程，串行执行任务 | 没有开启新线程，串行执行任务    | 没有开启新线程，串行执行任务 |
| 异步(async) | 有开启新线程，并发执行任务  | 有开启新线程(1条)，串行执行任务 | 没有开启新线程，串行执行任务 |

// 同步执行任务创建方法
dispatch_sync(queue, ^{
    // 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});

备注:主线程死锁(照成死锁，sync 等待mainThread 执行完成， mianThread 等待sync 函数返回。)
- (void)viewDidLoad{
 [super viewDidLoad];
 NSLog(@"=================4");
dispatch_sync(dispatch_get_main_queue(), ^{
 NSLog(@"=================5");}
);
 NSLog(@"=================6");}

队列（Dispatch Queue）：

这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

GCD两种队列

串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同.

并发队列（Concurrent Dispatch Queue）

可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务;
注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效;
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。
// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

串行队列（Serial Dispatch Queue）

每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue);
获得主队列dispatch_queue_t queue = dispatch_get_main_queue();
所有放在主队列中的任务，都会放到主线程中执行;