iOS - 了解一点pthread的使用
pthread
POSIX Threads, usually referred to as pthreads, is an execution model that exists independently from a language, as well as a parallel execution model. It allows a program to control multiple different flows of work that overlap in time. Each flow of work is referred to as a thread, and creation and control over these flows is achieved by making calls to the POSIX Threads API.
POSIX（可移植操作系统接口）线程，即pthreads，是一种不依赖于语言的执行模型，也称作并行（Parallel）执行模型。其允许一个程序控制多个时间重叠的不同工作流。每个工作流即为一个线程，通过调用 POSIX 线程 API 创建并控制这些流。
pthread全称POSIX thread，是一套跨平台的多线程API，各个平台对其都有实现。pthread是一套非常强大的多线程锁，可以创建互斥锁（普通锁）、递归锁、信号量、条件锁、读写锁、once锁等，基本上所有涉及的锁，都可以使用pthread来实现。
创建线程
int pthread_create(pthread_t _Nullable * _Nonnull __restrict,
const pthread_attr_t * _Nullable __restrict,
void * _Nullable (* _Nonnull)(void * _Nullable),
void * _Nullable __restrict);
_Nullable 和 _Nonnull 是 Obj-C 桥接 Swift可选（Optional）类型的标志；__restrict 是 C99 标准引入的关键字，类似于restrict，可以用在指针声明处，用于告诉编译器只有该指针本身才能修改指向的内容，便于编译器优化。
去掉这些不影响函数本身的标志，补全参数名，即
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine) (void *),
void *arg);
函数的四个参数
其中第一个参数是 pthread_t *thread。关于该参数实际意义，一种指整型（Integer）四字节的线程 ID，另一种指包含值和其他的抽象结构体，这种抽象有助于在一个进程（Process）中实现扩展到数千个线程，后者也可以称为 pthread的句柄（Handle）。
在 Obj-C 中，pthread_t 属于后者，其本质是 _opaque_pthread_t，一个不透明类型（Opaque Type）的结构体，即一种外界只需要知道其存在，而无需关心内部实现细节的数据类型。在函数中，该参数是作为指针传入的，总之我们可以简单将这个参数理解为线程的引用即可，通过它能找到线程的 ID 或者其他信息。
typedef __darwin_pthread_t pthread_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
struct _opaque_pthread_t {
long __sig;
struct __darwin_pthread_handler_rec *__cleanup_stack;
char __opaque[__PTHREAD_SIZE__];
};
第二个参数是 const pthread_attr_t *attr。pthread_attr_t 本质也是一个不透明类型的结构体。可以使用 int pthread_attr_init(pthread_attr_t *); 初始化该结构体。该参数为 NULL 时将使用默认属性来创建线程。
typedef __darwin_pthread_attr_t pthread_attr_t;
typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
struct _opaque_pthread_attr_t {
long __sig;
char __opaque[__PTHREAD_ATTR_SIZE__];
};
最后两个参数是 void *(*start_routine) (void *), void *arg。start_routine() 是新线程运行时所执行的函数，arg 是传入 start_routine() 的参数。当 start_routine() 执行终止或者线程被明确杀死，线程也将会终止。
返回值是int 类型，当返回0时，创建成功，否则将返回错误码。
简单使用
#import "pthread.h"
void * runForPthreadCreate(void * arg) {
// 打印参数 & 当前线程 __opaque 属性的地址
printf("%s (%p) is running.\n", arg, &pthread_self()->__opaque);
exit(2);
}
- (void)pthreadCreate {
// 声明 thread_1 & thread_2
pthread_t thread_1, thread_2;
// 创建 thread_1
int result_1 = pthread_create(&thread_1, NULL, runForPthreadCreate, "thread_1");
// 打印 thread_1 创建函数返回值 & __opaque 属性的地址
printf("result_1 - %d - %p\n", result_1, &thread_1->__opaque);
// 检查线程是否创建成功
if (result_1 != 0) {
perror("pthread_create thread_1 error.");
// 线程创建失败退出码为 1
exit(1);
}
// 创建 thread_2
int result_2 = pthread_create(&thread_2, NULL, runForPthreadCreate, "thread_2");
// 打印 thread_2 创建函数返回值 & __opaque 属性的地址
printf("result_2 - %d - %p\n", result_2, &thread_2->__opaque);
if (result_2 != 0) {
perror("pthread_create thread_2 error.");
// 线程创建失败退出码为 1
exit(1);
}
// sleep(1);
// 主线程退出码为 3
exit(3);
}
- 互斥锁（pthread_mutex）
pthread_mutex表示互斥锁。互斥锁的实现原理与信号量非常相似，不是使用忙等，而是阻塞线程并睡眠，需要进行上下文切换。pthread_mutex 是 C 语言下多线程加互斥锁的方式
typedef __darwin_pthread_mutex_t pthread_mutex_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
struct _opaque_pthread_mutex_t {
long __sig;
char __opaque[__PTHREAD_MUTEX_SIZE__];
};
常用函数
// 初始化锁变量mutex。attr为锁属性，NULL值为默认属性。
int pthread_mutex_init(pthread_mutex_t * __restrict,
const pthread_mutexattr_t * __restrict);
// 加锁
int pthread_mutex_lock(pthread_mutex_t *);
// 加锁，但是与2不一样的是当锁已经在使用的时候，返回为EBUSY，而不是挂起等待。
int pthread_mutex_trylock(pthread_mutex_t *);
// 解锁
int pthread_mutex_unlock(pthread_mutex_t *);
// 使用完后释放
pthread_mutex_destroy(pthread_mutex_t* *mutex);
简单使用
#import <pthread.h>
static pthread_mutex_t theLock;
-(void)pthread {
pthread_mutex_init(&theLock, NULL);
pthread_t thread1;
pthread_create(&thread1, NULL, threadMethod1, NULL);
pthread_t thread2;
pthread_create(&thread2, NULL, threadMethod2, NULL);
}
void *threadMethod1() {
pthread_mutex_lock(&theLock);
printf("线程1\n");
sleep(2);
pthread_mutex_unlock(&theLock);
printf("线程1解锁成功\n");
return 0;
}
void *threadMethod2() {
sleep(1);
pthread_mutex_lock(&theLock);
printf("线程2\n");
pthread_mutex_unlock(&theLock);
return 0;
}
运行输出
线程1
线程1解锁成功
线程2
一般情况下，一个线程只能申请一次锁，也只能在获得锁的情况下才能释放锁，多次申请锁或释放未获得的锁都会导致崩溃。假设在已经获得锁的情况下再次申请锁，线程会因为等待锁的释放而进入睡眠状态，因此就不可能再释放锁，从而导致死锁。
然而这种情况经常会发生，比如某个函数申请了锁，在临界区内又递归调用了自己。辛运的是 pthread_mutex 支持递归锁，也就是允许一个线程递归的申请锁，只要把 attr 的类型改成 PTHREAD_MUTEX_RECURSIVE 即可。
- 递归锁（pthread_mutexattr_t）
Mutex可以分为递归锁(recursive mutex)和非递归锁(non-recursive mutex)。可递归锁也可称为可重入锁(reentrant mutex)，非递归锁又叫不可重入锁(non-reentrant mutex)。
二者唯一的区别是，同一个线程可以多次获取同一个递归锁，不会产生死锁。而如果一个线程多次获取同一个非递归锁，则会产生死锁。
typedef __darwin_pthread_mutexattr_t pthread_mutexattr_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
struct _opaque_pthread_mutexattr_t {
long __sig;
char __opaque[__PTHREAD_MUTEXATTR_SIZE__];
};
递归锁的创建方法跟普通锁是同一个方法，不过需要传递一个attr参数.
锁的类型
/*
* Mutex type attributes
*/
#define PTHREAD_MUTEX_NORMAL 0
#define PTHREAD_MUTEX_ERRORCHECK 1
#define PTHREAD_MUTEX_RECURSIVE 2
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
1、PTHREAD_MUTEX_NORMAL
缺省类型，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后先进先出原则获得锁。
2、PTHREAD_MUTEX_ERRORCHECK
检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与普通锁类型动作相同。这样就保证当不允许多次加锁时不会出现嵌套情况下的死锁。
3、PTHREAD_MUTEX_RECURSIVE
递归锁，允许同一个线程对同一个锁成功获得多次，并通过多次 unlock 解锁。
4、PTHREAD_MUTEX_DEFAULT
互斥锁，动作最简单的锁类型，仅等待解锁后重新竞争，没有等待队列。
简单使用
-(void)pthread_mutexattr {
__block pthread_mutex_t theLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); // 设置为递归锁
pthread_mutex_init(&theLock, &attr); // 创建锁
pthread_mutexattr_destroy(&attr);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveMethod)(int);
RecursiveMethod = ^(int value) {
pthread_mutex_lock(&theLock);
if (value > 0) {
NSLog(@"value = %d", value);
sleep(1);
RecursiveMethod(value - 1);
}
pthread_mutex_unlock(&theLock);
};
RecursiveMethod(5);
});
}
运行输出
value = 5
value = 4
value = 3
value = 2
value = 1
这是pthread_mutex为了防止在递归的情况下出现死锁而出现的递归锁。作用和NSRecursiveLock递归锁类似
- 条件锁（pthread_cond_t）
typedef __darwin_pthread_cond_t pthread_cond_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
struct _opaque_pthread_cond_t {
long __sig;
char __opaque[__PTHREAD_COND_SIZE__];
};
常用函数
// 等待条件锁
int pthread_cond_wait(pthread_cond_t * __restrict,
pthread_mutex_t * __restrict);
// 激动一个相同条件的条件锁
int pthread_cond_signal(pthread_cond_t *);
简单使用
- (void)conditionLock {
// 初始化锁变量mutex
__block pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
// 条件锁
__block pthread_cond_t cond;
pthread_cond_init(&cond, NULL);
// 线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 加锁
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
NSLog(@"thread 1");
// 解锁
pthread_mutex_unlock(&mutex);
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
pthread_mutex_lock(&mutex);
NSLog(@"thread 2");
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
});
}
运行结果
thread 2
thread 1
- 读写锁（pthread_rwlock_t）
读写锁是一种特殊的自旋锁，将对资源的访问分为读者和写者，顾名思义，读者对资源只进行读取，而写者对资源只有写访问，相对于自旋锁来说，这中锁能提高并发性。在多核处理器操作系统中，允许多个读者访问同一资源，却只能有一个写者执行写操作，并且读写操作不能同时进行
typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
struct _opaque_pthread_rwlock_t {
long __sig;
char __opaque[__PTHREAD_RWLOCK_SIZE__];
};
常用函数
// 初始化都写锁
int pthread_rwlock_init(pthread_rwlock_t * __restrict,
const pthread_rwlockattr_t * _Nullable __restrict);
// 读操作上锁
int pthread_rwlock_tryrdlock(pthread_rwlock_t *);
// 写操作上锁
int pthread_rwlock_trywrlock(pthread_rwlock_t *);
// 获取写锁
int pthread_rwlock_wrlock(pthread_rwlock_t *);
// 获取读锁
int pthread_rwlock_rdlock(pthread_rwlock_t *);
// 解锁
int pthread_rwlock_unlock(pthread_rwlock_t *);
// 释放锁
int pthread_rwlock_destroy(pthread_rwlock_t * );
简单使用
static pthread_rwlock_t rwlock;
// 读写锁
- (void)rwlock {
pthread_rwlock_init(&rwlock, NULL);
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self readBookWithTag:0];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self readBookWithTag:1];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self writeBook:2];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self readBookWithTag:3];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self writeBook:4];
});
}
- (void)readBookWithTag:(NSInteger )tag {
pthread_rwlock_rdlock(&rwlock);
NSLog(@"读%tu",tag);
sleep(3);
pthread_rwlock_unlock(&rwlock);
}
- (void)writeBook:(NSInteger)tag {
pthread_rwlock_wrlock(&rwlock);
NSLog(@"写%tu",tag);
sleep(3);
pthread_rwlock_unlock(&rwlock);
}
运行输出
读0
读1
写2
读3
读4
- once锁（pthread_once）
一次性初始化pthread_once
static pthread_once_t once = PTHREAD_ONCE_INIT;
static pthread_mutex_t mutex;
void init() {
pthread_mutex_init(&mutex, NULL);
}
void performWork() {
pthread_once(&once, init); // Correct
pthread_mutex_lock(&mutex);
// ...
pthread_mutex_unlock(&mutex);
}
- pthread（semaphore）
pthread的信号量不同于GCD自带的信号量，如前面所说，pthread是一套跨平台的多线程API，对信号量也提供了相应的使用。其大概原理和使用方法与GCD提供的信号量机制类似，使用起来也比较方便。
信号量机制通过信号量的值控制可用资源的数量。线程访问共享资源前，需要申请获取一个信号量，如果信号量为0，说明当前无可用的资源，线程无法获取信号量，则该线程会等待其他资源释放信号量（信号量加1）。如果信号量不为0，说明当前有可用的资源，此时线程占用一个资源，对应信号量减1。
// 该函数申请一个信号量，当前无可用信号量则等待，有可用信号量时占用一个信号量，对信号量的值减1。
int sem_wait(sem_t *sem);
// 该函数释放一个信号量，信号量的值加1。
int sem_post(sem_t *sem);
简单使用
#import "pthread.h"
#import <sys/semaphore.h>
static sem_t *semaphore;
void *runForSemaphoreDemo1(void * arg) {
// 等待信号
sem_wait(semaphore);
printf("Running - %s.\n", arg);
return 0;
}
void *runForSemaphoreDemo2(void * arg) {
printf("Running - %s.\n", arg);
sleep(1);
// 发送信号
sem_post(semaphore);
return 0;
}
- (void)semaphoreDemo {
// sem_init 初始化匿名信号量在 macOS 中已被废弃
// semaphore = sem_init(&semaphore, 0, 0);
semaphore = sem_open("sem", 0, 0);
pthread_t thread_1, thread_2;
void * result;
if (pthread_create(&thread_1, NULL, runForSemaphoreDemo1, "Thread 1") != 0) {
perror("pthread_create thread_1 error.");
exit(1);
}
if (pthread_create(&thread_2, NULL, runForSemaphoreDemo2, "Thread 2") != 0) {
perror("pthread_create thread_2 error.");
exit(1);
}
// thread_join用来等待一个线程的结束
pthread_join(thread_1, &result);
pthread_join(thread_2, &result);
}
运行输出
Running - Thread 2.
Running - Thread 1.
