【iOS】GCD

于 2024-07-24 20:06:48 发布
阅读量978 收藏 11
点赞数 13
分类专栏： iOS多线程 文章标签： ios cocoa macos objective-c xcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XY_Mckevince/article/details/140640546
版权

参考文章：GCD函数和队列原理探索

之前写项目的时候，进行耗时的网络请求使用GCD处理过异步请求，但对一些概念都很模糊，这次就来系统学习一下GCD相关

相关概念

什么是GCD？

Grand Center Dispatch简称GCD，是苹果公司开发的技术，以优化应用程序支持多核心处理器

GCD的优势：

  • GCD 是苹果公司为多核的并⾏运算提出的解决⽅案
  • GCD 会⾃动利⽤更多的CPU内核（⽐如双核、四核）
  • GCD 会⾃动管理线程的⽣命周期（创建线程、调度任务、销毁线程）
  • 程序员只需要告诉GCD想要执⾏什么任务，不需要编写任何线程管理代码

GCD要做的事情就是：GCD将任务添加到队列，并指定执行任务的函数

「任务」

任务： 执行操作，就是在线程中执行的那段代码。在GCD中是放在Block中的。执行任务有两种方式：

  • 同步执行（sync）：
    • 必须等待当前语句执⾏完毕，才会执⾏下⼀条语句
    • 不会开启线程
    • 只能在当前线程中执行任务，不具备开启新线程的能力
  • 异步执行（async）：
    • 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务
    • 可以在新的线程中执行任务，具备开启新线程的能力
    • 异步是多线程的代名词

注意：异步执行（async） 虽然具有开启新线程的能力，但是并不一定开启新线程，这跟任务指定的队列类型有关

两者主要的区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力

「队列」

队列（Dispatch Queue）： 这里的队列指执行任务的等待队列，即用来存放任务的队列。每读取一个任务，则从队列中释放一个任务，参考下图：

请添加图片描述

队列分为两种：串行队列和并发队列。不同的队列中，任务排列的方式是不一样的，任务通过队列的调度，由线程池安排的线程来执行
两者都符合FIFO（先进先出）的原则：

  • 串行队列（Serial Dispatch Queue）：每次只有一个任务被执行，让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
  • 并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

注意：并发队列的并发功能只有在异步（dispatch_async）方法下才有效

两者的主要区别是：执行顺序不同，以及开启线程数不同。参考下图：

请添加图片描述

创建队列：

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

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

MRC下，生成的队列需由程序员负责持有或释放，通过以下两个函数的引用计数来管理内存：

dispatch_retain(serialQueue);
dispatch_release(serialQueue);

队列与函数组合

队列用来调用任务，函数用来执行任务，那么队列和函数不同的配合会有怎样的运行效果呢？

  • 同步函数串行队列
    1. 不会开启线程，在当前线程中执行任务
    2. 任务串行执行，任务一个接着一个执行
    3. 会产生阻塞
  • 同步函数并发队列
    1. 不会开启线程，在当前线程中执行任务
    2. 任务一个接着一个执行
  • 异步函数串行队列
    1. 会开启一个线程
    2. 任务一个接着一个执行
  • 异步函数并发队列
    1. 开启线程，在当前线程执行任务
    2. 任务异步执行，没有顺序，CPU调度有关

GCD中的队列

主队列

  1. The main queue：系统自带的一个队列，放到这个队列中的代码会被系统分配到主线程中执行。Main queue可以调用dispatch_get_main_queue()来获得。因为main queue是与主线程相关的，所以这是一个串行队列， 交至其中的任务顺序执行(一个任务执行完毕后，再执行下一个任务)

    dispatch_queue_t mainQueue = dispatch_get_main_queue();

全局队列

  1. Global queues：整个应用程序存在4个全局队列(系统已经创建好，只需获得即可)：高、中(默认)、后台三个优先级队列，可以调用dispatch_get_global_queue函数传入有下级来访问队列。全局队列是并行队列，可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)，并发功能只有在异步(dispatch_async)函数下才有效

    dispatch_queue_t globalQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t globalQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t globalQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

自定义队列

  1. 用户自己创建队列：dispatch_queue_create创建的队列可以是串行的，也可以是并行的，因为系统已经给我们供了并行、串行队列，所以一般情况下我们不再需要在创建自己的队列。用户创建的队列可以有任意多个

注意: 分线程不能刷新UI，刷新UI只能在主线程。如果每个线程都刷新UI，将会很容易造成UI冲突，会出现不同步的情况，所以只有主线程中能刷新UI系统是为了降低编程的复杂程度，最大程度的避免冲突

相关案例分析

耗时性

任务是耗时的，不同函数只要执行任务，都会耗时

异步函数会开启线程，执行的耗时相对较少，在实际开发中，异步可以用来解决并发、多线程等问题

六种情况示例

主队列添加同步任务

在当前的main队列中添加一个任务，并同步执行该任务：

void mainSyncTest(void) {
    /*
     主队列同步
     不会开启线程
     会崩溃！
     */
    NSLog(@"start");
    
    // dispatch_queue_t concurrentQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(serialQueue, ^{
        NSLog(@"a");
    });
    
    NSLog(@"b");
}

在当前流程中，默认队列就是主队列，也是一个串行队列，任务执行顺序应为：

在这里插入图片描述

而到了第二步的块任务，会向当前的主队列中添加一个任务NSLog(@"a");，因为主队列是一个串行队列，现在要执行b，必须要等a（任务块）执行完成，而a又必须等b执行完成，产生了相互等待问题，造成了死锁！见下图：

在这里插入图片描述

运行结果就是崩溃：

在这里插入图片描述

解决办法就是将主队列改成自定义的串行队列或并发队列：

NSLog(@"start");

// dispatch_queue_t concurrentQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
dispatch_sync(serialQueue, ^{
    NSLog(@"a");
});

NSLog(@"b");

运行结果：

在这里插入图片描述

主队列添加异步任务
void mainAyncTest(void) {
    NSLog(@"start");
    
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialQueue, ^{
        NSLog(@"a");
    });
    
    NSLog(@"b");
}

主队列添加异步任务不会阻塞，不会崩溃

运行结果：

在这里插入图片描述

并发队列添加异步任务
void concurrentAsyncTest(void) {
    dispatch_queue_t concurrentQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1 --- %@", [NSThread currentThread]);
    
    dispatch_async(concurrentQueue, ^{
        NSLog(@"2 --- %@", [NSThread currentThread]);
        
        dispatch_async(concurrentQueue, ^{
            NSLog(@"3 --- %@", [NSThread currentThread]);
        });
        
        NSLog(@"4 --- %@", [NSThread currentThread]);
    });
    
    NSLog(@"5 --- %@", [NSThread currentThread]);
}

并发队列，通道比较宽，不会导致任务的阻塞
每个任务复杂度基本一致，异步不会堵塞主线程，dispatch_async会开启一个新的线程去执行其中的任务块

运行结果：

在这里插入图片描述

并发队列添加同步任务
void concurrentSyncTest(void) {
    dispatch_queue_t concurrentQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1 --- %@", [NSThread currentThread]);
    
    dispatch_sync(concurrentQueue, ^{
        NSLog(@"2 --- %@", [NSThread currentThread]);
        
        dispatch_sync(concurrentQueue, ^{
            NSLog(@"3 --- %@", [NSThread currentThread]);
        });
        
        NSLog(@"4 --- %@", [NSThread currentThread]);
    });
    
    NSLog(@"5 --- %@", [NSThread currentThread]);
}

因为并发队列，所以不会导致队列任务的阻塞，同时因为是同步执行，所以不会开启新的线程，按照顺序去执行流：

在这里插入图片描述

串行队列添加异步任务
void serialAsyncTest(void) {
    // 串行队列
    NSLog(@"start --- %@", [NSThread currentThread]);
    
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 5; ++i) {
        dispatch_async(serialQueue, ^{
            NSLog(@"%d --- %@", i, [NSThread currentThread]);
        });
    }
    
    NSLog(@"hello queue");
    NSLog(@"end --- %@", [NSThread currentThread]);
}

运行结果：

在这里插入图片描述

串行队列添加异步任务，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行
另一方面可以看出，所有任务是在打印的start和end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行

串行队列添加同步任务
void serialSyncTest(void) {
    NSLog(@"start --- %@", [NSThread currentThread]);
    
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 5; ++i) {
        dispatch_sync(serialQueue, ^{
            NSLog(@"%d --- %@", i, [NSThread currentThread]);
        });
    }
    
    NSLog(@"hello queue");
    NSLog(@"end --- %@", [NSThread currentThread]);
}

运行结果：

在这里插入图片描述

串行队列同步执行任务，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行
同时我们还可以看到，所有任务都在打印的start和end之间，这说明任务是添加到队列中马上执行的

串行队列添加同步和异步任务混合

void serialSyncAndAsyncTest(void) {
    NSLog(@"start --- %@", [NSThread currentThread]);
    
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialQueue, ^{
        NSLog(@"a --- %@", [NSThread currentThread]);
        dispatch_sync(serialQueue, ^{
            NSLog(@"b --- %@", [NSThread currentThread]);
        });
        NSLog(@"d --- %@", [NSThread currentThread]);
    });
    
    NSLog(@"hello queue");
    NSLog(@"end --- %@", [NSThread currentThread]);
}

在异步添加的线程中，情况类似主队列添加同步函数，b（任务块）和d相互等待了，导致死锁！

运行结果：

在这里插入图片描述

并发队列多任务

void concurrentSyncAndAsyncTest(void) {
    dispatch_queue_t concurrentQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(concurrentQueue, ^{
        NSLog(@"1");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"2");
    });
    
    dispatch_sync(concurrentQueue, ^{
        NSLog(@"3");
    });
    
    NSLog(@"0");
    
    dispatch_async(concurrentQueue, ^{
        NSLog(@"7");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"8");
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"9");
    });
}
// 3 0 1 2 7 9 8
// 3 0 1 7 9 8 2
// 3 0 1 2 7 8 9
// 3 1 0 2 7 8 9
// 3 2 1 0 7 8 9
// 3 1 2 0 7 9 8

结果分析：

  • 主队列共10个任务
  • 1、2、3的顺序不确定
  • 3、0是同步任务，所以3一定在0前面
  • 7、8、9一定在0后面

GCD线程间通信

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯

void communicateAmongThread(void) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 6; ++i) {
            NSLog(@"1 --- %@", [NSThread currentThread]);
        }
         
        // 回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"2 --- %@", [NSThread currentThread]);
        });
    });
}

运行结果：

在这里插入图片描述

可以看到在其他线程中先执行操作，执行完了之后回到主线程执行主线程的相应操作

GCD的栅栏方法

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏

这是没添加栅栏函数之前的结果，顺序不确定：

在这里插入图片描述

void barrierFunc(void) {
    dispatch_queue_t queue = dispatch_queue_create("666", DISPATCH_QUEUE_CONCURRENT);
 
    dispatch_async(queue, ^{
        NSLog(@"1 --- %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2 --- %@", [NSThread currentThread]);
    });
 
    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----%@", [NSThread currentThread]);
    });
 
    dispatch_async(queue, ^{
        NSLog(@"3 --- %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"4 --- %@", [NSThread currentThread]);
    });
}

栅栏函数可保证异步操作的执行顺序，这里保证了1或2先执行，3或4后执行：

在这里插入图片描述

GCD的延时方法

当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法

void delayExec(void) {
    NSLog(@"run -- 0");
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 3秒后异步执行这里的代码...
       NSLog(@"run -- 2");
    });
}

运行结果：

在这里插入图片描述

GCD的一次性代码（只执行一次）

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

void onceExec(void) {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行一次的代码（这里面是默认线程安全的）
        NSLog(@"Hhhhhhhh");
    });
}

onceExec();
onceExec();

调用两次只会执行一次：

在这里插入图片描述

GCD的队列组

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

  • 我们可以先把任务放到队列中，然后将队列放入队列组中
  • 调用队列组的dispatch_group_notify回到主线程执行操作
void queueGroup(void) {
    // GCD的队列组
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行1个耗时的异步操作
        int i = 0;
        while (i < 100) {
            NSLog(@"1");
            i++;
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行1个耗时的异步操作
        int i = 0;
        while (i < 100) {
            NSLog(@"2");
            i++;
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程...
        NSLog(@"3");
    });
}

运行结果：

在这里插入图片描述

dispatch_set_target_queue

这个函数有两个作用：

  1. 改变队列的优先级
  2. 防止多个串行队列的并发执行

改变队列的优先级

dispatch_queue_create函数生成的串行队列和并发队列，都使用 与默认优先级的Global Dispatch Queue 相同执行优先级 的线程

void serialBackgroundQueue(void) {
    // 需求：生成一个后台的串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("bySelf", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t globalQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
    
    // 第1个参数：需要改变优先级的队列
    // 第2个参数：目标队列
    dispatch_set_target_queue(serialQueue, globalQueueBackground);
}

防止多个串行队列的并发执行

如果是将任务追加到3个串行队列中，那么这些任务就会并发执行。因为每个串行队列都会创建一个线程，这些线程会并发执行
如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么这多个串行queue在目标queue上就是同步执行的，不再是并行执行
将串行队列加入指定优先级队列，会按照加入优先级队列的顺序依次执行串行队列

未加入优先级队列：

在这里插入图片描述

void abandonSerialQueuesToConcurrent(void) {
    dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
 
    dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
    
//    dispatch_set_target_queue(queue1, targetQueue);
//    dispatch_set_target_queue(queue2, targetQueue);
//    dispatch_set_target_queue(queue3, targetQueue);
        
    dispatch_async(queue1, ^{
        NSLog(@"1 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"1 out");
    });
 
    dispatch_async(queue2, ^{
        NSLog(@"2 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"2 out");
    });
    dispatch_async(queue3, ^{
        NSLog(@"3 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"3 out");
    });
}

加入后：

在这里插入图片描述

dispatch_suspend/dispatch_resume

dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行

挂起指定队列：dispatch_suspend(serialQueue);
恢复指定队列：dispatchp_resume(serialQueue);

void suspendOrResumeQueue(void) {
    dispatch_queue_t queue = dispatch_queue_create("com.test.gcd", DISPATCH_QUEUE_SERIAL);
    //提交第一个block，延时5秒打印。
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds...");
    });
    //提交第二个block，也是延时5秒打印
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds again...");
    });
    //延时一秒
    NSLog(@"sleep 1 second...");
    sleep(1);
    //挂起队列
    NSLog(@"suspend...");
    dispatch_suspend(queue);
    //延时10秒
    NSLog(@"sleep 17 second...");
    sleep(17);
    //恢复队列
    NSLog(@"resume...");
    dispatch_resume(queue);
}

线程安全

为了保证线程安全，我们之前了解过互斥锁，在书上给了我们dispatch_semaphore方法，我们总结为三点：

  1. synchronized加锁，属于互斥锁，当有线程执行锁住的代码的时候，其他线程会进入休眠，需要唤醒后才能继续执行，性能较低

    - (void)synchronizedSecurity {
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
     // 加锁保证block中执行完成才会执行其他的
         @synchronized (self) {
             NSLog(@"1开始");
             sleep(2);
             NSLog(@"1结束");
         }
     });
     dispatch_async(dispatch_get_global_queue(0, 0), ^{
         @synchronized (self) {
             NSLog(@"2开始");
             sleep(2);
             NSLog(@"2结束");
         }
     });
}

  2. 信号量semaphore加锁，属于自旋锁，当有线程执行锁住的代码的时候，其他线程会进入死循环的等待，当解锁后会立即执行，性能较高
    提供了三种函数：

    • dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量（同时有几个线程可以执行，一般是1）

    • dispatch_semaphore_wait：可以使总信号量减1，当信号总量小于0时就会一直等待（阻塞所在线程），否则就可以正常执行，这个放在要执行的代码的前面。

    • dispatch_semaphore_signal：发送一个信号，让信号总量加1，代码执行完成之后使用，使其他线程可以继续执行

      void semaphoreSecurity(void) {
  dispatch_semaphore_t semalook = dispatch_semaphore_create(1);

  dispatch_async(dispatch_get_global_queue(0, 0), ^{
      dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
      NSLog(@"1开始");
      sleep(2);
      NSLog(@"1结束");
      dispatch_semaphore_signal(semalook);
  });

  dispatch_async(dispatch_get_global_queue(0, 0), ^{
      dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
      NSLog(@"2开始");
      sleep(2);
      NSLog(@"2结束");
      dispatch_semaphore_signal(semalook);
  });
}

  3. NSLock

    void lockSecurity(void) {
 NSLock *lock = [[NSLock alloc]init];
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
     [lock lock];
     NSLog(@"1开始");
     sleep(2);
     NSLog(@"1结束");
     [lock unlock];
 });
  
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
     [lock lock];
     NSLog(@"2开始");
     sleep(2);
     NSLog(@"2结束");
     [lock unlock];
 });
}

    运行结果：

    在这里插入图片描述

zhngxvy
关注
专栏目录
iOS开发：GCD
软贱开发攻城狮
02-20 1万+
       在iOS开发中经常会用到GCD，如果你在求职过程中GCD的使用也是面试官必问的，那么今天就来说说GCD的有关内容，不喜勿喷。       一、GCD的概念       1.GCD全称是Grand Central Dispatch，可译为“CPU的中枢调度器”，是C语言，提供了非常多的强大的函数。       2.GCD的优势：GCD是苹果公司为多核的并行运算提出的解决方案，它会自动利...
【iOS开发】—— GCD
weixin_50990189的博客
03-19 3763
文章目录GCD概述什么是GCD？多线程编程GCD的APIDispatch Queuedispatch_queue_createMain Dispatch Queue/Global Dispatch Queuedispatch_set_target_queuedispatch_after GCD概述 什么是GCD？ GCD（Grand Center Dispatch）是异步执行任务的技术之一。开发者定义想执行的任务并且追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。 多线程
iOS中的GCD
阿党的专栏
09-30 441
iOS开发多线程篇—GCD介绍 一、简单介绍 1.什么是GCD？ 全称是Grand Central Dispatch，可译为“牛逼的中枢调度器” 纯C语言，提供了非常多强大的函数   2.GCD的优势 GCD是苹果公司为多核的并行运算提出的解决方案 GCD会自动利用更多的CPU内核（比如双核、四核） GCD会自动管理线程的生命周期（创建线程、调
gcd - b- 201611302317
weixin_34258838的博客
03-11 219
谈到iOS多线程，一般都会谈到四种方式：pthread、NSThread、GCD和NSOperation。其中，苹果推荐也是我们最经常使用的无疑是GCD。对于身为开发者的我们来说，并发一直都很棘手，如果对GCD的理解不够透彻，那么iOS开发的历程绝对不会顺利。这里，我会从几个角度浅谈我对GCD的理解。 一、多线程背景 Although threads have been around fo...
【iOS】—— 深入了解GCD
m0_55124878的博客
08-05 1048
百度：Grand Central Dispatch（GCD） 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。苹果官方：Grand Central Dispatch(GCD) 是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级实现。...
ios中多线程之GCD的使用
Messi_M10的博客
03-16 369
1. GCD 简介什么是 GCD 呢？我们先来看看百度百科的解释简单了解下概念。引自百度百科Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。为什么要用...
ios gcd
04-20
在iOS开发中，Grand Central Dispatch（GCD）是苹果公司提供的多线程解决方案，它极大地简化了并发编程。GCD是基于C语言的API，但同时也很好地与Objective-C和Swift兼容。这篇博客文章《ios gcd》可能深入探讨了如何...
iOS GCD 开发教程 完整版
03-19
**iOS GCD 开发教程 完整版** GCD（Grand Central Dispatch）是Apple在OS X和iOS系统中引入的一种多线程处理技术，旨在简化并发编程，提高应用程序的性能和响应速度。GCD利用了操作系统底层的调度机制，允许开发者...
iOS GCD timer 计时器
05-08
在iOS开发中，Grand Central Dispatch (GCD) 是一种强大的多线程管理工具，由Apple引入，用于简化并发编程。GCD timer是基于GCD的一种计时器实现，相较于NSTimer，它提供了一种更高效、更易于管理的计时器解决方案。...
iOS GCD详解
12-04
iOS GCD详解 一、什么是GCD？ GCD（Grand Central Dispatch），是一套低层API，提供了一种新的方法来进行并发程序编写。它允许程序将任务切分为多个单一任务然后提交至工作队列来并发地或者串行地执行。GCD比之...
iOS开发：深入理解GCD 第二篇（dispatch_group、dispatch_barrier、基于线程安全的多读单写）1
08-03
dispatch_queue_t queue = dispatch_queue_create("com.gcd-dispatch_group_async(gro
iOS GCD开发总结整理
06-23
iOS GCD（Grand Central Dispatch）是Apple在2010年引入的一种多线程解决方案，它为开发者提供了一种高效、简洁的方式来管理并发任务。GCD是基于Cocoa框架的，适用于iOS和Mac OS X平台。本文将深入探讨GCD的基本概念...
iOS开发-GCD技术
CaicaiNo.1
04-29 1046
GCD是iOS开发中常用的线程技术
IOS开发—GCD介绍
Lotheve的私房菜
03-13 1162
IOS多线程（GCD）介绍
苹果多线程GCD
Stream__的博客
06-30 180
总结 GCD的全称是Grand Central Dispatch，GCD为了替代NSThread，充分利用苹果设备的多核设备，生命周期自动管理，是纯C语言，提供了非常直观和用户理解和习惯的函数，用DISPATCH_QUEUE_SERIAL，和DISPATCH_QUEUE_CONCURRENT 控制串行和并行，用sync和async控制同步和异步。 1.基本使用 //串行 dispatch_queue_t serial = dispatch_queue_creat...
IOS应用开发－GCD编程入门
备忘录
02-25 1512
GCD是一套高度抽象化的多线程编程技术，使用它可以编写出高效的多线程代码。相比于NSThread和NSOperation,Apple更推荐我们使用GCD。GCD的适用范围通常是那种需要长时间CPU运算的场合，例如耗时较长的图形处理和算法执行。 GCD有两宝:一个Dispatch Queue(FIFO队列)和一个线程池，前者用来添加任务，后者用来执行任务。 Dispatch Queue也是一个对
iOS中GCD的使用
cherry的博客
02-07 2361
在iOS开发中，所有的UI操作都是在主线程中进行的，那么如果将把耗时操作也放在主线程中，就会造成页面卡顿的现象。因此我们应该将耗时操作放在子线程中执行，GCD是iOS多线程当中比较常用的方法，下面简单介绍一下GCD的使用。 一、GCD当中的基本概念 1.同步函数和异步函数 同步函数： 同步函数不具备开启新线程的能力 dispatch_sync(dispatch_queue_t _Nonnull...
iOS——【GCD】
最新发布
m0_73348697的博客
03-26 1200
GCD指的是Grand Central Dispatch，它是苹果公司开发的一套多线程编程技术。GCD提供了一种简单而有效的方式来管理应用程序中的并发任务。它通过将任务提交到适当的队列（串行队列或并发队列）来管理并发执行的任务，从而帮助开发者更轻松地实现并发编程，提高应用程序的性能和响应速度。上面的就是在后合线程中执行长时间处理，处理结束时，主线程使用该处理结果的源代码。这样，dispatch_async (queue, ^{ 这仅有 一行的代码表示让处理在后台线程中执行。
iOS开发中的四种GCD
iOS15011015的博客
04-07 513
GCD的核心：将操作/任务放到队列中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值