【iOS】GCD

于 2024-07-24 20:06:48 发布
阅读量784 收藏 9
点赞数 13
文章标签： 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];
 });
}

    运行结果：

    在这里插入图片描述

Jaxon_Cheung
关注
  • 13
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iOS GCD详解
12-04
iOS GCD详解 一、什么是GCD？ GCD（Grand Central Dispatch），是一套低层API，提供了一种新的方法来进行并发程序编写。它允许程序将任务切分为多个单一任务然后提交至工作队列来并发地或者串行地执行。GCD比之...
ios gcd
04-20
在iOS开发中，Grand Central Dispatch（GCD）是苹果公司提供的多线程解决方案，它极大地简化了并发编程。GCD是基于C语言的API，但同时也很好地与Objective-C和Swift兼容。这篇博客文章《ios gcd》可能深入探讨了如何...
iOS GCD
风中的劲草
06-15 624
1、什么是GCD? GCD全称是Grand Central Dispatch，可译为“强大的调度器”。iOS 4开始引入的新一代的多线程编程技术。 开发者只需定义想执行的任务并追加到适当的Dispatch Queu中，GCD就能生成必要的线程并有计划的执行任务。 2、什么是任务？ 想要做什么事情，在GCD中是放在block中的。 3、什么是串行队列 和 并行队列 ? 串行队列 (DISP...
iOS GCD定时器的使用
iOS15011015的博客
07-15 913
GCDTimer类，使用时导入该类即可。
iOS GCD使用
walkerwqp的博客
03-28 277
dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ // 追加任务1        [self.hud show:YES];        for (int i = 0; i &lt; 2; ++i) { [NSThread ...
ios GCD简洁使用教程，gcd切换到主线程执行
大炮哥的博客
05-15 457
网上想搜个gcd切换主线程的用法，一堆无用的废话，这里简洁上教程，直接上代码。
ios gcd异步_带有GCD的iOS中的多线程：同步和异步操作变得简单
weixin_26638123的博客
08-27 681
ios gcd异步Grand Central Dispatch(GCD) is used to handle multithreading in iOS and if you have been developing iOS apps from sometime then for sure you must have come across it. The focus of this post i...
iOS——【GCD】
m0_73348697的博客
03-26 1005
GCD指的是Grand Central Dispatch，它是苹果公司开发的一套多线程编程技术。GCD提供了一种简单而有效的方式来管理应用程序中的并发任务。它通过将任务提交到适当的队列（串行队列或并发队列）来管理并发执行的任务，从而帮助开发者更轻松地实现并发编程，提高应用程序的性能和响应速度。上面的就是在后合线程中执行长时间处理，处理结束时，主线程使用该处理结果的源代码。这样，dispatch_async (queue, ^{ 这仅有 一行的代码表示让处理在后台线程中执行。
iOS GCD 死锁
xsdzx1的专栏
09-11 29
在当前线程（线程所执⾏的任务是从当前队列取出来的）同步的向串⾏队列⾥⾯添加任务，就会产⽣死锁。
ios GCD 用法
hyczwl的专栏
07-03 298
1、GCD线程dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 耗时的操作 dispatch_async(dispatch_get_main_queue(), ^{ // 更新界面 }); });2、GCD延时di
iOS GCD简单使用
韩万杰的博客
02-28 301
#import "GCD.h"@interface GCD ()@property (strong,nonatomic) UIImageView * backImage;@end@implementation GCD- (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading
iOS GCD单例
SoulKey的博客
03-10 492
单例模式可能是设计模式中最简单的形式了，这一模式的意图就是使得类中的一个对象成为系统中的唯一实例。它提供了对类的对象所提供的资源的全局访问点。因此需要用一种只允许生成对象类的唯一实例的机制。我们来看下单例的作用： 可以保证的程序运行过程，一个类只有一个示例，而且该实例易于供外界访问从而方便地控制了实例个数，并节约系统资源。 下面我们利用GCD写一个单例类 新建一个继承NSObject
iOS GCD开发总结整理
06-23
iOS GCD（Grand Central Dispatch）是Apple在2010年引入的一种多线程解决方案，它为开发者提供了一种高效、简洁的方式来管理并发任务。GCD是基于Cocoa框架的，适用于iOS和Mac OS X平台。本文将深入探讨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 collectionView 滑动出现空白
Rex
07-22 379
iOS CollectionView 滑动出现空白
【iOS】进程与多线程
最新发布
XY_Mckevince的博客
07-23 870
iOS开发是单进程，本文针对iOS开发对多线程作以了解，并区分了进程、线程之间的区别和意义，认识了线程的生命周期、线程池的运行策略、简单了解了自旋锁和互斥锁，浅析了atomic原子属性的底层实现是通过自旋锁实现的
【iOS】—— 类与对象的底层
qq_72437394的博客
07-23 841
从源码中可也看到，class_data_bits_t 有一个属性uintptr_t bits，uintptr_t是无符号整数类型，能够存储指针，可以提高内存的利用率，它不止存储class_rw_t结构体指针，还存储其他的信息。​ 从字面上解读：class_ro_t的ro代表的是“只读”，class_rw_t中的rw代表的是“读写”，class_rw_ext_t中的rw_ext表示可读可写的扩展。指针，因此每一个新定义的类，它对应的结构体当中都会有一个这样的class类型的isa指针。
【iOS】内存对齐
XY_Mckevince的博客
07-22 773
内存对齐可以提高CPU的存取效率同时提升安全性，会有部分内存的浪费，但是系统又会根据数据存储情况进行内存优化，尽可能降低内存浪费，这样即保证了性能又减少了浪费
深入理解iOS GCD：并行编程与优势解析
"本文详细介绍了iOS中的GCD(Grand Central Dispatch)，包括它的概念、特点、优势以及核心组件如Dispatch Objects、Dispatch Queues和Dispatch Sources。GCD是Apple为提高多核处理器环境下程序性能提供的低级API，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值