[转]iOS 的多线程同步

  • 作者：adolsai
  • 时间：August 17, 2015
  • 分类：FW,Objective-C

转载：iOS 的多线程同步 by zqqf16

我的上一家公司有个引以为豪的技术：多核无锁，不仅避免了各种由锁带来的问题，还极大的提高了性能，所以产品性能能够在业界数一数二。 在这样的氛围影响下，我在开发的时候也很少用锁，能不用就不用。 后来去面试 iOS 开发的时候，面试官总是喜欢问有关于锁的问题，最近趁有时间就整理了一下，算是补充一下技能树吧。

1.互斥锁（Mutex）

互斥锁是比较常用的一种锁，当一个线程试图获取被另一个线程占用的锁时，它将会被挂起，让出 CPU，直到该锁被释放。

在 iOS 中，互斥锁有多种实现方式：

1.1 POSIX Api

POSIX 方式的优点是比较通用，对那些需要跨平台的 library 来说再合适不过了。

POSIX 中与互斥锁有关的主要有 5 个函数：

  • pthread_mutex_init 初始化锁
  • pthread_mutex_lock 加锁
  • pthread_mutex_tylock 加锁，当锁被占用时，返回 busy，不挂起线程。
  • pthread_mutex_unlock 释放锁
  • pthread_mutex_destroy 销毁锁

例子：

#include <pthread.h>

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

void mutiThreadMethod()
{
    pthread_mutex_lock(&mutex);

    // Do something

    pthread_mutex_unlock(&mutex);
}

void destroyLock()
{
    pthread_mutex_destroy(&mutex);
}

1.2 @synchronized

@synchronized 应该是用起来最简单的方式了，例如：

- (void)mutiThreadMethod2
{
    @synchronized(self) {
        // Do something
    }
}

用 clang 改写一下就可以发现，其实编译器为这个语法糖做了很多工作，大致如下：

//...

objc_sync_enter
objc_exception_try_enter
setjmp
objc_exception_extract

// Do something

objc_exception_try_exit
objc_sync_exit
// ...
objc_exception_throw
// ...

可以看到做了很多与锁有关的操作，其性能不如 POSIX 方式，尽管后者难看些。

1.3 NSLock

NSLock *lock = [[NSLock alloc] init];

// ...

- (void)mutiThreadMethod3
{
    if ([lock tryLock]) {
        // Do something
        // ...
        [lock unlock];
    }
}

2. 递归锁（Recursive Lock）

递归锁是互斥锁的变体，它允许一个线程在释放它之前多次获取它，并且只有在释放相同次数之后其它线程才能获取它。

NSRecursiveLock *theLock = [[NSRecursiveLock alloc] init];

void MyRecursiveFunction(int value)
{
    [theLock lock];
    if (value != 0)
    {
        --value;
        MyRecursiveFunction(value);
    }
    [theLock unlock];
}

MyRecursiveFunction(5);

3. 读写锁（Read-write Lock）

读写锁把访问对象划分为读者和写者，当读写锁在读加锁状态时，所有的试图以读加锁方式对其进行加锁时，都会获得访问权限。 所有的试图以写加锁方式对其加锁的线程都将阻塞，直到所有的读锁释放。 当在写加锁状态时，所有试图对其加锁的线程都将阻塞。

读写锁适合读操作远大于写操作的情况。

在 iOS 上，读写锁得用 POSIX 方式实现。POSIX 提供的相关函数如下：

  • pthread_rwlock_init 初始化读写锁
  • pthread_rwlock_rdlock 读加锁
  • pthread_rwlock_wrlock 写加锁
  • pthread_rwlock_unlock 释放锁
  • pthread_rwlock_destroy 销毁锁
    例子：
#include <pthread.h>

pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);

void mutiThreadWritting()
{
    pthread_rwlock_wrlock(&rwlock);
    // write
    pthread_rwlock_unlock(&rwlock);
}

void mutiThreadReadding()
{
    pthread_rwlock_rdlock(&rwlock);
    // read
    pthread_rwlock_unlock(&rwlock);
}

4. 自旋锁（Spin Lock）

自旋锁与互斥锁不同的地方在于，自旋锁是非阻塞的，当一个线程无法获取自旋锁时，会自旋，直到该锁被释放，等待的过程中线程并不会挂起。

它的优点是效率高，不用进行线程切换。缺点是如果一个线程霸占锁的时间过长，自旋会消耗 CPU 资源。

#import <libkern/OSAtomic.h>

static OSSpinLock lock = OS_SPINLOCK_INIT;

void mutiThreadMethod4
{
    OSSpinLockLock(&lock);
    // Do something
    OSSpinLockUnlock(&lock);
}

5. 分布锁（Distributed Lock）

严格来说，分布锁是进程间同步的工具，有点像 Unix 下的各种 lock 文件，比如 apt-get 的 “/var/lib/apt/lists/lock”。

它并不强制进程休眠，只是起到告知的作用。具体如何处理资源被占，完全由进程自己决定。

iOS 上几本用不上分布锁，在 OS X 中，可以用 NSDistributedLock 实现：

NSDistributedLock *lock = [NSDistributedLock lockWithPath:path];

// ...

if ([lock tryLock]) {
    // Do something
    [lock unlock];
}

或者，可以直接通过写 lock 文件的方式来实现。

6. 条件变量（Condition Variable）

如果一个线程需要等待某一条件才能继续执行，而这个条件是由别的线程产生的，这时候只用锁就有点捉襟见肘了。要么不停的轮询，消耗资源，要么每隔一段时间查询一次，丧失了及时性。 条件变量就是为了满足这种场景而生的，它可以让一个线程等待某一条件，当条件满足时，会收到通知。 在获取条件变量并等待条件发生的过程中，也会产生多线程的竞争，所以条件变量通常会和互斥锁一起工作。

iOS 中，条件变量有两种实现方式：

6.1 POSIX

POSIX 提供的相关函数如下：

  • pthread_cond_init 初始化
  • pthread_cond_wait 等待条件
  • pthread_cond_broadcast 发送广播，唤醒所有正在等待的线程
  • pthread_cond_signal 发送信号，唤醒第一个线程
  • pthread_cond_destroy 销毁
    例子：
#include <pthread.h>

static pthread_mutex_t mutex;
static pthread_cond_t condition;

// ...

pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&condition, NULL);

// ...

void waitCondition()
{
    pthread_mutex_lock(&mutex);
    while (value == 0) {
        pthread_cond_wait(&condition, &mutex);
    }
    pthread_mutex_unlock(&mutex);
}

void triggerCondition()
{
    pthread_mutex_lock(&mutex);

    value = 1;

    pthread_mutex_unlock(&mutex);
    pthread_cond_broadcast(&condition);
}

// ...

pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&condition);

6.2 NSCondition

例子摘自 Threading Programming Guide

[cocoaCondition lock];
while (timeToDoWork <= 0)
    [cocoaCondition wait];

timeToDoWork--;

// Do real work here.

[cocoaCondition unlock];

发送信号：

[cocoaCondition lock];
timeToDoWork++;
[cocoaCondition signal];
[cocoaCondition unlock];

7. NSConditionLock

NSConditionLock 跟 NSCondition 类似，但是实现机制是不一样的，所以单独列了出来。

例子：

生产者

id condLock = [[NSConditionLock alloc] initWithCondition:NO_DATA];

while(true)
{
    [condLock lock];
    // Add data to the queue.
    [condLock unlockWithCondition:HAS_DATA];
}

消费者

while (true)
{
    [condLock lockWhenCondition:HAS_DATA];
    // Remove data from the queue.
    [condLock unlockWithCondition:(isEmpty ? NO_DATA : HAS_DATA)];

    // Process the data locally.
}

8. 信号量（Semaphore）

信号量可以看成是一种特殊的互斥锁，不同的是，它可以不只有两个状态，它可以是资源的计数器。还记得《操作系统》中学过的 PV 操作么？

iOS 中，信号量有两种实现方式：

8.1 POSIX

POSIX 提供的相关函数如下：

  • sem_init 初始化
  • sem_post 给信号量的值加一（V 操作）
  • sem_wait 给信号量的值减一（P 操作）
  • sem_getvalue 返回信号量的值
  • sem_destroy 销毁

8.2 GCD 信号量

GCD 提供的函数如下：

  • dispatch_semaphore_create 创建信号量
  • dispatch_semaphore_signal 发送信号（信号量加一，V 操作）
  • dispatch_semaphore_wait等待信号（信号量减一，P 操作）
    例子：
dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);

// ...

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// Do something
dispatch_semaphore_signal(semaphore);

9. 栅栏／屏障（Barrier）

如果一个线程需要等待另一个线程的某些操作之后才能继续执行，可以用上面所说的条件变量来实现，还有一种优雅的实现方式 —— Barrier。 形象点说，就是把线程挡在同一个 Barrier 之前，所有的线程都达到 Barrier 之后，统一放行。

同样，iOS 中有两种实现方式：

9.1 POSIX

相关函数如下： - pthread_barrier_init 创建 barrier - pthread_barrier_wait 告知当前线程已经到达 barrier，等所有线程都告知后，会继续往下执行 - pthread_barrier_destroy 销毁

9.2 Dispatch Barrier

Dispatch Barrier 的概念跟 POSIX 类似，不同的是它是针对于 GCD 异步任务的。它可以让在它之前提交的异步任务都执行完成之后再执行。

例子：

dispatch_async(async_queue, block1);
dispatch_async(async_queue, block2);
// block3 会在 block1 和 block2 执行完成之后再执行
dispatch_barrier_async(async_queue, block3);
// block4 和 block5 会在 block3 之后执行
dispatch_async(async_queue, block4);
dispatch_async(async_queue, block5);

后记
锁 这个东西可谓 “小用怡情，滥用伤身”，用的时候一不小心就会有各种各样的问题，比如死锁，我曾经就这样写过：

void func()
{
    LOCK;

    //...

    if (someCondition) {
        return;
    }

    UNLOCK;
}

在 iOS 中，很多时候都可以用 GCD 的串行队列来避免使用锁：

dispatch_async(serialQueue, block);

因为串行队列中的任务一次只能执行一个，所以就不存在资源的竞争，还能有效的避免死锁问题。

标签：ios, object-c