iOS多线程-02-GCD

时间  2019-11-10
标签 ios 多线程 gcd 栏目 iOS 繁體版
原文   原文链接

简介

  • GCD（Grand Center Dispatch）是Apple为多核的并行运算提出的解决方案，纯C语言
  • 更加适配多核处理器，且自动管理线程的生命周期，使用起来较为方便
  • GCD经过任务和队列实现多线程功能
    • 任务：描述所要执行的操做
    • 队列：用来存放所要执行的任务，队列中的任务遵循FIFO（First In First Out）原则

GCD的任务函数（是否开启新的线程）

  • 同步
    • 不具有开启新的线程的能力
    • 同步执行任务的函数
      • void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block)，Block类型
        • queue：任务队列
        • block（代码块）：所执行的任务
      • void dispatch_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work)，函数类型（每一个Block类型都对应一个函数类型）
        • queue：任务队列
        • context：传递给任务函数的参数
        • work（函数）：所执行的任务
    • 同步执行任务的其余函数（barrier），在前面的任务执行完毕它才执行，它后边的任务等它执行完毕才执行
      • void dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block)，block类型
        • queue：任务队列，仅当该参数为并发队列时，该函数才有意义
      • dispatch_barrier_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work)，函数类型
  • 异步
    • 具有开启新的线程的能力（须要将任务添加到并发队列中）
    • 异步执行任务的函数（参数意义与同步函数相同）
      • void dispatch_async(dispatch_queue_t queue, dispatch_block_t block)
      • void dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work)
    • 异步执行任务的其余函数（barrier），在前面的任务执行完毕它才执行，它后边的任务等它执行完毕才执行（参数意义与同步函数相同）
      • void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block)
      • void dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work)

GCD的队列（任务的执行方式）

  • 并发队列
    • 开启多个线程，使队列中的多个任务并发执行（须要异步执行函数的配合）
  • 串行队列
    • 队列中的任务一个接一个顺序地执行
  • 队列的种类
    • 串行队列
      • dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
        • label：一般为0
        • attr：队列类型，DISPATCH_QUEUE_SERIAL
    • 并发队列
      • dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
        • label：一般为0
        • attr：队列类型 DISPATCH_QUEUE_CONCURRENT
    • 主队列（串行，只能在主线程中运行）
      • dispatch_queue_t dispatch_get_main_queue(void)，获取主队列
    • 全局队列（并发）
      • dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags)

任务与队列的组合

  • 同步函数

    • 同步函数主队列多线程

      /**
- 运行在主线程主队列（未开启新的线程），主线程被卡死
- 缘由：任务代码等待着当前函数执行完毕才能执行（当前函数正在执行且未执行完毕）；
       当前函数等待着任务代码 执行完毕才能执行（当前任务正在执行且未执行完毕）；
       相互等待，出现死锁
*/

//获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
//添加任务到队列
dispatch_sync(queue, ^{
    //任务1代码
});
dispatch_sync(queue, ^{
    //任务2代码
});

    • 同步函数串行队列并发

      /**
- 运行在主线程串行非主队列（未开启新的线程），任务串行执行
*/

//建立串行队列
dispatch_queue_t queue = dispatch_queue_create("com.23565@qq", DISPATCH_QUEUE_SERIAL);
//添加任务到队列
dispatch_sync(queue, ^{
    //任务1代码
});
dispatch_sync(queue, ^{
    //任务2代码
});

    • 同步函数并发队列app

      /**
- 运行在非主线程并发队列（未开启新的线程），任务串行执行
*/

//获取全局队列（并发）
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//将任务加至队列
dispatch_sync(queue, ^{
    //任务1代码
});
dispatch_sync(queue, ^{
    //任务2代码
});
  • 异步函数

    • 异步函数主队列异步

      /**
- 运行在主线程主队列（未开启新的线程），任务串行执行
*/

// 得到主队列
dispatch_queue_t queue = dispatch_get_main_queue();
// 将任务加入队列
dispatch_async(queue, ^{
    //任务1代码
});
dispatch_async(queue, ^{
    //任务2代码
});

    • 异步函数串行队列async

      /**
- 运行在主函数串行非主队列（未开启新的线程），任务串行执行
*/

//建立串行队列
dispatch_queue_t queue = dispatch_queue_create("com.23565@qq", DISPATCH_QUEUE_SERIAL);
//将任务加至队列
dispatch_async(queue, ^{
    //任务1代码
})
dispatch_async(queue, ^{
    //任务2代码
})

    • 异步函数并发队列ide

      /**
- 运行在非主线程并发队列（开启新的线程），任务并发执行
- 系统根据任务建立线程（没法肯定任务执行在哪一个线程）
*/

//得到全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//将任务加入队列
dispatch_async(queue, ^{
    //任务1代码
});
dispatch_async(queue, ^{
    //任务2代码
});

      线程之间的通讯

  • 从主线程到子线程
    • 注意
      • 只有异步函数与并发队列的组合，才会开启新的线程，使任务并发执行
      • 一般使用异步函数将任务添加到并发队列中，来实现从主线程到子线程的通讯

    • 实现代码函数

      dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //须要在子线程中执行的任务代码
    })
  • 从子线程到主线程
    • 注意
      • 主队列中的任务只能在主线程中执行
      • 一般使用异步/同步函数将任务添加到主队列中，来实现从子线程到主线程的通讯

    • 实现代码ui

      dispatch_async(dispatch_get_main_queue(), ^{
        //须要在主线程中执行的代码
    })

GCD的其余任务

  • 单次执行（一般用在单例模式的设计中）spa

    //定义一个标记
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    //此处的代码只会被执行一次
});

  • 延迟执行线程

    /**
- 方法一（GCD）
*/
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    //此处的代码将延迟执行
});

/**
- 方法二（performSelector）
*/
[self performSelector:@selector(run) withObject:self afterDelay:2.0];

/**
- 方法三（NSTimer）
*/
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO]

  • 快速迭代

    void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t))
/**
    iterations：迭代执行的次数
    queue：任务队列
    block：迭代执行的代码
    size_t：用来定义当前迭代到第几回，须要本身添加，如在size_t后添加index索引，记录当前的迭代次数
*/

  • Barrier

    /**
- Barrier中的任务，只能在它前面的任务执行完毕才能执行
  Barrier后的任务，只能等到它执行完毕才能执行
- 要将队列添加到本身建立的并发队列中，否其功能等同于函数
  void dispatch_async(dispatch_queue_t queue, dispatch_block_t block)
*/
//建立队列（一般是本身建立的并发队列）
dispatch_queue_t queue = dispatch_queue_create("123", DISPATCH_QUEUE_CONCURRENT);
//将任务添加到队列
dispatch_async(queue, ^{
    //在Barrier前执行的任务代码
});
dispatch_barrier_async(queue, ^{
   //Barrier中的任务代码
});
dispatch_async(queue, ^{
    //在Barrier后执行的任务代码
});

  • 队列组

    //获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//建立队列组
dispatch_group_t group = dispatch_group_create();
//添加任务到队列组
dispatch_group_async(group, queue, ^{
        //任务1代码
    });
dispatch_group_async(group, queue, ^{
        //任务2代码
    });
dispatch_group_notify(group, queue, ^{
        //任务3代码
        /**
        group组中的全部任务执行完毕在执行
        若group为空，则当即执行
        */
});

GCD定时器

  • 实现原理
    • 建立一个DISPATCH_SOURCE_TYPE_TIMER类型的dispatch source，并添加到dispatch queue，经过dispatch source来响应事件
    • 经过函数void dispatch_source_set_timer(dispatch_source_t source, dispatch_time_t start, uint64_t interval, uint64_t leeway)，来设置dispatch source的执行事件

  • 实现代码

    //得到队列
dispatch_queue_t queue = dispatch_get_main_queue();
//建立一个定时器
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);

//设置定时器的各类属性(起止时间)
dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(8.0 * NSEC_PER_SEC));
uint64_t interval = (uint64_t)(1.0 * NSEC_PER_SEC);
//设置
dispatch_source_set_timer(self.timer, start, interval, 0);

//设置回调
dispatch_source_set_event_handler(self.timer, ^{
    //定时器被触发时所要执行的代码
});

//开启定时器
dispatch_resume(self.timer);
//取消定时器
dispatch_cancel(self.timer);
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程