Linux 线程互斥

#include <iostream>
#include <pthread.h>
#include <string>
#include <vector>
#include <unistd.h>
using namespace std;
struct customer
{pthread_t tid;string name;
};
int g_tickets = 1000;
void* GetTicket(void* args)
{customer* c = (customer*)args;while(true){if(g_tickets > 0){usleep(1000);cout << c->name << " is getting a ticket " << g_tickets << endl;g_tickets--;}elsebreak;}return nullptr;
}int main()
{vector<customer> custs(5);for(int i = 0; i < 5; i++){custs[i].name= "customer-" + to_string(i + 1);pthread_create(&custs[i].tid, nullptr, GetTicket, &custs[i]);}for(int i = 0; i < 5; i++){pthread_join(custs[i].tid, nullptr);}return 0;
}

if(g_tickets > 0)
{usleep(1000);cout << c->name << " is getting a ticket " << g_tickets << endl;g_tickets--;
}

MOV  eax, [0x1000]  ; 读取 g_ticket 的值
DEC  eax            ; 减 1
MOV  [0x1000], eax  ; 将值写回 g_ticket

要解决以上问题，需要做到三点：

初始化互斥量有两种方法：

方法 1 ，静态分配 :

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

我们创建了一个名为 mutex的变量，类型是  pthread_mutex_t ，全局的互斥锁用宏PTHREAD_MUTEX_INITIALIZER 进行初始化， 并且使用 PTHREAD_ MUTEX_ INITIALIZER 初始化的互斥量不需要销毁。

方法 2 ，动态分配 :

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

参数：

mutex：指向互斥量变量的指针，该变量将被初始化。

attr：指向互斥量属性的指针，如果为 NULL，则使用默认属性。

返回值：如果函数成功，返回 0；如果失败，返回相应的错误码。

方法3，C++STL:

在C++标准模板库(STL)中，可以使用std::mutex作为互斥量：

#include <mutex>int main() {std::mutex my_mutex;// 使用互斥量...// 不需要显式销毁，因为它是对象，在其作用域结束时会自动析构return 0;
}

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

• mutex: 这是指向已经初始化过的互斥量的指针。

返回值：如果函数成功，则返回 0；若发生错误，则返回相应的错误码。

销毁互斥量需要注意：

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);

• pthread_mutex_lock：用于申请锁，如果申请失败，就阻塞等待，直到申请到锁；如果申请成功，就执行临界区代码。
• pthread_mutex_trylock：用于非阻塞等待申请锁，如果申请失败，立即返回错误码EBUSY，表示互斥量当前不可用；如果申请成功，就执行临界区代码。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

pthread_mutex_unlock：释放（解锁）互斥量mutex，使其他线程可以获取该互斥量，调用这个函数的线程应该是当前持有互斥量的线程。

接下来我们修改一下抢票系统的代码，给它加锁，保证抢票g_ticket--的原子性：

int g_tickets = 1000;
//定义一个全局变量的锁，保证所有线程都用同一个锁
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
void *GetTicket(void *args)
{customer *c = (customer *)args;while (true){pthread_mutex_lock(&g_mutex); //加锁if (g_tickets > 0){usleep(1000);cout << c->name << " is getting a ticket " << g_tickets << endl;g_tickets--;pthread_mutex_unlock(&g_mutex); //解锁}else{pthread_mutex_unlock(&g_mutex); //解锁break;}}return nullptr;
}

当第一个线程被调度进行抢票，先申请锁g_mutex，然后再去if中访问g_ticket。假如在访问临界资源的过程中，CPU调度了第二个线程，第二个线程也想访问g_ticket，于是也申请锁g_mutex，但是由于锁已经被第一个线程申请走了，此时第二个线程pthread_mutex_lock就会失败，然后阻塞等待。等到第一个线程再次被调度，访问完临界区后，对g_mutex解锁，此时锁又可以被申请了。于是线程二申请到锁，再去访问g_ticket。加锁可以保证任何时候都只有一个线程访问临界区,这就保证了临界区的原子性，从而维护线程的安全！

3. 互斥量的实现原理

互斥量的汇编伪代码如下：

加锁lock：

moveb $0, %al
xchgb %al, mutex
if (al寄存器的内容 > 0){return 0;
}else挂起等待;
goto lock

假设有这样的情形，有两个线程thread-1和thread-2，它们共用内存中的锁mutex。在CPU中有一个寄存器%al，用于存储锁的值。

假设thread-1进行调度执行pthread_mutex_lock：

首先执行指令moveb $0, %al，把寄存器%al内部的值变成0：

随后执行xchgb %al, mutex，让内存中的mutex与寄存器%al的值进行交换：

此时寄存器%al的值变成1，mutex的值变成0。随后执行：

if (al寄存器的内容 > 0){return 0;
}else挂起等待;

判断当前%al内部的值是否大于0，如果大于0那么说明争夺到了锁，此时函数pthread_mutex_lock返回0，表示加锁成功，否则执行else进行挂起等待。

现在假设thread-1执行到第一条汇编语句后，%al的值还是0，但是CPU切换去调度thread-2了：

现在thread-1保存自己的硬件上下文，包括%al = 0在内，随后therad-2进入：

现在thread-2执行了两行汇编语句，成功把内存中的mutex与自己的%al交换，申请到了锁，此时thread-1再次调度，thread-2拷贝走自己的硬件上下文：

恢复硬件上下文后，thread-1的%al等于0，执行第二条语句后，%al和mutex依然是0，这表明锁已经别的线程拿走了，此时在执行if内部的内容，thread-1挂起等待。

其实锁的本质，就是保证mutex变量中以及所有访问锁的线程的%al寄存器中，只会有一个非零值。只有拿到非零值的线程才有资格去访问临界资源。其它线程如果要再次申请锁，由于自己的%al和mutex都是0，就算交换后还是0，也申请不到锁。并不是谁先调用ptherad_mutex_lock，谁就先抢到锁，而是谁先执行该函数内部的xchgb %al, mutex语句，把非零值放到自己的%al中，谁才抢到锁。

再简单看看解锁unlock：

moveb $1, mutex
唤醒等待mutex的线程;
return 0;

moveb $1, mutex就是把%al中的1还给mutex，然后唤醒所有等待该锁的线程，让它们再次争夺这把锁。最后return 0，也就是pthread_mutex_unlock函数返回0。