线程同步的实现

翔在天上飞

已于 2022-09-16 18:59:35 修改

阅读量272

点赞数 2

分类专栏： linux学习历程文章标签： c语言 linux ubuntu

于 2022-09-13 19:36:26 首次发布

本文链接：https://blog.csdn.net/qq_45570844/article/details/126839234

版权

linux学习历程专栏收录该内容

25 篇文章 8 订阅

订阅专栏

互斥锁

互斥锁的使用就是当有线程访问进程空间中的公共资源时，线程执行“加锁”操作(将资源锁起来)，阻止其它线程的访问。访问完成后，该线程（谁锁上的必须由谁来解锁）负责完成“解锁”操作，将资源让给其它线程。当有多个线程同时需要访问同一个公共资源时，谁先上锁成功，这公共资源就归谁使用，只有等他用完了，释放锁了，其他线程才能用

互斥锁的使用流程

（1）定义一个互斥锁

在<pthread.h>头文件中，有一个专门用来定义互斥锁变量的结构体，叫pthread_mutex_t，我们直接拿来用就是了，使用方法如下

pthread_mutex_t myMutex;

（2）初始化互斥锁

互斥锁的初始化方法有两种，一种是使用特定的宏，一种是使用专门的初始化函数，一般没啥特殊要求我们就用第一种宏就行，对于调用 malloc() 函数分配动态内存的互斥锁，只能使用第二种方式。

使用宏的方法

pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;

使用函数的方法

pthread_mutex_t myMutex;
pthread_mutex_init(&myMutex , NULL);

关于pthread_mutex_init() 函数，他的原型是这样的

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

关于他的参数，mutex 参数表示要初始化的互斥锁；attr 参数用于自定义新建互斥锁的属性，当attr 的值为 NULL 时表示以默认属性创建互斥锁，我们一般也就使用NULL。

（3）加锁

int pthread_mutex_lock(pthread_mutex_t* mutex);

//或者用下面这个

int pthread_mutex_trylock(pthread_mutex_t* mutex);

有关两者的区别，具体如下

pthread_mutex_lock() 函数会使线程进入等待（阻塞）状态，直至互斥锁得到释放；

pthread_mutex_trylock() 函数不会阻塞线程，直接返回非零数（表示加锁失败）。

（4）解锁

int pthread_mutex_unlock(pthread_mutex_t* mutex);

说到最后，用一个实际案例来实验一下，模拟的是网上买票的工作流程。创建了四个子线程，去模拟不同的买票窗口去负责卖票。

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
int ticket_sum = 30;//这表示票的总量

//创建互斥锁变量并初始化
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;

//模拟售票员卖票
void *sell_ticket(void *arg) 
{
    //输出当前线程的ID
    printf("id = %u\n", pthread_self());
    int i;
    int islock = 0;
    for (i = 0; i < 10; i++)
    {
        //当前线程“加锁”
        islock = pthread_mutex_lock(&myMutex);
        //如果“加锁”成功，执行如下代码
        if (islock == 0)
        {
            //如果票数 >0 ,开始卖票
            if (ticket_sum > 0)
            {
                sleep(1);
				printf("%u sell the NO.%d ticket\n",pthread_self(),30-ticket_sum+1);
                ticket_sum--;
            }
           	pthread_mutex_unlock(&myMutex);
        }
       
    }
    return 0;
}
int main() 
{
    int flag;
    int i;
    //创建4个线程
    pthread_t tids[4];
    for (i = 0; i < 4; i++)
    {
        flag = pthread_create(&tids[i], NULL, &sell_ticket, NULL);
        if (flag != 0) 
        {
            printf("fail\n");
            return 0;
        }
    }
    sleep(30);   //等待4个子线程完成
    for (i = 0; i < 4; i++)
    {
        flag = pthread_join(tids[i], NULL);
        if (flag != 0) 
        {
            printf("tid=%d wait fail !", tids[i]);
            return 0;
        }
    }
    return 0;
}

程序中pthread_self()这个其实是这样子的，我直接man出来，大家看一下，就是用来返回，调用线程的id的。

关于这个程序案例，写完后，我自己其实运行了几次，之前我将票的总数量设置成10，发现从头到尾只有一个线程在被调用，我以为是我的程序有问题，在网上查阅了一下资料发现，是我们当前的电脑机子性能太好所致，当操作数量少的情况下的多线程，电脑自己其实就使用一个线程就给我们安排了，于是我加大了数量，这才发生点变化出来

信号量

互斥锁的状态值只有开锁和解锁两个方面，信号量则不同，他可以根据实际场景的不同设置自己想要的转态值，可以说是更加灵活吧。

信号量可以分成是二进制信号量和计数信号量，二进制信号量就可以用来替代互斥锁，就是只将信号量的初始值设置成1，然后只能0,1间变换，可以理解成每次只允许一个线程同时访问一片公共资源，而计数信号量就是将信号量的初始值设置的多一点，大于1的那种，意味着每次可以同时接待多个线程来访问公共资源。

下面来看看信号量这东西的用法，具体咋用

sem_t mySem; //先定义一个信号量

//信号量的初始化

int sem_init(sem_t *sem, int pshared, unsigned int value);

各个参数的含义分别为：

1、参数sem：表示要初始化的目标信号量；

2、参数pshared：表示该信号量是否可以和其他进程共享，pshared 值为 0 时表示不共享，值为 1 时表示共享；

3、参数value：设置信号量的初始值。

对于初始化好了的信号量，我们可以借助 <semaphore.h> 头文件提供的一些函数操作

入参都是要操作的信号量

//将信号量的值“加 1”

int sem_post(sem_t* sem);

//对信号量做“减 1”操作,当信号量的值为 0 时，阻塞当前线程等待

int sem_wait(sem_t* sem);

//当信号量的值为 0 时，sem_trywait() 函数并不会阻塞当前线程，而是立即返回 -1；

int sem_trywait(sem_t* sem);

//手动销毁信号量

int sem_destroy(sem_t* sem);