linux系统编程---线程互斥锁相关API的使用---学习和记录（三）

本文链接：https://blog.youkuaiyun.com/weixin_74133504/article/details/128804043

互斥锁的作用：在编程中，对象互斥锁用来保证共享数据操作的完整性。每个对象都对应于一个可称为"互斥锁" 的标记，这个标记用来保证在某个时刻，只能有一个线程访问该对象。

互斥锁是使用加锁的方法来控制对共享资源的访问。互斥锁有两种状态：上锁( lock )和解锁( unlock )。

互斥锁的使用方式：在访问共享资源临界区域前，对互斥锁进行加锁；
在访问完成后，对互斥锁进行解锁和释放；
对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到这个线程对互斥锁进行解锁后；
默认情况下，Linux 不允许在同一线程中递归加锁，否则在第二次加锁操作时线程可能出现死锁现象。

互斥锁包含创建、销毁、加锁、解锁等4种操作

互斥锁的创建和销毁的函数原型：

有两种方法创建互斥锁， 静态方式 和 动态方式 。

先说结果：
动态初始化在堆中创建，不用了需要删除以释放内存；
静态初始化在静态存储区，初始化之后直接用就可以，不用了也不需要删除。

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
//创建
int pthread_mutex_destroy(pthread_mutex_t *mutex);
//销毁
// 若成功返回0，否则返回错误编号

mutex:在全局变量中声明一个pthread_mutex_t mutex attr:要用默认的属性初始化互斥量，只需把attr设置为NULL

互斥锁的加锁和解锁函数原型：

int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_trylock(pthread_mutex_t *mutex);//非阻塞加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
// 返回：若成功返回0，否则返回错误编号

函数例子：程序运行结果是，线程1先运行累计到data=5时，退出线程1，开始分别运行线程2和main函数里面的打印的东西；

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
int p_data = 0;
pthread_mutex_t mutex; //定义线程互斥锁
void *func1(void *arg) 
{
    //sleep(1); 这里是为了让其他线程竞争,如果有此条的话，最先运行的有可能不是线程一
    pthread_mutex_lock(&mutex);  //对线程一加锁
    while(1){
        printf("t1 p_data : %d\n",p_data++);
        if(p_data == 5){        //等于5的话就退出
        	pthread_mutex_unlock(&mutex);  //对线程一解锁
            printf("t1 quit=========================\n");
            pthread_exit(NULL);  //退出线程一
            //exit(0);           //如果用exit退出的话，整个进程都会退出
        }
    }
}
void *func2(void *arg)
{
    while(1){
        printf("t2 param is %d\n",*((int *)arg));
        pthread_mutex_lock(&mutex); //对线程二加锁
        p_data++;                   //值加1
        pthread_mutex_unlock(&mutex); //对线程二解锁
        sleep(1);                    //这里延时1s是为了让线程一来竞争，如果最先运行的不是线程一，
        							//则让线程一运行，为了让线程一运行，让线程一退出
    }
}
int main()
{
     int ret;
     int param = 100;
     pthread_t t1;  //线程一
     pthread_t t2;  //线程二
     pthread_mutex_init(&mutex,NULL);  //创建线程互斥锁
     ret = pthread_create(&t1,NULL,func1,(void *)&param); //线程一
     ret = pthread_create(&t2,NULL,func2,(void *)&param); //线程二
     while(1){
     	printf("main p_data : %d\n",p_data);
        	sleep(1);   //让其他线程来竞争
     }
     pthread_join(t1,NULL); //等待线程一退出
     pthread_join(t2,NULL); //等待线程二退出
     pthread_mutex_destroy(&mutex); //销毁线程互斥锁
     return 0;
}

线程死锁：死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。

相当于就是：线程1创建一个锁1，锁2，线程2创建一个锁2，锁1，2个线程同时分别获得锁1和锁2后，想在获取锁2，锁1，但是已经分别被2个线程已经获取了，只能处于等待状态，由于都没有分别解锁，这就造成了死锁；

函数例子（死锁）：

#include <stdio.h>
#include <pthread.h>
//两个线程互斥锁
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void *func1(void *arg)
{
        pthread_mutex_lock(&mutex1); 线程1获取到锁1
        sleep(1);
        pthread_mutex_lock(&mutex2); 等待1秒后 因为锁2已经被线程2已经拿到了，此时处于等待
        while(1){
                printf("t1 param : %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
        pthread_mutet_unlock(&mutex2);
}

void *func2(void *arg)
{
        pthread_mutex_lock(&mutex2);  线程2获取到锁2
        sleep(1);
        pthread_mutex_lock(&mutex1); 等待1秒后 因为锁1已经被线程1已经拿到了，此时处于等待
        while(1){
                printf("t2 param : %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
        pthread_mutet_unlock(&mutex2);
}

int main()
{ 
        int ret;
        int param = 100;
        pthread_t t1;
        pthread_t t2;
        pthread_mutex_init(&mutex1,NULL);
        pthread_mutex_init(&mutex2,NULL);
        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        ret = pthread_create(&t2,NULL,func2,(void *)&param);
        pthread_join(t1,NULL); //等待退出
        pthread_join(t2,NULL);
        pthread_mutex_destroy(&mutex1);  //销毁互斥锁
        pthread_mutex_destroy(&mutex2);
        return 0;
}