pthread 互斥量

参考文献：

• [1] https://computing.llnl.gov/tutorials/pthreads/

温故知新

在 OS 中，每个进程都独立地拥有：

• Process ID, process group ID, user ID, and group ID
• Environment
• Working directory
• Program instructions
• Registers
• Stack
• Heap
• File descriptors
• Signal actions
• Shared libraries
• Inter-process communication tools (such as message queues, pipes, semaphores, or shared memory).

因此，使用 fork 开启一个新的进程，需要拷贝很多数据，开销较大。

与进程不同，线程需要只需要独立拥有：

• Stack pointer
• Registers
• Scheduling properties (such as policy or priority)
• Set of pending and blocked signals
• Thread specific data

需要特别注意的是，文件描述符和堆空间是进程独有的，因此该进程下面的所有线程都共用该进程的堆与文件描述符。

例如下面的代码：

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
void *worker1(void *arg)
{
    char *p = malloc(25);
    memcpy(p, "heap data from worker1", 23);
    return p;
};
void *worker2(void *arg)
{
    pthread_t tid1 = *(pthread_t *)arg;
    char *ptr = NULL;
    pthread_join(tid1, (void **)&ptr);
    printf("In worker2: ");
    if (ptr) puts(ptr);
    return NULL;
}
int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, worker1, NULL);
    pthread_create(&tid2, NULL, worker2, &tid1);
    pthread_join(tid2, NULL);
}

线程同步

在描述这个概念之前，先看一段代码：

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
const int N = 1e4;
int value = 0;
void *worker1(void *arg)
{
    int i = 1;
    for (; i <= N / 2; i++) value = value + i;
    return NULL;
};
void *worker2(void *arg)
{
    int i = N / 2 + 1;
    for (; i <= N; i++) value = value + i;
    return NULL;
}
int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, worker1, NULL);
    pthread_create(&tid2, NULL, worker2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("%d\n", value);
    printf("SUM(1, %d) should be %d .\n", N, N * (N + 1) / 2);
}

显然，我们想通过 2 个线程实现 SUM(1, N) 这个功能，但是编译多次你会发现，value 的值并不准确，有时候能输出正确答案 500500，有时候却不能。

这是因为 work1 和 work2 是并发执行的，假设一开始，2 个线程同时计算 value + i，work1 和 work2 分别得到 1 和 5001，但是写入 value 变量是有先后顺序的。假设 work1 先写入，work2 后写入，那么对于这 2 次累加，value 的最终结果是 5001 ，而不是 5002 。

从这个例子可以看出，线程与进程类似，同样需要同步 (Synchronization) ，对于临界资源，每次只允许一个线程访问。

互斥量 mutex

互斥量，也叫互斥锁。mutex, 即 Mutual exclusion , 意为相互排斥，主要用于实现线程同步中的写保护操作。

pthread_mutex_init

初始化一个互斥量 pthread_mutex_t mutex .

函数原型：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

参数：

• mutex 是即将要被初始化的互斥量
• attr 是互斥量的属性，与 pthread_attr_t 类似

与之类似的，还有 pthread_mutex_destroy 函数。

使用方法：

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
pthread_mutex_destroy(&mutex);

pthread_mutex_lock

阻塞调用。如果这个互斥锁此时正在被其它线程占用， 那么 pthread_mutex_lock() 调用会进入到这个互斥锁量的等待队列中，并会进入阻塞状态， 直到拿到该锁之后才会返回。

函数原型如下：

int pthread_mutex_lock(pthread_mutex_t *mutex);

pthread_mutex_trylock

非阻塞调用。当请求的锁正在被占用的时候， 不会进入阻塞状态，而是立刻返回，并返回一个错误代码 EBUSY，意思是说， 有其它线程正在使用这个锁。

直白点的说法，请求资源，能拿到就拿，拿不到我就继续往下执行。

函数原型：

int pthread_mutex_trylock(pthread_mutex_t *mutex);

pthread_mutex_unlock

释放互斥锁。

函数原型如下：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

对于这些 API，如果成功，那么返回 0，否则返回错误码 errno ，可以通过下列宏定义打印错误信息：

#define handler_error_en(en, msg) \
    do                            \
    {                             \
        errno = en;               \
        perror(msg);              \
        exit(EXIT_FAILURE);       \
    } while (0)

例子：同步累加

对于「线程同步」一节给出的例子，使用互斥量实现同步操作，使得程序能够正确完成累加操作。

#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
const int N = 1e4;
int value = 0;
pthread_mutex_t mutex;
void *worker1(void *arg)
{
    int i = 1;
    int sum = 0;
    for (; i <= N / 2; i++) sum += i;
    // 这样保证 value 仅能由一个线程访问
    pthread_mutex_lock(&mutex);
    value += sum;
    pthread_mutex_unlock(&mutex);
    return NULL;
};
void *worker2(void *arg)
{
    int i = N / 2 + 1;
    int sum = 0;
    for (; i <= N; i++) sum += i;
    pthread_mutex_lock(&mutex);
    value += sum;
    pthread_mutex_unlock(&mutex);
    return NULL;
}
int main()
{
    pthread_t tid1, tid2;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&tid1, NULL, worker1, NULL);
    pthread_create(&tid2, NULL, worker2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("%d\n", value);
    printf("SUM(1, %d) should be %d .\n", N, N * (N + 1) / 2);
    pthread_mutex_destroy(&mutex);
}