Linux互斥锁的使用

目录

1. 互斥锁原理

2. 互斥锁相关函数

3. 互斥锁使用过程

4. 互斥锁使用示例

5. 死锁

---

1. 互斥锁原理

如上图所示：如果多个线程要访问一段共享资源的内存区域时，其中一个线程（如图中线程1）首先读取共享区域时，会在共享区域外设置一把互斥锁，其它线程阻塞在互斥锁处，线程1结束共享资源的访问后，会解锁该内存区域，此时其它的线程才可以继续访问共享资源的内存区域。本来多线程访问数据时是并行访问内存区域的，加上互斥锁后变为串行处理。

多线程编程是建议使用互斥锁，这样可以对公共区域的数据进行保护。互斥锁的缺点就是串行，数据访问的效率会有一定的降低。

2. 互斥锁相关函数

1.创建互斥锁函数
pthread_mutex_t mutex;

2.初始化互斥锁函数：
int pthread_mutex_init(pthread_mutex_t *restrict mutex, 
                       const pthread_mutexattr_t *restrict attr
                        ); 
    参数1：传出参数，调用是创建的互斥锁变量。
    参数2：传入参数，互斥锁属性，一般为NULL表示为默认属性
    这里的restrict关键字，表示指针指向的内容只能通过这个指针进行修改
    restrict关键字作用可以理解为：
	    用来限定指针变量。被该关键字限定的指针变量所指向的内存操作，必须由本指针完成。
    
    初始化可以使用静态初始化和动态初始化，示例：
    pthread_mutex_t mutex;
		1. pthread_mutex_init(&mutex, NULL);   			动态初始化。
		2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;	静态初始化。

3.加锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
     参数：mutex
     没有上锁，当前线程会将这把锁上锁
     已经上锁，当前线程会阻塞在此
              锁被打开之后，线程会解除阻塞

4.尝试加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);
      参数：mutex
      没有上锁：同上
      已经上锁，不阻塞返回

5.解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);

6.销毁一个互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

3. 互斥锁使用过程

（1）创建互斥锁：pthread_mutex_t mutex;

（2）初始化互斥锁： pthread_mutex_init(&mutex, NULL);

（3）找到线程共同操作的共享资源

           加锁：prhread_mutex_lock(&mutex);     //如果共享区域已经上锁，会阻塞线程

                      pthread_mutex_trylock(&mutex);   //如果共享区域已经上锁，直接返回，不会阻塞。

（4）访问内存区域

（5）解锁：pthread_mutex_unlock(&mutex);

（6）销毁：pthread_mutex_destory(&mutex);

 使用注意：

尽量保证锁的粒度，越小越好，一般访问共享数据前加锁，访问结束立即解锁。

        互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功。）

        加锁： --操作， 阻塞线程。

        解锁： ++操作， 唤醒阻塞在锁上的线程。

        try锁：尝试加锁，成功--。失败，返回。同时设置错误号 EBUSY

4. 互斥锁使用示例

pthread_mutex.c：主线程建立两个子线程对全局变量进行++操作。

#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 10000
// 全局变量
int number;
//创建一把互斥锁
pthread_mutex_t mutex;


// 线程A处理函数
void* funcA_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        //访问全局变量之前加锁
        //如果mutex被锁上了，代码阻塞在当前位置
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread A, id = %lu, number = %d\n", pthread_self(), number);
        //解锁
        pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}
// 线程B处理函数 
void* funcB_num(void* arg)
{
    for(int i=0; i<MAX; ++i)
    {
        pthread_mutex_lock(&mutex);
        int cur = number;
        cur++;
        number = cur;
        printf("Thread B, id = %lu, number = %d\n", pthread_self(), number);
                pthread_mutex_unlock(&mutex);
        usleep(10);
    }
 
    return NULL;
}

/*主函数创建两个线程，分别操作共享区域内存：全局变量number*/
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;
}

运行结果：AB两个线程逐个访问共享内存区域。

5. 死锁

程序运行是要避免死锁的情况。通常出现死锁的情况有两种：
       1.  对一个锁反复lock：对一个地方使用了两次锁，没有及时解锁

2. 两个线程，各自持有一把锁，请求另一把锁，如下图所示:A，B两个线程访问AB两个共享数据区域时。

解决方法：

        1. 让线程按照一定的顺序去访问共享资源

        2. 在访问的其他锁的时候，需要先将字节的锁解开

        3.trylock方式定义锁