Day08 Liunx高级系统设计9-线程间同步与互斥

引入

经过昨天的学习 , 我们会使用线程

但是当多个线程同时操作同一个数据会导致数据安全问题

为了解决该问题 , 我们需要对其进行更加深入的学习

解决思路

保证多个线程不能同时操作同一个数据

同步与互斥的概念

互斥：同一时间，只能有一个任务（进程或线程）执行，谁先执行不确定。

同步：同一时间，只能有一个任务（进程或线程）执行，有顺序的执行。

同步 是特殊的互斥。

锁

作用

用于线程的互斥。

互斥锁是一种简单的加锁的方法来控制对共享资源的访问。

互斥锁只有两种状态 , 即加锁 ( lock ) 和解锁（ unlock ）。

帮助文档

1 ）在访问共享资源后临界区域前，对互斥锁进行加锁。

2 ）在访问完成后释放互斥锁导上的锁。

3 ）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁

被释放。

注意 : 多个线程互斥锁要是同一个

互斥锁的数据类型是 :pthread_mutex_t

互斥锁

概念：

用于线程的互斥。

互斥锁是一种简单的加锁的方法来控制对共享资源的访问。

互斥锁只有两种状态 , 即加锁 ( lock ) 和解锁（ unlock ）。

操作原理

1 ）在访问共享资源后临界区域前，对互斥锁进行加锁。

2 ）在访问完成后释放互斥锁导上的锁。

3 ）对互斥锁进行加锁后，任何其他试图再次对互斥锁加锁的线程将会被阻塞，直到锁

被释放。

注意 : 多个线程互斥锁要是同一个

互斥锁的数据类型是 :pthread_mutex_t

初始化

作用 : 初始化互斥锁

所需头文件

        #include <pthread.h>

函数

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

参数：

        mutex：互斥锁地址。类型是 pthread_mutex_t 。

        attr：设置互斥量的属性，通常可采用默认属性，即可将 attr 设为 NULL 。

        可以使用宏PTHREAD_MUTEX_INITIALIZER 静态初始化互斥锁 , 比如：

                pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

                这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_mutex_init() 来完成动态初始化，不同之处在于 PTHREAD_MUTEX_INITIALIZER 宏不进行错误检查。

返回值：

        成功：0 ，成功申请的锁默认是打开的。

        失败：非 0 错误

示例

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    // 动态获取互斥锁,推荐
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, NULL);
    // 静态获取互斥锁,声明与赋值必须同时进程
    pthread_mutex_t lock02 = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_destroy(&lock);
    pthread_mutex_destroy(&lock02);
    return 0;
}

销毁

作用 : 销毁互斥锁 , 互斥锁在使用完毕后，必须要对互斥锁进行销毁，以释放资源。

函数

所需头文件

        #include <pthread.h>

函数

        int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

        mutex：互斥锁地址。

返回值 :

        成功：0

        失败：非 0 错误码

示例

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    // 动态获取互斥锁,推荐
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, NULL);
    // 静态获取互斥锁
    pthread_mutex_t lock02 = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_destroy(&lock);
    pthread_mutex_destroy(&lock02);
    return 0;
}

上锁

作用 : 对互斥锁上锁，若互斥锁已经上锁，则调用者阻塞，直到互斥锁解锁后再上锁。

函数

所需头文件

        #include <pthread.h>

函数

        int pthread_mutex_lock(pthread_mutex_t *mutex);

参数：

        mutex：互斥锁地址。

返回值：

        成功：0

        失败：非 0 错误码

解锁

作用 : 对指定的互斥锁解锁。

函数

所需头文件

        #include <pthread.h>

函数

        int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

        mutex：互斥锁地址。

返回值：

        成功：0

        失败：非 0 错误码

案例1:错误演示

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
void *tick(void *arg)
{
    static int num = 100;
    while (num > 0)
    {
        num--;
        sleep(0.1);
        printf("线程%ld销售了一张票,还剩%d张\n", pthread_self(), num);
    }
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_t p1, p2, p3, p4;
    pthread_create(&p1, NULL, tick, NULL);
    pthread_create(&p2, NULL, tick, NULL);
    pthread_create(&p3, NULL, tick, NULL);
    pthread_create(&p4, NULL, tick, NULL);
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
    pthread_join(p3, NULL);
    pthread_join(p4, NULL);
    return 0;
}

案例2:加锁后

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
int ticket = 100;
pthread_mutex_t lock;
// pthread_cond_t cond;
void *sale(void *name)
{
    
    while(ticket > 0)
    {
        pthread_mutex_lock(&lock);
        if(ticket <= 0)
        {
            pthread_mutex_unlock(&lock);
            break;
        }
        ticket--;
        sleep(0.5);
        printf("%s售卖了一张船票,还剩%d张船票\n",(char *)name,ticket);
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}
int main(int argc, char const *argv[])
{
    pthread_mutex_init(&lock,NULL);//初始化
    pthread_t tid1,tid2,tid3,tid4;
    pthread_create(&tid1,NULL,sale,"一号窗口");
    pthread_create(&tid2,NULL,sale,"二号窗口");
    pthread_create(&tid3,NULL,sale,"三号窗口");
    pthread_create(&tid3,NULL,sale,"四号窗口");
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);
    pthread_join(tid4,NULL);
    pthread_mutex_destroy(&lock);
    return 0;
}

死锁

概念 : 多个线程互相持有对方所需的锁资源

结果 : 程序无法向下运行 , 所以不会结束 , 但又不能执行代码

总结