多线程(3): 线程同步

1. 互斥锁的加锁和解锁

1.1 加锁解锁说明

在处理线程同步时，第一种方式就是使用互斥锁。互斥锁只能同时被一个线程使用，锁的所有权只能被一个线程拥有。互斥锁是线程同步最常用的一种方式，通过互斥锁可以锁定一个代码块 ，被锁定的这个代码块，所有的线程只能顺序执行 (不能并行处理)，这样多线程访问共享资源数据混乱的问题就可以被解决了，需要付出的代价就是执行效率的降低，因为默认临界区多个线程是可以并行处理的，现在只能串行处理。

在 Linux 中互斥锁的类型为 pthread_mutex_t，创建一个这种类型的变量就得到了一把互斥锁：

pthread_mutex_t  mutex;

在创建的锁对象中保存了当前这把锁的状态信息：锁定还是打开，如果是锁定状态还记录了给这把锁加锁的线程信息（线程 ID）。一个互斥锁变量只能被一个线程锁定，被锁定之后其他线程再对互斥锁变量加锁就会被阻塞，直到这把互斥锁被解锁，被阻塞的线程才能被解除阻塞。一般情况下，每一个共享资源对应一个把互斥锁，锁的个数和线程的个数无关。

Linux 提供的互斥锁操作函数如下，如果函数调用成功会返回 0，调用失败会返回相应的错误号：

// 初始化互斥锁
// restrict: 是一个关键字, 用来修饰指针, 只有这个关键字修饰的指针可以访问指向的内存地址, 其他指针是不行的
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
           const pthread_mutexattr_t *restrict attr);
// 释放互斥锁资源            
int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数:

• mutex: 互斥锁变量的地址
• attr: 互斥锁的属性，一般使用默认属性即可，这个参数指定为 NULL
• restrict: 是一个关键字, 用来修饰指针,只有这个关键字修饰的指针可以访问指向的内存地址, 其他指针是不行的。比如说将 p=mux,虽然将互斥锁变量赋值给了p，但p不能访问该互斥锁指向的内存地址。

// 修改互斥锁的状态, 将其设定为锁定状态, 这个状态被写入到参数 mutex 中
int pthread_mutex_lock(pthread_mutex_t *mutex);

这个函数被调用，首先会判断参数 mutex 互斥锁中的状态是不是锁定状态:

• 没有被锁定，是打开的，这个线程可以加锁成功，这个这个锁中会记录是哪个线程加锁成功了
• 如果被锁定了，其他线程加锁就失败了，这些线程都会阻塞在这把锁上
• 当这把锁被解开之后，这些阻塞在锁上的线程就解除阻塞了，并且这些线程是通过竞争的方式对这把锁加锁，没抢到锁的线程继续阻塞

// 对互斥锁解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

不是所有的线程都可以对互斥锁解锁，哪个线程加的锁，哪个线程才能解锁成功。

互斥锁加锁和解锁操作，需要成对出现。从互斥锁加锁到解锁包括的区域称为临界区，如何确定临界区的范围，首先需要找到共享资源(多线程同时读写的变量)，然后将共享资源上下文中涉及到处理共享资源的代码，作为临界区。 临界区内的代码是串行执行的，虽然牺牲了执行效率，但可以确保访问资源的安全。

// 尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);

• pthread_mutex_trylock和pthread_mutex_lock，都可以对互斥锁加锁，主要区别是：如果互斥锁没有被锁住的情况下，这两种操作都可以对互斥锁加锁，但是如果这把互斥锁已经锁上了，此时线程调用pthread_mutex_lock就堵塞到这把互斥锁了。而线程调用pthread_mutex_trylock，表示尝试给这把互斥锁加锁，如果加锁失败了的话，还可以继续干一会其他事情，然后再重新尝试给互斥锁加锁。总之：pthread_mutex_lock在互斥锁已经加锁的时候，线程会堵塞在那，然后一直死等，等待重新尝试上锁，而pthread_mutex_trylock则会比较灵活，它发现无法加锁，拿不到cpu时间片，就回去干些其他事情，事情干完之后，再回来尝试对互斥锁进行重新解锁。

这些互斥锁的加锁和解锁操作，都有一个参数pthread_mutex_t *mutex, 这个对象时通过mutex进行pthread_mutex_init初始化得到的，因此在做线程同步的时候，一定要先通过pthead_mutex_t创建 一个互斥锁mutex,然后调用pthread_mutex_init对创建的互斥锁进行初始化，并且在做线程锁同步期间，这个锁的资源是不能被释放的。

1.2 互斥锁使用

我们可以将：多线程(2):线程同步中多线程交替数数的例子修改一下，使用互斥锁进行线程同步。两个线程一共操作了同一个全局变量，因此需要添加一互斥锁，来控制这两个线程

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>

#define MAX 100
// 全局变量
int number;

// 创建一把互斥锁
// 全局变量, 多个线程共享
pthread_mutex_t mutex;

// 线程处理函数
void* funcA_num(void* arg)
{
    
    
    for(int i=0; i<MAX; ++i)
    {
    
    
        // 如果线程A加锁成功, 不阻塞
        // 如果B加锁成功, 线程A阻塞
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        usleep(10);
        number = cur;
        pthread_mutex_unlock(&mutex);
        printf("Thread A, id = %lu, number = %d\n", pthread_self(), number);
    }

    return NULL;
}

void* funcB_num(void* arg)
{
    
    
    for(int i=0; i<MAX; ++i)
    {
    
    
        // a加锁成功, b线程访问这把锁的时候是锁定的
        // 线程B先阻塞, a线程解锁之后阻塞解除
        // 线程B加锁成功了
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        pthread_mutex_unlock(&mutex);
        printf("Thread B, id = %lu, number = %d\n", pthread_self(), number);
        usleep(5);
    }

    return NULL;
}

int main(int argc, const char* argv[])
{
    
    
    pthread_t p1, p2;

    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);

    // 创建两个子线程
    pthread_create(&p1, NULL, funcA_num, NULL);
    pthread_create(&p2, NULL, funcB_num, NULL);

    // 阻塞，资源回收
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);

    // 销毁互斥锁
    // 线程销毁之后, 再去释放互斥锁
    pthread_mutex_destroy(&mutex);

    return 0;
}

• 使用互斥锁pthread_mutex_t，需要引入头文件<pthread.h>,为了保证在线程同步期间，互斥锁资源一直存在，因此这里创建了全局变量的互斥锁。

• 在数数的过程中，很明显共享资源/临界资源就是变量number, 在做线程同步的时候，我们需要确定的是我们要找到的临界区范围肯定是越小越好，因为临界区内只允许一个线程同时执行，所以多线程是串行执行的，执行效率比较低，所以我们要缩小代码块的范围。对于funcA_num这个任务函数，可以看到for循环内的代码都很临界资源number有关系,其中printf这句不加也可以。因此在临界区开始位置加锁操作 pthread_mutex_lock(&mutex)，在临界区下面加锁解锁操作pthread_mutex_unlock(&mutex)。
  

• 同理对于funcB_num这个任务函数，它的临界区也是操作共享资源number这部分代码块，其中usleep由于不涉及操作共享资源，因此临界区可以不包括usleep:
  

• 接下来分析下这个多线程的执行过程，funcA_um和funcB_num这两个任务函数分别是由两个线程p1和p2来执行的。假设线程p1先抢到cpu的时间片，然后向下执行，然后执行到pthread_mutex_lock加锁成功，继续向下执行到usleep,usleep使得线程强制放弃了cpu时间片。休眠的过程中，线程p2抢到了cpu时间片, 执行任务函数funcB_num，执行到pthread_mutex_lock(&mutex),但是这个互斥锁mutex已经被线程p1给锁定了，线程p2就被阻塞了，只能在那死等，在阻塞期间它就放弃了cpu资源。线程p1睡醒了之后，又抢到了cpu时间片，继续从原来的位置向下执行，执行完成之后，通过pthread_mutex_unlock(&mutex)把互斥锁mutex解锁，解锁后线程p2就被解除堵塞了，解除堵塞后，线程p2马上就抢到了cpu时间片，然后通过pthread_mutex_lock(&mutex)把锁重新锁上。然后执行funcB_num中数数的代码，在数数期间,线程p1可能又抢到时间片，但它不能执行funcA_um中数数的代码，因为锁已经让线程p2锁上了，线程p1只能堵塞在这把互斥锁上。

• 从前面的分析可以知道，线程p1和线程p2在访问共享资源number时是线性执行（顺序或串行），而不是并行执行。既然是顺序执行，就不存在同时访问共享资源的情况，那么数据就不会发生错落了。

另外互斥锁mutex变量需要在线程调用前进行初始化，不然的话会导致线程在使用互斥锁出现问题。

// 初始化互斥锁
pthread_mutex_init(&mutex, NULL);

• 当线程做完同步，并且线程资源已经被回收了，此时互斥锁就没有存在的意义了，就需要将互斥锁的资源释放掉。

   // 销毁互斥锁
    // 线程销毁之后, 再去释放互斥锁
    pthread_mutex_destroy(&mutex);

• 最后执行编译，两个线程同时数数，每个线程各数50次，可以正常数到100，从打印的结果可以看出，两个线程并不是交替执行，同一个线程可能连续数3次，可能间隔一段时间才数数，这是因为线程抢到cpu资源是随机的。

2 死锁

当多个线程访问共享资源，需要加锁，如果锁使用不当，就会造成死锁这种现象。如果线程死锁造成的后果是：所有的线程都被阻塞，并且线程的阻塞是无法解开的（因为可以解锁的线程也被阻塞了）。

造成死锁的场景有如下几种：

• 加锁之后忘记解锁

// 场景1
void func()
{
    
    
    for(int i=0; i<6; ++i)
    {
    
    
        // 当前线程A加锁成功, 当前循环完毕没有解锁, 在下一轮循环的时候自己被阻塞了
        // 其余的线程也被阻塞
    	pthread_mutex_lock(&mutex);
    	....
    	.....
        // 忘记解锁
    }
}

// 场景2
void func()
{
    
    
    for(int i=0; i<6; ++i)
    {
    
    
        // 当前线程A加锁成功
        // 其余的线程被阻塞
    	pthread_mutex_lock(&mutex);
    	....
    	.....
        if(xxx)
        {
    
    
            // 函数退出, 没有解锁（解锁函数无法被执行了）
            return ;
        }
        
        pthread_mutex_unlock(&mutex);
    }
}

场景2： 粗看pthread_mutex_lock(&mutex)和 pthread_mutex_unlock(&mutex)成对出现，在临界区开始加锁，在临界区结束解锁。但注意其中存在一个if条件，如果条件为真的话，直接就return了，此时就不会执行 pthread_mutex_unlock(&mutex)操作，就会出现死锁，其他线程都会堵塞在这把锁上。

• 重复加锁，造成死锁

void func()
{
    
    
    for(int i=0; i<6; ++i)
    {
    
    
        // 当前线程A加锁成功
        // 其余的线程阻塞
    	pthread_mutex_lock(&mutex);
        // 锁被锁住了, A线程阻塞
        pthread_mutex_lock(&mutex);
    	....
    	.....
        pthread_mutex_unlock(&mutex);
    }
}

// 隐藏的比较深的情况
void funcA()
{
    
    
    for(int i=0; i<6; ++i)
    {
    
    
        // 当前线程A加锁成功
        // 其余的线程阻塞
    	pthread_mutex_lock(&mutex);
    	....
    	.....
        pthread_mutex_unlock(&mutex);
    }
}

void funcB()
{
    
    
    for(int i=0; i<6; ++i)
    {
    
    
        // 当前线程A加锁成功
        // 其余的线程阻塞
    	pthread_mutex_lock(&mutex);
        funcA();		// 重复加锁
    	....
    	.....
        pthread_mutex_unlock(&mutex);
    }
}

这种死锁比较直观：在func() for循环内部，通过一个线程调用了pthread_mutex_lock, 把互斥锁锁上了，接着继续调用pthread_mutex_lock又锁了一遍，这个时候运行到第二个pthread_mutex_lock个lock时线程就堵塞了，因此这个锁已经锁上了（不能重复连续上锁），这种情况比较少见。

第二种情况比较隐藏，经常会出现。这里写了两个函数，funcA()和funcB(), 在funcA()中写了一个for循环，在临界区开始的时候通过pthread_mutex_lock加锁，在临界区结束的时候通过pthread_mutex_unlock解锁，没有任何问题。接着存在一个funcB()函数， 在临界区的上面进行加锁操作，在临界区下面进行解锁操作。但是在临界区中调用了另外一个函数funcA(), 此时就存在问题了，因为在funcB中加锁了，紧接着，在funcA内部也对同一把锁也进行了加锁操作，连续2次加锁，此时存在重复上锁,两次加锁操作中间没有解锁操作。导致应用程序死锁。

• 在程序中有多个共享资源，因此有很多把锁，随意加锁，导致相互被阻塞

场景描述:
  1. 有两个共享资源:X, Y，X对应锁A, Y对应锁B
     - 线程A访问资源X, 加锁A
     - 线程B访问资源Y, 加锁B
  2. 线程A要访问资源Y, 线程B要访问资源X，因为资源X和Y已经被对应的锁锁住了，因此这个两个线程被阻塞
     - 线程A被锁B阻塞了, 无法打开A锁
     - 线程B被锁A阻塞了, 无法打开B锁

在使用多线程编程的时候，如何避免死锁呢？

• 避免多次锁定，多检查

• 对共享资源访问完毕之后，一定要解锁，或者在加锁的使用 trylock

• 如果程序中有多把锁，可以控制对锁的访问顺序 (顺序访问共享资源，但在有些情况下是做不到的)，另外也可以在对其他互斥锁做加锁操作之前，先释放当前线程拥有的互斥锁。

• 项目程序中可以引入一些专门用于死锁检测的模块