iOS开发 - 在实战中挖掘之线程间的通信方式

怼烎@ 2023-09-30 15:30 7阅读 0赞

技术这行怎么变的高大上呢？那一定是抛出一个个的专有名词，很多时候，我们在谈论技术的时候，往往忘记了技术本身的作用是什么？我不能说这有多不好，但多少还是会有失偏颇。

今天我们要说的内容是线程间通信，说得直白的点就是子线程完成任务后回主线程刷新UI，或者是多个线程共享数据，产生依赖关系。

我相信这种通信方式但凡是个程序猿就一定在项目中用过，但当换个名字问的时候很多人就一时不知道说的是什么，这让我想起前几天有人问我快捷开发，搞的我一愣，后来了解才知道就是所谓的敏捷开发，什么是敏捷开发？说实话我个人也参与过所谓敏捷开发的项目，还真没感觉和平时的项目有什么区别，最多开发的快一点？哈哈......

言归正传，什么是线程间通信呢？

首先我们要先知道什么是线程，线程分为四种：

`1.pthread`：即`POSIX Thread`，缩写称为`Pthread`，是线程的`POSIX`标准，是一套通用的多线程`API`，可以在`Unix/Linux/Windows`等平台跨平台使用。`iOS`中基本不使用。

`2.NSThread`：苹果封装的面向对象的线程类，可以直接操作线程，比起`GCD`，`NSThread`效率更高，由程序员自行创建，当线程中的任务执行完毕后，线程会自动退出，程序员也可手动管理线程的生命周期。使用频率较低。

`3.GCD`：全称`Grand Central Dispatch`，由`C`语言实现，是苹果为多核的并行运算提出的解决方案，`CGD`会自动利用更多的`CPU`内核，自动管理线程的生命周期，程序员只需要告诉`GCD`需要执行的任务，无需编写任何管理线程的代码。`GCD`也是`iOS`使用频率最高的多线程技术。

`4.NSOperation`：基于`GCD`封装的面向对象的多线程技术，常配合`NSOperationQueue`使用，面向对象，提供了一些GCD所没有的能力，使用频率较高。

除了第一种，余下三种算是我们都比较常用的，我们先来说说简单的线程通信：

#### 1.子线程完成任务后，回到主线程刷新UI ####

1）NSThread

- (void)viewDidLoad
    {
        NSURL *url = [NSURL URLWithString:@"xxxxxxx"];
        开启线程，在后台执行图片下载方法
       [self performSelectorInBackground:@selector(downloadImg:) withObject:url];
    }
    
    - (void)downloadImg:(NSURL *)url
    {
        NSData *data = [NSData dataWithContentsOfURL:url];
        UIImage *image = [UIImage imageWithData:data];
        // 回到主线程中执行图片赋值的方法
        [self performSelector:@selector(showImg:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
    }
    
    -(void)showImg:(UIImage *)image
    {
        // 刷新UI
        self.imageView.image = image;
    }

2）GCD

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        dispatch_async(queue, ^{
            NSURL *url = [NSURL  URLWithString:@"xxxxxxxxxx"];
            NSData *data = [NSData dataWithContentsOfURL:url];
            UIImage *image = [UIImage imageWithData:data];
            /*
                异步函数调用, 先执行完其他代码, 再更新UI
                同步函数调用, 先更新UI, 再执行其它代码
                根据具体需要来选择
            */
            dispatch_sync(dispatch_get_main_queue(), ^{
                self.imageView.image = image;
                NSLog(@"Refreshed UI");
            });
            NSLog(@"我位置靠后");
        });

3）`NSOperation`

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
        [queue addOperationWithBlock:^{
            NSURL *url  = [NSURL URLWithString:@"xxxxxxx"];
            NSData *data = [NSData dataWithContentsOfURL:url];
            UIImage *image = [UIImage imageWithData:data];
            //回主线程刷新UI
            [[NSOperationQueue mainQueue] addOperationWithBlock:^{
                self.imageView.image = image;
            }];
        }];

#### 2.线程之间相互依赖 ####

有依赖的场景经常会发生在GCD和`NSOperation上面，不是说NSThread不行，只是这两种方式更好使用，下面讲讲这两者怎么添加相互依赖：`

`1）GCD`

`GCD的依赖一般是一个线程依赖于另一个线程中的某些数据，我们常说的线程安全，比如读写，也可以认为是一种依赖关系，我们一般通过三种方式来做：`

*  ddispatch\_group\_notify

dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    [[WebImageManager sharedManager]downloadImageWithURL:@"xxxxxxxxxx" completed:^(UIImage *image, NSError *error, ImageCacheType cacheType, BOOL finished) {
        dispatch_group_leave(group);
    }];
    
    dispatch_group_enter(group);
    [[WebImageManager sharedManager]downloadImageWithURL:@"xxxxxxxxxx" completed:^(UIImage *image, NSError *error, ImageCacheType cacheType, BOOL finished) {
        dispatch_group_leave(group);
    }];
                
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    
    });

dispatch\_group\_enter(group);和dispatch\_group\_leave(group);都是成对出现的，一个进，就要一个出，这里也可以选择普通dispath\_async来做，总之notify的作用就是形成一个栅栏，把栅栏之前的代码围堵起来执行完毕后再执行栅栏和栅栏之后的代码。

*  信号量

AFNetworking中就有这么一段运用，创建信号量，执行任务，dispatch\_semaphore\_signal信号量+1，这时候任务已经在执行，在没有执行完毕时，信号量大于0，所以其他任务无法进入，dispatch\_semaphore\_wait设置等待时长，当前线程被阻塞，当任务执行完毕后，信号总量-1，此时，其他任务可以进入。

信号量可以用来做并发控制，设置最多允许的可访问临界区域的数量就可以，dispatch\_semaphore\_create(0)，0可以修改。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
        __block NSArray *tasks = nil;
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
            if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
                tasks = dataTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
                tasks = uploadTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
                tasks = downloadTasks;
            } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
                tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
            }
    
            dispatch_semaphore_signal(semaphore);
        }];
    
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
        return tasks;
    }

*  `NSOperation`

`NSOperation中有一种添加依赖的方式，我们来看看代码：`

//创建一个队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    //下载第一张图片
    __block UIImage *img1 = nil;
    NSBlockOperation *opb1 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"xxxxx"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        img1 = [UIImage imageWithData:data];
    }];
    
    //下载第二张图片
    __block UIImage *img2 = nil;
    NSBlockOperation *opb2 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"xxxxx"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        img2 = [UIImage imageWithData:data];
    }];
    //image1和image2合成
    NSBlockOperation *opb3 = [NSBlockOperation blockOperationWithBlock:^{
        UIGraphicsBeginImageContext(CGSizeMake(400, 200));
        [img1 drawInRect:CGRectMake(0, 0, 200, 200)];
        [img2 drawInRect:CGRectMake(200, 0, 200, 200)];
        UIImage *ads = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
    
        //回到主线程更新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            self.imageView.image = ads;
        }];
    }];
    
    //添加依赖
    [opb3 addDependency:opb1];
    [opb3 addDependency:opb2];
    
    //添加到队列
    [queue addOperation:opb1];
    [queue addOperation:opb2];
    [queue addOperation:opb3];

--------------------

简单的线程通信我们说完了，接下来就来说说稍微复杂点的，[苹果官方文档][Link 1]给出的线程间通信的方式有以下几种：

<table> 
 Table 1-3&nbsp;&nbsp;Communication mechanisms 
 <tbody> 
 <tr> 
 <th> Mechanism </th> 
 <th> Description </th> 
 </tr> 
 <tr> 
 <td> Direct messaging </td> 
 <td> Cocoa applications support the ability to perform selectors directly on other threads. This capability means that one thread can essentially execute a method on any other thread. Because they are executed in the context of the target thread, messages sent this way are automatically serialized on that thread. For information about input sources, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html#//apple_ref/doc/uid/10000057i-CH16-SW44" title="Cocoa Perform Selector Sources" rel="nofollow">Cocoa Perform Selector Sources</a>.&nbsp; </td> 
 </tr> 
 <tr> 
 <td> Global variables, shared memory, and objects </td> 
 <td> Another simple way to communicate information between two threads is to use a global variable, shared object, or shared block of memory. Although shared variables are fast and simple, they are also more fragile than direct messaging. Shared variables must be carefully protected with locks or other synchronization mechanisms to ensure the correctness of your code. Failure to do so could lead to race conditions, corrupted data, or crashes.&nbsp; </td> 
 </tr> 
 <tr> 
 <td> Conditions </td> 
 <td> Conditions are a synchronization tool that you can use to control when a thread executes a particular portion of code. You can think of conditions as gate keepers, letting a thread run only when the stated condition is met. For information on how to use conditions, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html#//apple_ref/doc/uid/10000057i-CH8-SW4" title="Using Conditions" rel="nofollow">Using Conditions</a>.&nbsp; </td> 
 </tr> 
 <tr> 
 <td> Run loop sources </td> 
 <td> A custom run loop source is one that you set up to receive application-specific messages on a thread. Because they are event driven, run loop sources put your thread to sleep automatically when there is nothing to do, which improves your thread’s efficiency. For information about run loops and run loop sources, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html#//apple_ref/doc/uid/10000057i-CH16-SW1" title="Run Loops" rel="nofollow">Run Loops</a>.&nbsp; </td> 
 </tr> 
 <tr> 
 <td> Ports and sockets </td> 
 <td> Port-based communication is a more elaborate way to communication between two threads, but it is also a very reliable technique. More importantly, ports and sockets can be used to communicate with external entities, such as other processes and services. For efficiency, ports are implemented using run loop sources, so your thread sleeps when there is no data waiting on the port. For information about run loops and about port-based input sources, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html#//apple_ref/doc/uid/10000057i-CH16-SW1" title="Run Loops" rel="nofollow">Run Loops</a>.&nbsp; </td> 
 </tr> 
 <tr> 
 <td> Message queues </td> 
 <td> The legacy Multiprocessing Services defines a first-in, first-out (FIFO) queue abstraction for managing incoming and outgoing data. Although message queues are simple and convenient, they are not as efficient as some other communications techniques. For more information about how to use message queues, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Carbon/Conceptual/Multitasking_MultiproServ/01introduction/introduction.html#//apple_ref/doc/uid/TP40000853" title="Multiprocessing Services Programming Guide" rel="nofollow">Multiprocessing Services Programming Guide</a>. </td> 
 </tr> 
 <tr> 
 <td> Cocoa distributed objects </td> 
 <td> Distributed objects is a Cocoa technology that provides a high-level implementation of port-based communications. Although it is possible to use this technology for inter-thread communication, doing so is highly discouraged because of the amount of overhead it incurs. Distributed objects is much more suitable for communicating with other processes, where the overhead of going between processes is already high. For more information, see&nbsp;<a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/DistrObjects/DistrObjects.html#//apple_ref/doc/uid/10000102i" title="Distributed Objects Programming Topics" rel="nofollow">Distributed Objects Programming Topics</a>.&nbsp; </td> 
 </tr> 
 </tbody> 
</table>

按照技术复杂度由低到高排列，其中后两种只能在`OS X`中使用，我们暂且忽略：

*  `Direct messaging`：其实这就是大家最熟悉的perforSelector。

*  `Global variables...`：通过全局变量、共享内存等方式，但这种方式会造成资源抢夺，涉及到线程安全问题，所以上面列出的notify和信号量就可以用来解决这种方式。

*  `Conditions`：一种特殊的锁--条件锁，当使用条件锁使一个线程等待（`wait`）时，该线程会被阻塞并进入休眠状态，在另一个线程中对同一个条件锁发送信号（`single`），则等待中的线程会被唤醒继续执行任务，有点像信号量？

*  `Run loop sources`：通过自定义`Run loop sources`来实现，在AF中就曾使用添加port的方式来使线程保活。

*  `Ports and sockets`：通过端口和套接字来实现线程间通讯。

关于NSPort，NSPort有3个子类，NSSocketPort、NSMessagePort、NSMachPort，NSMachPort和NSMessagePort只允许本地（在一样的机器上）通信。NSSocketPort允许本地和远程两种通讯，但是对于本地通信，NSSocketPort会更加耗费资源。创建NSPort对象，可以使用allocWithZone:或port，NSMachPort对象创建例外。所以综上所述，在iOS下只有NSMachPort可用。

使用的方式为接收线程中注册的NSMachPort，在另外的线程中使用此port发送消息，则被注册线程会收到相应消息，最终在主线程里调用某个回调函数。

可以看到，使用NSMachPort的结果为调用了其它线程的1个函数，而这正是performSelector所做的事情，这时候你会发现，NSThread的使用突然高大上起来，由此可见，NSMachPort就有些鸡肋，但这并不妨碍你使用。如果你要线程保活的话，当然还是推荐使用port来做，实际上，port什么都没做，只是起到唤醒runloop的作用。

> 总结：到这里，线程间通信的方式基本上算是讲全了，只是碍于业务发展，有些并不适合，也并不常用，选择适合业务场景的才是最好的，不要盲目使用，反而会影响性能。

[Link 1]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/AboutThreads/AboutThreads.html