多线程与GCD

线程

进程和线程

• 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行。
• 进程要想执行任务，必须得有线程，进程至少要有一条线程
• 程序启动会默认开启一条线程，这条线程被称为主线程或 UI 线程。

关系

• 地址空间:同一进程的线程共享本进程的地址空间，而进程之间则是独立的地址空间。
• 资源拥有:同一进程内的线程共享本进程的资源如内存、I/O、cpu等，但是进程之间的 资源是独立的。

多线程

• 对于单核CPU，同一时间，CPU只能处理一条线程，即只有一条线程在工作(iOS中的多线程同时执行的本质是CPU在多个任务直接进行快速的切换，由于CPU调度线程的时间足够快，就造成了多线程的“同时”执行的效果。其中切换的时间间隔就是时间片, 就是时分复用).

线程状态

iShot2022-02-17 11.56.47.png

• 新建：主要是实例化线程对象
• 就绪：线程对象调用start方法，将线程对象加入可调度线程池，等待CPU的调用，即调用start方法，并不会立即执行，进入就绪状态，需要等待一段时间，经CPU时间片调度后再执行，也就是从就绪状态进入运行状态。
• 运行：就是线程执行，处于运行中的线程拥有一段可以执行的时间(时间片)。
• 阻塞：当满足某个预定条件时，可以使用休眠，即sleep，或者同步锁，阻塞线程执行。当进入sleep时，会重新将线程加入就绪中。
• 死亡：分为两种情况，
  1. 正常死亡，即线程执行完毕
     2.非正常死亡，即当满足某个条件后，在线程内部(或者主线程中)终止执行(调用exit方法等退出)

1. 如果时间片用尽，线程就会进入就绪状态队列
2. 如果时间片没有用尽，且需要开始等待某事件，就会进入阻塞状态队列
3. 等待事件发生后，线程又会重新进入就绪状态队列
4. 每当一个线程离开运行，即执行完毕或者强制退出后，会重新从就绪状态队列中选择一个线程继续执行

GCD

任务

同步执行(sync)

同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
只能在当前线程中执行任务，不具备开启新线程的能力。

异步执行(async)

异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
可以在新的线程中执行任务，具备开启新线程的能力。

队列

串行队列(Serial Dispatch Queue)

每次只有一个任务被执行。让任务一个接着一个地执行。(只开启一个线程，一个任务执行完毕后，再执行下一个任务)

并发队列(Concurrent Dispatch Queue)

以让多个任务并发(同时)执行。(可以开启多个线程，并且同时执行任务)

同步执行 + 并发队列

• 在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。

异步执行 + 并发队列

• 可以开启多个线程，任务交替(同时)执行。

同步执行 + 串行队列

• 不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。

异步执行 + 串行队列

• 会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务(所以只开启了一个线程)

同步执行 + 主队列

在主线程中

• 互相等待卡住不可行

在其他线程

• 不会开启新线程，执行完一个任务，再执行下一个任务

异步执行 + 主队列

• 只在主线程中执行任务，执行完一个任务，再执行下一个任务。

锁

互斥锁

是一种用于多线程编程中，防止两条线程同时对同一公共资源(比如全局变量)进行读写的机制。该目的通过将代码切片成一个一个的临界区而达成

• NSLock

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

• pthread_mutex

pthread_mutex_t pattr; 
pthread_mutex_init(&_lock, NULL);
pthread_mutex_lock(&_lock); 
xxx
pthread_mutex_unlock(&_lock);

• @synchronized

@synchronized(self) {
  xxx
}

自旋锁

是用于多线程同步的一种锁，线程反复检查锁变量是否可用。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。 自旋锁避免了进程上下文的调度开销，因此对于线程只会阻塞很短时间的场合是有效的。但是会有优先级反转的问题(如果一个低优先级的线程获得锁并访问共享资源，这时一个高优先级的线程也尝试获得这个锁，它会处于 spin lock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺 CPU 时间，从而导致任务迟迟完不成、无法释放 lock。)

• OSSpinLock

OSSpinLock lock = OS_SPINLOCK_INIT;
OSSpinLockLock(&lock);
xxx
OSSpinLockUnlock(&lock);

读写锁

读写锁与互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么是不加锁状态，而且一次只有一个线程对其加锁。读写锁可以有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可用同时占有读模式的读写锁;

int pthread_rwlock_rdlock(pthread_rwlock_t *rwptr); //获取一个读出锁
int pthread_rwlock_wrlock(pthread_rwlock_t *rwptr); //获取一个写入锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwptr); //释放一个写入锁或者读出锁

递归锁

递归锁有一个特点，就是同一个线程可以加锁N次而不会引发死锁

• NSRecursiveLock

NSRecursiveLock *lock = [NSRecursiveLock new];
[_lock lock];
xxx
[_lock unlock]

• pthread_mutex(recursive)

pthread_mutex_t lock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
pthread_mutex_lock(&lock);
xxx
pthread_mutex_unlock(&lock);

信号量

是一种更高级的同步机制，互斥锁可以说是semaphore在仅取值0/1时的特例。信号量可以有更多的取值空间，用来实现更加复杂的同步，而不单单是线程间互斥。

dispatch_semaphore_create(long value); // 创建信号量
dispatch_semaphore_signal(dispatch_semaphore_t deem); // 发送信号量
dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); // 等待信号量

条件锁

就是条件变量，当进程的某些资源要求不满足时就进入休眠，也就是锁住了。当资源被分配到了，条件锁打开，进程继续运行。

• NSCondition

// - 遵循NSLocking协议，使用的时候同样是lock,unlock加解锁，wait是傻等，waitUntilDate:方法是等一会，都会阻塞掉线程，signal是唤起一个在等待的线程，broadcast是广播全部唤起。
NSCondition *lock = [[NSCondition alloc] init];
//Son 线程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    while (No Money) {
        [lock wait];
    }
    NSLog(@"The money has been used up.");
    [lock unlock];
});
    
 //Father线程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    NSLog(@"Work hard to make money.");
    [lock signal];
    [lock unlock];
 });