iOS开发之多线程

已于 2024-06-03 19:22:59 修改
阅读量2.8k 收藏 6
点赞数 5
分类专栏： 技术文档 文章标签： ios ios开发 多线程
于 2017-08-31 10:50:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/styleqiang/article/details/77742944
版权

iOS开发之多线程

本文章博主和大家一块学习多线程，很自然就涉及到线程和进程，然后涵括NSThread、GCD、NSOperation！然后就是最牛叉的RunLoop和Runtime。

一、线程与进程
进程是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发。
线程是进程的子任务，是CPU调度和分配的基本单位，用于保障程序执行的实时性，实现进程内部的并发。
区别：

  • 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程依赖于进程而存在。
  • 进程是资源分配的最小单位，线程是CPU调度的最小单位
  • 进程在执行过程中拥有独立的内存单元，而多个线程共享进程的内存。
  • 进程间不会相互影响 ；线程：一个线程挂掉将导致整个进程挂掉
  • 线程之间的通信更加方便，同一个进程下线程共享全局变量，静态变量等数据。

二、多线程

多线程的优点和缺点

  • 优点
    1.能适当的提高程序的执行效率
    2.能适当提高资源利用率（CPU内存利用率）
  • 缺点
    1.开启线程需要占用一定的内存空间，如果开启大量的线程，则会占用大量的内存空间，降低程序的性能。
    2.线程越多，CUP在调度线程的开销就越大。
    3.程序设计更加复杂，比如线程之间的通信，多线程的数据共享。

多线程的应用
1.使用单利模式时，可以使用GCD
2.耗时操作放入子线程处理，完成后回主线程显示。
3.从数据库读取大量数据，可开辟子线程操作。
4.处理音频、视频数据时，在子线程处理。
5.数据同步操作。

三、容易混淆的4个术语

同步和异步主要影响：能不能开启新的线程。
1.同步：只是在当前线程中执行任务，不具备开启新线程的能力。
2.异步：可以在新的线程中执行，具备开启新线程的能力。

并发和串行主要影响：任务的执行方式
并发：多个任务并发（同时）执行。
串行：一个任务执行完毕后，再执行下一个任务。

这里写图片描述

四、NSThread、NSOperation、GCD

1.NSThread
1)通过NSThread的对象方法（动态创建）

这里写图片描述

2)通过NSThread的类方法（静态创建）

这里写图片描述
NSThread的线程管理

  1. 线程创建
  2. 线程开启
  3. 线程取消
  4. 线程关闭
  5. 线程暂停
  6. 设置线程优先级

NSThread的线程通信

  1. 指定当前线程执行操作
  2. （在其他线程中）指定主线程执行操作
  3. 在主线程中）指定其他线程执行操作

2.NSOperation
2.1 NSOperation 基本使用
在iOS开发中，为了提升用户体验，我们通常会将操作耗时的操作放在主线程之外的线程进行处理。对于正常的简单操作，我们更多的选择代码更少的GCD，让我们专注于自己的业务逻辑开发。NSOperation在iOS4后也基于GCD实现，但是对于GCD来说可控性更强，并且可以加入操作依赖。
(1) 相关概念
NSOperation是对GCD的封装，其中有两个核心概念【队列+操作】
1.NSOperation本身是抽象类，只能有它的子类。
2.两大子类分别是:NSBlockOperation、NSInvocationOperation，当然你也可以自定义继承自NSOperation的类。

(2)基本使用

  • 实例化NSOperation的子类，绑定执行的操作。
  • 创建NSOperationQueue队列，将NSOperation实例添加进来。
  • 系统会自动将NSOperationQueue队列中检测取出和执行NSOperation的操作。

NSInvocationOperation类

//  01 NSInvocationOperation创建线程
/*
 第一个参数：目标对象
 第二个参数：该操作要调用的方法，最多接受一个参数
 第三个参数：调用方法传递的参数，如果方法不接受参数，那么该值传nil
 */
- (void) method1 {
    NSString * imageUrl = @"https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=482494819,3150422682&fm=200&gp=0.jpg";
    NSInvocationOperation * invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(loadImageSource:) object:imageUrl];
//    [invocationOperation start];
    //一旦执行操作，就会调用target的sel方法， 默认情况下调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作，只有将NSOperation放到一个NSOperationQueue中，才会异步执行操作
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:invocationOperation];
}
//更新imageView
- (void)updateImage:(NSData *)data{
    //在主线程中更新UI
    //将二进制数据转换为图片
    UIImage *image=[UIImage imageWithData:data];
    //设置image
    self.imageView.image=image;
}

NSBlockOperation类

  • 创建NSBlockOperation对象
  • 通过addExecutionBlock:方法添加更多的操作
    这里写图片描述

队列的取消、暂停、和恢复

// 恢复队列，继续执行
// self.queue.suspended = NO;

// 暂停（挂起）队列，暂停执行
// self.queue.suspended = YES;

// 取消队列的所有操作
[self.queue cancelAllOperations];

操作依赖

NSOperation之间可以设置依赖来保证执行顺序
这里写图片描述
不添加依赖之前op1、op2、op3的顺序是随机的

在不同queue的NSOperation之间创建依赖关系
这里写图片描述
在不加依赖之前，op1和op2的执行顺序是随机的，添加依赖后op2会在op1之后执行。

线程间的通讯

[[NSOperationQueue mainQueue] addOperationWithBlock:^{
            [self updateImage:data];
        }];

3.GCD

3.1基本概念
全称是Grand Central Dispatch，即：强大的中枢调度器，它是纯C语言的，提供了非常多强大的函数。

3.2GCD的优势:

GCD是苹果公司为多核的并行运算提出的解决方案

GCD会自动利用更多的CPU内核（比如双核、四核）

GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）

程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

3.3GCD的使用步骤：

  1. 指定任务：确定想要做的事

  2. 将任务添加到队列中：GCD会自动将队列中的任务取出，放到对应的线程中执行，任务的取出遵循队列的FIFO原则：先进先出，后进后出。

3.4GCD的队列

3.4.1 GCD的队列可以分为2大类型：

1.并发队列（Current Dispatch Queue）

2.串行队列（Serial Dispatch Queue）

3.4.2 使用dispatch_queue_create函数创建队列

dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
其中：const char *label 列队列的名称
      dispatch_queue_attr_t attr 队列的类型

创建一个并发队列
    dispatch_queue_t queue1 = dispatch_queue_create("myQueue1", DISPATCH_QUEUE_CONCURRENT);

创建一个串行队列
     dispatch_queue_t queue2 = dispatch_queue_create("myQueue2", DISPATCH_QUEUE_SERIAL);

GCD默认意境提供了全局的并发队列，供整个应用使用，可以无需手动创建

使用dispatch_get_global_queue 函数获得全局并发队列
     //获得全局的并发队列
     dispatch_queue_t queue3 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     其中：第一个参数代表全局并发队列的优先级
     #define DISPATCH_QUEUE_PRIORITY_HIGH 2 --》 高
     #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 --》 默认（中）
     #define DISPATCH_QUEUE_PRIORITY_LOW (-2) --》 低
     #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN --》 后台
     第二个参数标记：是为了未来使用保留的！所以这个参数应该永远指定为0

GCD中获得串行有2种途径

1.使用dispatch_queue_create 创建串行队列，创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
     dispatch_queue_t queue4 = dispatch_queue_create("com.520.queue", NULL);
2.使用主队列 （跟主线程相关联的队列）,主队列时GCD自带的一种特殊的串行队列，放在主队列中的任务，都会放在主线程中执行，dispatch_get_main_queue()获得主队列
     dispatch_queue_t queue5 = dispatch_get_main_queue();

3.4.3 应用

3.4.3.1 串行队里
3.4.3.2.并发队列（Concurrent Dispatch Queue）

//
//  ViewController.m
//  TestThread
//
//  Created by denggaoqiang on 2022/9/10.
//

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [self example14];
    
}

- (void)example1 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"当前同步任务1一-------%@",[NSThread currentThread]);
        sleep(3);
        
    });
    NSLog(@"1111");
    dispatch_sync(queue, ^{
        NSLog(@"当前同步任务2一-------%@",[NSThread currentThread]);
        sleep(2);
        
    });
    NSLog(@"2222");
    dispatch_sync(queue, ^{
        NSLog(@"当前同步任务3一-------%@",[NSThread currentThread]);
        sleep(1);
    });
    NSLog(@"走到这里了");
    /** 打印结果
     当前同步任务1
     1111
     当前同步任务2
     2222
     当前同步任务3
     走到这里了
     */
}

- (void)example2 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        
        sleep(5);
        NSLog(@"当前异步任务1一-------%@",[NSThread currentThread]);
    });
    NSLog(@"1111");
    dispatch_async(queue, ^{
        
        sleep(2);
        NSLog(@"当前异步任务2一-------%@",[NSThread currentThread]);
    });
    NSLog(@"2222");
    dispatch_async(queue, ^{
        
        sleep(1);
        NSLog(@"当前异步任务3一-------%@",[NSThread currentThread]);
    });
    NSLog(@"走到这里了");
    /** 打印结果
     
     1111
     2222
     走到这里了
     当前异步任务1
     当前异步任务2
     当前异步任务3
     
     */
}

- (void)example3 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"当前同步任务1一-------%@",[NSThread currentThread]);
    });
    NSLog(@"1111");
    dispatch_async(queue, ^{
        NSLog(@"当前异步任务2开始一-------%@",[NSThread currentThread]);
        sleep(10);
        NSLog(@"当前异步任务2结束一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"2222");
    
    dispatch_sync(queue, ^{
        sleep(2);
        NSLog(@"当前同步任务3一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"3333");
    dispatch_async(queue, ^{
        sleep(1);
        NSLog(@"当前异步任务4一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"走到这里了");
    /** 打印结果
     当前同步任务1
     1111
     2222
     当前异步任务2开始
     当前异步任务2结束
     当前同步任务3
     3333
     走到这里了
     当前异步任务4
     */
}

- (void)example4 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        sleep(5);
        NSLog(@"当前同步任务1一-------%@",[NSThread currentThread]);
    });
    NSLog(@"1111");
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"当前同步任务2一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"2222");
    dispatch_sync(queue, ^{
        sleep(1);
        NSLog(@"当前同步任务3一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"走到这里了");
    /** 打印结果
     当前同步任务1
     1111
     当前同步任务2
     2222
     当前同步任务3
     走到这里了
     */
}

- (void)example5 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"当前同步任务1一-------%@",[NSThread currentThread]);
    });
    NSLog(@"1111");
    dispatch_async(queue, ^{
        sleep(8);
        NSLog(@"当前异步任务2一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"2222");
    dispatch_async(queue, ^{
        sleep(3);
        NSLog(@"当前同步任务3一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"3333");
    dispatch_async(queue, ^{
        sleep(1);
        NSLog(@"当前异步任务4一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"走到这里了");
    /** 打印结果
     1111
     2222
     3333
     走到这里了
     当前异步任务4
     当前异步任务3
     当前异步任务1
     当前异步任务2
     */
}

- (void)example6 {
    
    dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"当前同步任务1一-------%@",[NSThread currentThread]);
    });
    NSLog(@"1111");
    dispatch_async(queue, ^{
        sleep(8);
        NSLog(@"当前异步任务2一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"2222");
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"当前同步任务3一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"3333");
    dispatch_async(queue, ^{
        sleep(1);
        NSLog(@"当前异步任务4一-------%@",[NSThread currentThread]);
        
    });
    NSLog(@"走到这里了");
    /** 打印结果
     当前同步任务1
     1111
     2222
     当前同步任务3
     3333
     走到这里了
     当前异步任务4
     当前异步任务2
     */
}

/**总结:
 一、在同一串行队列种
 同步里面创建同步 死锁崩溃
 同步里面创建异步 正常
 异步里面创建同步 死锁崩溃
 异步里面创建异步 正常
 二、在同一并发队列
 同步里面创建同步 正常
 同步里面创建异步 正常
 异步里面创建同步 正常
 异步里面创建异步 正常
 */

-(void)example71 {
    
    //串行队列   同步里面创建同步 死锁崩溃
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example72 {
    
    //串行队列   同步里面创建异步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example73 {
    
    //串行队列   异步里面创建同步 死锁崩溃
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
}

-(void)example74 {
    
    //串行队列   异步里面创建异步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example81 {
    
    //并发队列   同步里面创建同步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_sync(queue, ^{
            sleep(1);
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example82 {
    
    //并发队列   同步里面创建异步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        sleep(3);
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_async(queue, ^{
            sleep(1);
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
            NSLog(@"走到这里了");
        });
    });
    NSLog(@"结束");
}

-(void)example83 {
    
    //并发队列   异步里面创建同步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(3);
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_sync(queue, ^{
            sleep(1);
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
}

-(void)example84 {
    
    //并发队列  异步里面创建异步 正常
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(3);
        NSLog(@"任务1...");
        NSLog(@"%@", [NSThread currentThread]);
        dispatch_async(queue, ^{
            sleep(1);
            NSLog(@"任务2...");
            NSLog(@"%@", [NSThread currentThread]);
            NSLog(@"走到这里了");
        });
    });
    NSLog(@"结束");
}

-(void)example91{
    
    //任务1和任务2在同一个线程里，在不同的队列里面，可以同步执行 运行正常
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue1, ^{
        NSLog(@"%@", [NSThread currentThread]);
        NSLog(@"任务1...");
        dispatch_sync(queue2, ^{
            NSLog(@"%@", [NSThread currentThread]);
            NSLog(@"任务2...");
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example92{
    
    //任务1和任务2在两个不同线程里，并且两个不同队列，不会造成死锁 可以正常运行
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue1, ^{
        NSLog(@"%@", [NSThread currentThread]);
        NSLog(@"任务1...");
        dispatch_async(queue2, ^{
            NSLog(@"%@", [NSThread currentThread]);
            NSLog(@"任务2...");
        });
        NSLog(@"走到这里了");
    });
    NSLog(@"结束");
    
}

-(void)example10 {
    //异步串行group
    //创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sccc", DISPATCH_QUEUE_SERIAL);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        [self doSomething:^() {
            NSLog(@"任务一");
        }];
    });
    dispatch_group_async(group, queue, ^{
        [self doSomething:^() {
            NSLog(@"任务二");
        }];
    });
    dispatch_group_async(group, queue, ^{
        [self doSomething:^() {
            NSLog(@"任务三");
        }];
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"前面的任务已完成");
    });
    
}

-(void)example11 {
    //异步串行group
    //创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sccc", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        [self doSomething:^() {
            NSLog(@"任务一");
        }];
    });
    dispatch_group_async(group, queue, ^{
        sleep(3);
        [self doSomething:^() {
            NSLog(@"任务二");
        }];
    });
    dispatch_group_async(group, queue, ^{
        
        [self doSomething:^() {
            NSLog(@"任务三");
        }];
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"前面的任务已完成");
    });
    
}

- (void)doSomething:(void (^)(void))handler {
    if (handler) {
        sleep(2);
        handler();
    }
}

-(void)example12 {
    
    // 因为 dispatch_group_async 里面的任务是异步的，所以任务在执行的时候，它不会去等待 for 循环执行结束，它会直接跳过 dispatch_async 这 block 执行下一句去了，所以 dispatch_group_notify 也会很快就执行。
    
    
    // 创建一个group
    dispatch_group_t group = dispatch_group_create();
    // 创建一个队列：全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // 将任务1添加到 group 中
    dispatch_group_async(group, queue, ^{
        // 模拟异步网络请求
        sleep(5);
        NSLog(@"任务一完成");
    });
    
    // 将任务2添加到 group 中
    dispatch_group_async(group, queue, ^{
        // 模拟异步网络请求
        sleep(3);
        NSLog(@"任务二完成");
    });
    
    // 任务1和任务2执行结束，回调
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"完成任务");
        });
    });
    
    
    
}

-(void)example13 {
    // 创建一个group
    dispatch_group_t group = dispatch_group_create();
    // 创建一个队列：全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // 进入group
    dispatch_group_enter(group);
    
    // 模拟异步网络请求
    dispatch_async(queue, ^{
        
        sleep(3);
        // 离开group
        NSLog(@"任务一完成");
        dispatch_group_leave(group);
        
        
    });
    
    // 进入group
    dispatch_group_enter(group);
    
    // 模拟异步网络请求
    dispatch_async(queue, ^{
        
        sleep(4);
        // 离开group
        NSLog(@"任务二完成");
        dispatch_group_leave(group);
        
        
    });
    
    
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"完成任务");
        });
    });
    
}

-(void)example14{
    // 创建一个group
    dispatch_group_t group = dispatch_group_create();
    // 创建一个队列：全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // 创建信号量，并且设置值为0
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    // 将任务1添加到 group 中
    dispatch_group_async(group, queue, ^{
        
        // 模拟异步网络请求
        dispatch_async(queue, ^{
            sleep(3);
            NSLog(@"任务一完成");
            
            // 每次发送信号则 semaphore 会 +1
            dispatch_semaphore_signal(semaphore);
            
        });
        // 由于是异步执行的，当 semaphore 等于 0，则会阻塞当前线程，直到执行了 block 的 dispatch_semaphore_signal，semaphore + 1，才会继续执行。
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
    });
    
    // 将任务2添加到 group 中
    dispatch_group_async(group, queue, ^{
        
        // 模拟异步网络请求
        dispatch_async(queue, ^{
            sleep(3);
            NSLog(@"任务二完成");
            
            dispatch_semaphore_signal(semaphore);
            
        });
        
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    });
    
    
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"完成任务");
        });
    });
    
    
}

@end

3.4.3.3.线程间的通信

  • Direct messaging：这是大家非常熟悉的**-performSelector:系列**。
  • Global variables…：直接通过全局变量、共享内存等方式，但这种方式会造成资源抢夺，涉及到线程安全问题。
  • Conditions：一种特殊的锁–条件锁，当使用条件锁使一个线程等待（wait）时，该线程会被阻塞并进入休眠状态，在另一个线程中对同一个条件锁发送信号（single），则等待中的线程会被唤醒继续执行任务。
  • Run loop sources：通过自定义Run loop sources来实现，后面的文章会单独研究Run loop。
  • Ports and sockets：通过端口和套接字来实现线程间通讯。
  • Run loop：NSMachPort

3.4.3.4.其他应用

1.延时执行
iOS常见三种延时执行方式
1）调用NSObject的方法

 [self performSelector:@selector(需要执行的方法名) withObject:nil afterDelay:2.0]

2）使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2秒后执行这里的代码..
    });

3）使用定时器

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(需要执行的方法名) userInfo:nil repeats:NO];

2.一次性代码

 static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
       //里面的代码只会被执行一次
    });

3.队列组

有这么一个需求，首先：分别异步执行2个耗时的操作，其次：等2个异步操作都执行完毕后，再回到主线程执行操作，如果想要快速高效地实现上述需求，可以考虑用队列组。

    dispatch_group_tgroup =  dispatch_group_create();  
      
    dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
      
        // 执行1个耗时的异步操作  
      
    });  
      
    dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
      
        // 执行1个耗时的异步操作  
      
    });  
      
    dispatch_group_notify(group,dispatch_get_main_queue(), ^{  
      
        // 等前面的异步操作都执行完毕后，回到主线程...  
      
    });

4.快速迭代
我只想说速度非常快,要加一个__block因为block代码默认不能改外面的东西
这里写图片描述

5.barry执行任务函数

在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行。
下面的例子是在添加到队列的任务1、任务2、任务3执行完毕后，然后才执行barrier，barrier执行完毕后才执行任务4、任务5。
这里写图片描述

dispatch_barrier在并发队列中创建一个同步点，当并发队列中遇到一个 dispatch_barrier时，会延时执行该 dispatch_barrier，等待在 dispatch_barrier之前提交的任务block执行完后才开始执行，之后，并发队列继续执行后续block任务。

6.GCD与定时器

@property (nonatomic,strong) dispatch_source_t timer;

- (void) myTimer {
    self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
    // 设置定时器的触发时间（1秒后）和时间间隔（每隔2秒）
    dispatch_source_set_timer(self.timer, dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC), 2 * NSEC_PER_SEC, 0);
    // 设置回调
    dispatch_source_set_event_handler(self.timer, ^{
        NSLog(@"Timer %@", [NSThread currentThread]);
    });
    // 开始定时器
    dispatch_resume(self.timer);
}


-(void)viewDidDisappear:(BOOL)animated {
    dispatch_cancel(self.timer);
    self.timer = nil;
}
styleqiang
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
iOS-开辟子线程(NSThread、NSOperationQueue、GCD)
SSY_1992的博客
02-23 6221
本节主要总结一些开辟子线程的常用的几种方法。 一、通过NSThread类开辟子线程 1.NSThread手动开启子线程 // 创建线程对象. NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(eat) object:nil]; thread.name = @"a"; // 手动开启线程 ...
QT中一种简单的开线程方法QThread
video_plugin_yue的博客
05-18 1363
QThread开启线程，及其使用步骤，安全退出的方法
[iOS]进程-线程-队列-任务
最新发布
Gamin
04-07 1048
进程是一个执行中的程序的实例。它是系统资源（如 CPU 时间、内存空间、文件描述符等）分配的基本单位。每个进程都运行在其自己的隔离空间内，操作系统负责管理进程的生命周期以及它们对系统资源的使用。在iOS开发中，使用Grand Central Dispatch (GCD)可以创建自定义队列（Custom Queues）。自定义队列可以是串行的也可以是并行的，取决于你的需求。
ios 里几种开新线程的方法
3句半
04-15 654
ios里几种常用开线程的方法主要有以下几种 1.NSObject [obj performSelectorInBackground:@selector(testTherd:) withObject:@"performSelectorInBackground"]; 2.NSThread   NSThread * newThread = [[NSThread alloc] initWi
ios多线程开发的常用四种方式和基本使用
哈皮吖的博客
11-23 6040
ios多线程开发的常用四种方式 1. pthread 2. NSThread 3. NSOperation\NSOperationQueue 4. GCD 一 、pthread C语言通用的多线程API，跨平台，程序员手动管理线程生命周期，使用难度大 代码实现 //创建线程 NSLog(@"开始执行"); int pthread_create(pthread_t * __restrict ,...
iOS底层原理之多线程
面壁者LOGIC
10-15 959
iOS底层原理之多线程
iOS 开发 之 多线程总结
03-23
iOS开发中的多线程技术是提升应用性能和用户体验的关键，特别是在处理耗时操作时，如网络请求、数据计算或大文件上传。本文将对多线程进行深入总结，主要涵盖线程的基本概念、使用多线程的原因以及在iPhone平台上...
IOS开发-多线程队列测试代码
01-04
// 单线程和多线程并发队列测试(同步和异步) // // 基础原理： // 1)队列： // 1.1 dispatch_queue_t 是一个队列,一个FIFO的消费队列 // 1.2 消费者：队列配置的运行线程 // 1.3 被消费对象: 添加到队列中的运行任务...
IOS多线程开发之线程的状态
09-03
在iOS开发中，多线程技术是提升用户体验和优化应用程序性能的关键。本文主要探讨了iOS多线程开发中线程的状态及其管理。线程状态的理解和控制对于编写高效且无阻塞的代码至关重要。 首先，我们需要了解线程的生命...
iOS开发中多线程的安全隐患总结
08-25
iOS开发中多线程的安全隐患总结 iOS开发中多线程的安全隐患是一种常见的问题，一旦不当处理，可能引发数据错乱和数据安全问题。解决方案是使用线程同步技术，常见的线程同步技术有：加锁（OSSpinLock、os_unfair_...
OS 的多线程原理、分类与应用
laikaikai的博客
09-03 355
OS 的多线程原理、分类与应用 今天查资料才发现，iOS 中的线程使用不是无限制的，官方文档给出的资料显示 iOS 下的主线程堆栈大小是 1M，第二个线程开始都是 512KB，并且该值不能通过编译器开关或线程 API 函数来更改。另外只有主线程有直接修改 UI 的能力。所以也学习并总结下 iOS 的多线程编程来加深下吧。 关于 RunLoop NSThread NS
iOS开发多线程在实际项目中的运用
Ocean WANG的博客
09-27 5813
在实际项目开发中为了能够给用户更好的体验，有些延时操作我们都会放在子线程中进行。 今天我们就来聊聊多线程在实际项目中的运用。
多线程编程1 - NSThread
热门推荐
M了个J
02-02 2万+
每个iOS应用程序都有个专门用来更新显示UI界面、处理用户的触摸事件的主线程，因此不能将其他太耗时的操作放在主线程中执行，不然会造成主线程堵塞(出现卡机现象)，带来极坏的用户体验。一般的解决方案就是将那些耗时的操作放到另外一个线程中去执行，多线程编程是防止主线程堵塞，增加运行效率的最佳方法 iOS支持多个层次的多线程编程，层次越高的抽象程度越高，使用也越方便，也是苹果最推荐使用的方法。下面根据抽
iOS 线程保活
kangpp的博客
09-25 3013
iOS 线程保活的三种方案。 目前从网上找到三种线程保活的方案，前两种通过 RunLoop实现，第三种通过条件锁实现。 首先我们自己创建 KYThread 继承 NSThread 并重写 dealloc 方法，用于判断线程是否被销毁。 @interface KYThread : NSThread @end @implementation KYThread - (void) dealloc { ...
在IOS中使用多线程
phxiang的博客
02-08 873
多线程是一个比较轻量级的方法来实现单个应用程序内多个代码执行路径。 在系统级别内，程序并排执行，程序分配到每个程序的执行时间是基于该程序的所需时间和其他程序的所需时间来决定的。 然而，在每个程序内部，存在一个或者多个执行线程，它同时或在一个几乎同时发生的方式里执行不同的任务。 概要提示： iPhone中的线程应用并不是无节制的，官方给出的资料显示，iPhone OS下的主线程的堆栈大小是1M
iOS主线程和主队列的区别
iOS_开发
09-16 1752
程序员大咖点击右侧关注，免费进阶高级！作者：大神Q链接：https://www.jianshu.com/p/c3545fc343b8这个问题之前也有看到，正好这两天看到一...
iOS 接收通知的线程一定是主线程吗？
frankisbaby的博客
03-16 4841
问题：在主线程中A对象监听到通知B后，调用函数functionX。然后我们开启一条子线程，在子线程中发出通知B。现在问A对象执行方法functionX时是在哪个线程？ In a multithreaded application, notifications are always delivered in the thread in which the notification wa...
【iOS沉思录】iOS子线程更新UI到主线程的三种方法
Mr_厚厚的博客
02-08 2万+
以下代码有什么问题？如何修复？@interface TTWaitController : UIViewController@property (strong, nonatomic) UILabel *alert;@end@implementation TTWaitController- (void)viewDidLoad { CGRect frame = CGRectMake(20, 200
iOS 多线程管理之 NSThread
qq_41644715的博客
05-04 195
iOS 多线程管理之 NSThread NSThread 是苹果官方提供的，使用起来比 pthread 更加面向对象，简单易用，可以直接操作线程对象。不过也需要需要程序员自己管理线程的生命周期(主要是创建)，我们在开发的过程中偶尔使用 NSThread。比如我们会经常调用 [NSThread currentThread] 来显示当前的进程信息。 构造方法 init 方法 创建一个带有方法体的...
1. iOS的多线程机制和常见的多线程技术有哪些？
05-12
iOS的多线程机制主要是基于POSIX标准的线程库实现的。在iOS中，常见的多线程技术包括以下几种： 1. NSThread：是iOS中最原始的多线程技术，可以手动创建线程并控制线程的生命周期，但需要开发者自行管理线程的状态和同步问题。 2. GCD（Grand Central Dispatch）：是Apple推出的一种基于C语言的多线程技术，它提供了一套高效的队列模型，用于管理任务和线程的执行。GCD可以自动管理线程的创建和销毁，同时还能够实现多种同步和异步的任务调度方式。 3. NSOperationQueue：是一个基于GCD的高级多线程技术，它提供了一套面向对象的API，用于管理任务和线程的执行。NSOperationQueue可以实现任务的依赖关系和优先级控制，同时还能够方便地实现任务的取消和暂停。 4. pthread：是基于POSIX标准的线程库，可以手动创建和管理线程，同时提供了一套基本的同步和互斥机制。 以上这些多线程技术在iOS开发中都有广泛的应用，开发者可以根据具体的场景和需求选择合适的技术来实现多线程编程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值