Written by 小小厨师
on April 12, 2018

多线程-GCD

多线程介绍

demo。最快熟悉的方式就是自己码一遍。

Serial vs. Concurrent 串行 vs. 并发 - 允许同时执行的任务数量

串行： 每次只有一个任务被执行。 并发： 同一时间内可以有多个任务被执行。

Concurrency vs Parallelism 并发与并行

多核设备通过并行来同时执行多个线程。为了使单核设备也能实现这一点，它们必须先运行一个线程，执行一个上下文切换，然后运行另一个线程或进程，这通常发生的足够快以致给我们并行执行的错觉。并行要求并发，但并发并不能保证并行。

Synchronous vs. Asynchronous 同步 vs. 异步

是否阻塞当前线程（是否等待当前操作执行完成） 同步： 等待预定任务完成后才返回。 异步： 调用操作后立即返回，预定的任务会完成但是不会等它完成。

队列 vs. 线程

iOS使用队列进行任务调度，它会根据调度任务的需要和系统当前的负载情况动态地创建和销毁线程，而不需要我们手动管理。

Critical Section 临界区

不能被 并发执行 的一段代码。两个线程不能同时执行这段代码。

Race Condition 竞态条件

基于特定序列或时机的事件的软件系统以不受控制的方式运行的行为。竟态条件可导致无法预测的行为，而不能通过代码检查立即发现。

Deadlock 死锁

线程互相等待或执行其他操作导致都卡住。

Thread Safe 线程安全

线程安全的代码能在多线程或并发任务中被安全调用，而不会导致任何问题。

Context Switch 上下文切换

一个上下文切换指当你在单个进程里切换不同的线程时存储与恢复执行状态的过程。这个过程在编写多任务应用时很普遍，但会带来一些额外开销。

队列 - 存放任务

串行队列： 等待正在执行的任务结束。串行队列中的任务一次执行一个，每个任务只在前一个任务完成后才开始。 并发队列： 不等待正在执行的任务结束。并发队列会按照添加的顺序开始执行，但可以以任意顺序完成。

GCD

dispatch_queue_create 创建队列

串行队列： 只能开启一个线程或者在当前线程中执行。

// 第二个参数可为NULL或0
dispatch_queue_t serialQueue = dispatch_queue_create("com.as.serial", DISPATCH_QUEUE_SERIAL);

并发队列： 可以开启多个线程，并发执行。

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.as.concurrent", DISPATCH_QUEUE_CONCURRENT);

dispatch_sync 同步执行

在当前线程中执行任务，不具备开启新线程的能力。添加任务到一个队列并等待直到任务完成，阻塞当前线程。

dispatch_sync(<#dispatch_queue_t  _Nonnull queue#>, ^{
        <#code#>
});

dispatch_async处理后台任务

在新的线程中执行任务，具备开启新线程的能力。添加任务到一个队列但不阻塞当前线程。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{ 
    // 1 后台执行
    dispatch_async(dispatch_get_main_queue(), ^{ 
      // 2 线程切换
    });
});

dispatch_after延迟执行

在主队列使用dispatch_after。一旦block提交便不能再取消。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

dispatch_once保证单例线程安全

dispatch_once() 以线程安全的方式执行且仅执行其代码块一次。试图访问临界区（即传递给 dispatch_once 的代码）的不同的线程会在临界区已有一个线程的情况下被阻塞，直到临界区完成为止。

dispatch barriers栅栏处理读写者问题

在自定义并发队列使用是最好的选择。 Dispatch barriers是一组函数，在并发队列上工作时扮演一个串行式的瓶颈，barrier执行时其本质就如同一个串行队列。GCD barrie确保提交的block在执行的特定时间内是指定队列上唯一被执行的条目。所有先于barrier提交到队列的条目必能在这个block执行前完成。

dispatch_group_t调度组

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t defaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, defaultQueue, ^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"1");
});
dispatch_group_async(group, defaultQueue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"2");
});
dispatch_group_notify(group, defaultQueue, ^{
    NSLog(@"3");
});
    
    //等价于
    
//    dispatch_group_enter(group);
//    dispatch_async(defaultQueue, ^{
//
//        NSLog(@"1");
//        dispatch_group_leave(group);
//    });

可以使用dispatch_group_wait(<#dispatch_group_t _Nonnull group#>, <#dispatch_time_t timeout#>);来指定等待时间。一旦调用dispatch_group_wait函数，该函数就处于调用的状态而不返回，阻塞当前线程。即执行dispatch_group_wait函数的现在的线程（当前线程）停止。在经过dispatch_group_wait函数中指定的时间或属于指定Dispatch Group的处理全部执行结束之前，执行该函数的线程停止。

dispatch_apply 快速迭代，重复执行某个片段

dispatch_apply(3, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^(size_t) {
    // do something;
});

dispatch_set_target_queue 改变生成的Queue的优先级

dispatch_queue_create生成的Queue都使用与默认优先级Global Dispatch Queue相同执行优先级的线程。指定要变更执行优先级Queue为dispatch_set_target_queue函数的第一个参数（这个参数不能指定为Main Queue或Global Dispatch Queue），指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）。

dispatch_queue_t serialQueue = dispatch_queue_create("com.as.serial", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t globalQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(serialQueue, globalQueueBackground);

dispatch_suspend / dispatch_resume 挂起/恢复队列执行

挂起队列： 追加到Queue中尚未执行的处理在此之后停止执行。

dispatch_suspend(<#dispatch_object_t  _Nonnull object#>);

恢复队列： 追加到Queue中尚未执行的处理在此之后继续执行。

dispatch_resume(<#dispatch_object_t  _Nonnull object#>);

dispatch_semaphore_t 信号量线程同步

创建信号量：

dispatch_semaphore_t dispatch_semaphore_create(long value);

等待资源释放： 如果传入的dsema大于0，则继续向下执行，并将信号量减1。如果等于0,则阻塞当前线程等待资源被dispatch_semaphore_signal释放。如果等到信号量，继续向下执行并将信号量减1，如果一直没有等到信号量，就等到timeout再继续执行。dsema不能传入NULL。

long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);

释放资源： 一般放入子线程，不能与dispatch_semaphore_wait在同一个线程。

long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

dispatch_queue_set_specific 和 dispatch_queue_get_specific 向Queue设置判断标识

设置关联：

dispatch_queue_set_specific(dispatch_queue_t queue, const void *key,
	void *_Nullable context, dispatch_function_t _Nullable destructor);

判断当前Queue是否为key关联的queue:

void *_Nullable
dispatch_get_specific(const void *key);

eg.
if (dispatch_get_specific(queueKey1)) {
    //说明当前的队列就是queue1
}
else {
    </span>//说明当前的队列不是是queue1
}

Dispatch I/O 输入输出

大文件读取：

pipe_q = dispatch_queue_create("PipeQ",NULL);
pipe_channel = dispatch_io_create(DISPATCH_IO_STREAM,fd,pipe_q,^(int err){
   close(fd);
});

*out_fd = fdpair[i];

dispatch_io_set_low_water(pipe_channel,SIZE_MAX);

dispatch_io_read(pipe_channel,0,SIZE_MAX,pipe_q, ^(bool done,dispatch_data_t pipe data,int err){
   if(err == 0)
     {
       size_t len = dispatch_data_get_size(pipe data);
       if(len > 0)
       {
          const char *bytes = NULL;
          char *encoded;

          dispatch_data_t md = dispatch_data_create_map(pipe data,(const void **)&bytes,&len);
          asl_set((aslmsg)merged_msg,ASL_KEY_AUX_DATA,encoded);
          free(encoded);
          _asl_send_message(NULL,merged_msg,-1,NULL);
          asl_msg_release(merged_msg);
          dispatch_release(md);
       }
      }

      if(done)
      {
         dispatch_semaphore_signal(sem);
         dispatch_release(pipe_channel);
         dispatch_release(pipe_q);
      }
});

参考

https://github.com/nixzhu/dev-blog/blob/master/2014-04-19-grand-central-dispatch-in-depth-part-1.md

← → Top