[TOC]

基本应用

队列

串行队列

• 以先进先出的方式，顺序调度队列中的任务执行
• 无论队列中所指定的执行任务函数是同步还是异步，都会等待前一个任务执行完成后，再调度后面的任务

# 串行队列

//1.主线程所在的串行队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();

- 专门用来在主线程上调度任务的队列;不会开启线程
- 在主线程空闲时才会调度队列中的任务在主线程执行;如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度

//2.自建串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);

//第一个参数:队列的标志符号
//第二个参数:用来区分串行还是并行: DISPATCH_QUEUE_SERIAL表示串行

并发队列

• 以先进先出的方式，并发调度队列中的任务执行
• 如果当前调度的任务是同步执行的，会等待任务执行完成后，再调度后续的任务
• 如果当前调度的任务是异步执行的，==同时底层线程池有可用的线程资源==，会再新的线程调度后续任务的执行；

# 并行队列

//1.全局的并行队列
/*
第一个参数:队列的优先级
第二个参数:是apple预留的一个参数,传0就行
*/
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//2.自建的并行队列
dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);

操作：同步和异步

• 同步

  • 同步执行任务: 不开启线程，在当前线程执行 task

  • 必须等待当前语句执行完毕，才会执行下一条语句

• 异步

  • 异步执行任务: 新建线程，在新线程执行 task

  • 不用等待当前语句执行完毕，就可以执行下一条语句

# 1)同步的提交
  /*
   第一个参数:线程在哪个队列执行
   第二个参数:代码块,线程的执行体
   */

- (void)gcdDemo1 {
    // 1. 全局队列
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);

    // 2. 任务
    void (^task)() = ^ {
        NSLog(@"%@", [NSThread currentThread]);
    };

    // 3. 指定执行任务的函数
    // 同步执行任务 - 不开启线程，在当前线程执行 task
    dispatch_sync(q, task);
}

# 2）异步提交
  /*
   第一个参数:线程在哪个队列执行
   第二个参数:代码块,线程的执行体
   */
- (void)gcdDemo1 {
    // 1. 全局队列
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);

    // 2. 任务
    void (^task)() = ^ {
        NSLog(@"%@", [NSThread currentThread]);
    };

    // 3. 指定执行任务的函数
    // 异步执行任务 - 新建线程，在新线程执行 task
    dispatch_async(q, task);
}

总结：

1. 串行队列，同步执行-----串行队列意味着顺序执行，同步执行意味着不开启线程（在当前线程执行）
2. 串行队列，异步执行-----串行队列意味着任务顺序执行，异步执行说明要开线程, （如果开多个线程的话，不能保证串行队列顺序执行，所以只开一个线程）
3. 并行队列,异步执行-----并行队列意味着执行顺序不确定，异步执行意味着会开启线程，而并行队列又允许不按顺序执行，所以系统为了提高性能会开启多个线程，来队列取任务（队列中任务取出仍然是顺序取出的，只是线程执行无序）。
4. 并行队列,同步执行-----同步执行意味着不开线程,则肯定是顺序执行

//1.以同步的方式向串行队列提交 ---> 按照顺序执行
//2.以同步的方式向并行队列提交 ---> 按照顺序执行
//3.以异步的方式向串行队列提交 ---> 按照顺序执行
//4.以异步的方式向并行队列提交 ---> 多个线程同时开始执行


//1.以同步的方式向串行队列提交 ---> 前面的线程执行完成之后，才开始执行后面的线程

  //创建一个串行队列
  dispatch_queue_t serialQueue = dispatch_queue_create("queueOne", DISPATCH_QUEUE_SERIAL);

  //以同步的方式提交两个线程
  dispatch_sync(serialQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程一:%d",i);
      }
  });

  dispatch_sync(serialQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程二:%d",i);
      }
  });



//2.以同步的方式向并行队列提交 ---> 前面的线程执行完成之后，才开始执行后面的线程

  //创建一个并行队列
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  //以同步的方式创建两个线程
  dispatch_sync(queue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程一:%d",i);
      }
  });
  dispatch_sync(queue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程二:%d",i);
      }
  });




//3.以异步的方式向串行队列提交 ---> 前面的线程执行完成之后，才开始执行后面的线程

  //串行队列
  dispatch_queue_t serialQueue = dispatch_queue_create("queueThree", DISPATCH_QUEUE_SERIAL);

  //异步提交两个代码块
  dispatch_async(serialQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程一:%d",i);
      }
  });
  dispatch_async(serialQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程二:%d",i);
      }
  });



//4.以异步的方式向并行队列提交 ---> 多个线程同时开始执行

  //并行队列
  dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);

  //异步提交两段代码块
  dispatch_async(concurrentQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程一:%d",i);
      }
  });
  dispatch_async(concurrentQueue, ^{
      for (int i=0; i<100; i++) {
          NSLog(@"执行了线程二:%d",i);
      }
  });