linux多线程编程——同步与互斥

最新推荐文章于 2023-04-15 00:21:16 发布
最新推荐文章于 2023-04-15 00:21:16 发布
阅读量430 收藏 2
点赞数
分类专栏： 进程和线程
原文链接：https://blog.csdn.net/zqixiao_09/article/details/50318149
版权

我们在前面文章中已经分析了多线程VS多进程，也分析了线程的使用，现在我们来讲解一下linux多线程编程之同步与互斥。

现在，我们不管究竟是多线程好还是多进程好，先讲解一下，为什么要使用多线程？

一、 为什么要用多线程技术？

1、避免阻塞，大家知道，单个进程只有一个主线程，当主线程阻塞的时候，整个进程也就阻塞了，无法再去做其它的一些功能了。

2、避免CPU空转，应用程序经常会涉及到RPC，数据库访问，磁盘IO等操作，这些操作的速度比CPU慢很多，而在等待这些响应时，CPU却不能去处理新的请求，导致这种单线程的应用程序性能很差。

3、提升效率，一个进程要独立拥有4GB的虚拟地址空间，而多个线程可以共享同一地址空间，线程的切换比进程的切换要快得多。

二、  如何使用多线程技术进行编程？

下面给出个多线程程序，一个最简单的模拟售票系统，代码如下：

#include <stdio.h>
#include <pthread.h>
 
void *ticketsell1(void *);
void *ticketsell2(void *);
int tickets = 20;
 
int main()
{
    pthread_t id1,id2;
    int error;
 
    error = pthread_create(&id1, NULL, ticketsell1, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    error = pthread_create(&id2, NULL, ticketsell2, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    
    return 0;
}
 
void *ticketsell1(void *arg)
{
    while(1)
    {
        if(tickets > 0)
        {
//            usleep(1000);
            printf("ticketse1 sells ticket:%d\n",tickets--);
        }
        else
        {
            break;
        }
    }
    return (void *)0;
}
 
void *ticketsell2(void *arg)
{
    while(1)
    {
        if(tickets > 0)
        {
//            usleep(1000);
            printf("ticketse2 sells ticket:%d\n",tickets--);
        }
        else
        {
            break;
        }
    }
 
    return (void *)0;
}


执行结果如下：

fs@ubuntu:~/qiang/mthread$ ./mthread1 
ticketse2 sells ticket:20
ticketse2 sells ticket:19
ticketse2 sells ticket:18
ticketse2 sells ticket:17
ticketse2 sells ticket:16
ticketse2 sells ticket:15
ticketse2 sells ticket:14
ticketse2 sells ticket:13
ticketse2 sells ticket:12
ticketse2 sells ticket:11
ticketse2 sells ticket:10
ticketse2 sells ticket:9
ticketse2 sells ticket:8
ticketse2 sells ticket:7
ticketse2 sells ticket:6
ticketse2 sells ticket:4
ticketse2 sells ticket:3
ticketse2 sells ticket:2
ticketse2 sells ticket:1
ticketse1 sells ticket:5


看到结果，我们发现时能正常卖票的，一部分连续是sel2,另一部分是ticketsel1;

此时，其实存在一个隐含的问题，就是线程间的切换，在单CPU系统中，CPU是有时间片时间，时间片到了，就要执行其它的线程，假设thread1执行到if里面，但在printf执行前发生了线程切换，那么会发生什么呢？我们在这里用usleep函数(放开程序中的usleep注释行)进行强制模拟切换;

我们看看结果：

fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread
fs@ubuntu:~/qiang/mthread$ ./mthread1 
ticketse2 sells ticket:20
ticketse1 sells ticket:19
ticketse2 sells ticket:18
ticketse1 sells ticket:17
ticketse2 sells ticket:16
ticketse1 sells ticket:15
ticketse2 sells ticket:14
ticketse1 sells ticket:13
ticketse2 sells ticket:12
ticketse1 sells ticket:11
ticketse2 sells ticket:10
ticketse1 sells ticket:9
ticketse2 sells ticket:8
ticketse1 sells ticket:7
ticketse2 sells ticket:6
ticketse1 sells ticket:5
ticketse2 sells ticket:4
ticketse1 sells ticket:3
ticketse1 sells ticket:2
ticketse2 sells ticket:1
ticketse1 sells ticket:0
fs@ubuntu:~/qiang/mthread$ 


运行程序发现竟然有0号票被卖出了，这显然是错误的！当thread1的if里面发生线程切换时，thread2得到运行，把最后一张票卖了，此时thread1恢复运行，结果卖出了0号票，这里我们需要的是火车票的票数数据对于所有线程而言是同步的，所以就要用到线程同步技术了。

 

三、  使用多线程的同步与互斥

1、多线程的同步方式有很多种，例如互斥锁，条件变量，信号量，读写锁。先看看互斥锁如何解决多线程之间的同步问题。程序用互斥锁后如下：

#include <stdio.h>
#include <pthread.h>
 
void *ticketsell1(void *);
void *ticketsell2(void *);
int tickets = 20;
pthread_mutex_t mutex;
 
int main()
{
    pthread_t id1,id2;
    pthread_mutex_init(&mutex, NULL);//
    int error;
 
    error = pthread_create(&id1, NULL, ticketsell1, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    error = pthread_create(&id2, NULL, ticketsell2, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    
    return 0;
}
 
void *ticketsell1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);//给互斥量上锁
        if(tickets > 0)
        {
            usleep(1000);
            printf("ticketse1 sells ticket:%d\n",tickets--);
            pthread_mutex_unlock(&mutex);//给互斥量解锁
            
        }
        else
        {
            pthread_mutex_unlock(&mutex);//给互斥量解锁
            break;
        }
        pthread_yield();//线程调度函数，使每个线程都有执行机会
    }
    return (void *)0;
}
 
void *ticketsell2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);//给互斥量上锁
        if(tickets > 0)
        {
            usleep(1000);
            printf("ticketse2 sells ticket:%d\n",tickets--);
            pthread_mutex_unlock(&mutex);//给互斥量解锁
        }
        else
        {
            pthread_mutex_unlock(&mutex);//给互斥量解锁
            break;
        }
        pthread_yield();//线程调度函数，是两个线程都有执行机会
    }
 
    return (void *)0;
}


执行结果如下：

fs@ubuntu:~/qiang/mthread$ vi mthread1.c
fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread
fs@ubuntu:~/qiang/mthread$ ./mthread1 
ticketse2 sells ticket:20
ticketse1 sells ticket:19
ticketse2 sells ticket:18
ticketse1 sells ticket:17
ticketse2 sells ticket:16
ticketse1 sells ticket:15
ticketse2 sells ticket:14
ticketse1 sells ticket:13
ticketse2 sells ticket:12
ticketse1 sells ticket:11
ticketse2 sells ticket:10
ticketse1 sells ticket:9
ticketse2 sells ticket:8
ticketse1 sells ticket:7
ticketse2 sells ticket:6
ticketse1 sells ticket:5
ticketse2 sells ticket:4
ticketse1 sells ticket:3
ticketse2 sells ticket:2
ticketse1 sells ticket:1

2、再看看用信号量来解决多线程的同步问题，程序代码如下：

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
 
void *ticketsell1(void *);
void *ticketsell2(void *);
int tickets = 20;
sem_t mutex,full;
 
int main()
{
    pthread_t id1,id2;
    int error;
    int ret;
 
    ret = sem_init(&mutex, 0 ,1);//初始化mutex信号量为1
    ret += sem_init(&full, 0 ,0);//初始化full信号量为0
 
    if(ret != 0)
    {
        printf("sem_init fails!\n");
    }
 
    error = pthread_create(&id1, NULL, ticketsell1, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    error = pthread_create(&id2, NULL, ticketsell2, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    
    return 0;
}
 
void *ticketsell1(void *arg)
{
    while(1)
    {
        sem_wait(&mutex);//mutex信号量进行P操作
        if(tickets > 0)
        {
            usleep(1000);
            printf("ticketse1 sells ticket:%d\n",tickets--);
            sem_post(&full);//full信号量进行V操作
        }
        else
        {
            sem_post(&full);//full信号量进行V操作
            break;
        }
    }
    return (void *)0;
}
 
void *ticketsell2(void *arg)
{
    while(1)
    {
        sem_wait(&full);//full信号量进行P操作
        if(tickets > 0)
        {
            usleep(1000);
            printf("ticketse2 sells ticket:%d\n",tickets--);
            sem_post(&mutex);//mutex信号量进行V操作
        }
        else
        {
            sem_post(&mutex);//mutex信号量进行V操作
            break;
        }
    }
 
    return (void *)0;
}


执行结果：

fs@ubuntu:~/qiang/mthread$ vi mthread1.c
fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread
fs@ubuntu:~/qiang/mthread$ ./mthread1 
ticketse1 sells ticket:20
ticketse2 sells ticket:19
ticketse1 sells ticket:18
ticketse2 sells ticket:17
ticketse1 sells ticket:16
ticketse2 sells ticket:15
ticketse1 sells ticket:14
ticketse2 sells ticket:13
ticketse1 sells ticket:12
ticketse2 sells ticket:11
ticketse1 sells ticket:10
ticketse2 sells ticket:9
ticketse1 sells ticket:8
ticketse2 sells ticket:7
ticketse1 sells ticket:6
ticketse2 sells ticket:5
ticketse1 sells ticket:4
ticketse2 sells ticket:3
ticketse1 sells ticket:2
ticketse2 sells ticket:1
fs@ubuntu:~/qiang/mthread$ 


上面的sem_init函数用来初始化两个信号量的初始化值，这里一个设为1，一个设为0，sem_wait类似于P操作，让信号量减1，如果小于结果小于0，线程阻塞，否则线程继续执行，sem_post类似于V操作，提升信号量的值，加1，通过这两个信号量之间的互相“救对方”，就可以实现这两个线程的同步执行。

我们编译运行以上程序，发现两个售票点交替卖票，两个纯程依次得到机会执行，并且不会有0号票卖出，实现了同步。

 

3、我们再用条件变量来解决同步问题，一般条件变量需要结合互斥量一起使用，代码如下

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
 
void *ticketsell1(void *);
void *ticketsell2(void *);
int tickets = 20;
pthread_mutex_t mutex;
pthread_cond_t  qready = PTHREAD_COND_INITIALIZER;//静态初始化条件变量;
        
int main()
{
    pthread_t id1,id2;
    pthread_mutex_init(&mutex, NULL);
    int error;
 
    error = pthread_create(&id1, NULL, ticketsell1, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    error = pthread_create(&id2, NULL, ticketsell2, NULL);
    if(error != 0)
    {
        printf("pthread is not created!\n");
        return -1;
    }
 
    pthread_join(id1,NULL);
    pthread_join(id2,NULL);
    
    return 0;
}
 
void *ticketsell1(void *arg)
{
    pthread_mutex_lock(&mutex);
    while(tickets > 0)
    {
        if(tickets%2 == 1)
        {
            usleep(1000);
            printf("ticketse1 sells ticket:%d\n",tickets--);
            pthread_cond_signal(&qready);//条件改变，发送信号，通知ticketse2
        }
        else
        {
            pthread_cond_wait(&qready,&mutex);//解开Mutex,并等待qready改变
        }
        pthread_mutex_unlock(&mutex);//给互斥量解锁
    }
    return (void *)0;
}
 
void *ticketsell2(void *arg)
{
    pthread_mutex_lock(&mutex);
    while(tickets > 0)
    {
        if(tickets%2 == 0)
        {
            usleep(1000);
            printf("ticketse2 sells ticket:%d\n",tickets--);
            pthread_cond_signal(&qready);//条件改变，发送信号，通知ticketse1
        }
        else
        {
            pthread_cond_wait(&qready,&mutex);//解开mutex,并等待qready改变
        }
        pthread_mutex_unlock(&mutex);//给互斥量解锁
    }
 
    return (void *)0;
}


执行结果如下：

fs@ubuntu:~/qiang/mthread$ vi mthread1.c
fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread
fs@ubuntu:~/qiang/mthread$ ./mthread1 
ticketse2 sells ticket:20
ticketse1 sells ticket:19
ticketse2 sells ticket:18
ticketse1 sells ticket:17
ticketse2 sells ticket:16
ticketse1 sells ticket:15
ticketse2 sells ticket:14
ticketse1 sells ticket:13
ticketse2 sells ticket:12
ticketse1 sells ticket:11
ticketse2 sells ticket:10
ticketse1 sells ticket:9
ticketse2 sells ticket:8
ticketse1 sells ticket:7
ticketse2 sells ticket:6
ticketse1 sells ticket:5
ticketse2 sells ticket:4
ticketse1 sells ticket:3
ticketse2 sells ticket:2
ticketse1 sells ticket:1
fs@ubuntu:~/qiang/mthread$ 

  条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件变量发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线程间的同步.

函数pthread_cond_wait使线程阻塞在一个条件变量上,而函数pthread_cond_signal是用来释放被阻塞在条件变量上的一个线程。但是要注意的是，条件变量只是起到阻塞和唤醒线程的作用，具体的判断条件还需用户给出，我这里给出的是tickets是否是偶数这个条件。
————————————————
版权声明：本文为CSDN博主「zqixiao_09」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zqixiao_09/article/details/50318149

modi000
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下的多线程编程二（线程的同步与互斥）
snow_5288的博客
06-14 4492
一、什么叫做线程的同步与互斥？为什么需要同步与互斥？ 二、互斥量 三、条件变量 四、信号量 五、读写锁
POSIX线程库pthread
m0_50488845的博客
04-27 2647
POSIX线程库中函数的相关解释
linux 同步 互斥 概念
awsqsh的专栏
02-13 399
相交进程之间的关系主要有两种，同步与互斥。所谓互斥，是指散步在不同进程之间的若干程序片断，当某个进程运行其中一个程序片段时，其它进程就不能运行它 们之中的任一程序片段，只能等到该进程运行完这个程序片段后才可以运行。所谓同步，是指散步在不同进程之间的若干程序片断，它们的运行必须严格按照规定的 某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。 　　显然，同步是一种更为复杂的互斥，而互斥是一
【Linux】线程互斥与同步
m0_51064412的博客
03-12 3376
文章目录一. 什么是互斥？二. 为什么要有互斥？三. 互斥量实现互斥 一. 什么是互斥？ 在介绍什么是互斥之前需要了解下面三个概念： 临界资源：多线程执行流共享的资源就叫做临界资源。 临界区：每个线程内部，访问临界资源的代码，就叫做临界区。 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 二. 为什么要有互斥？ 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程私有栈空间
Linux多线程编程(二)---线程之间的同步与互斥
热门推荐
王文松的博客
07-20 1万+
由于线程共享进程的资源和地址空间，因此在对这些资源进行操作时，必须考虑到线程间资源访问的同步与互斥问题。这里主要介绍Posix中两种线程同步机制，分别为互斥锁和信号量。这两个同步机制可以通过互相调用对方来实现，但互斥锁更适用于同时可用的资源是唯一的情况；信号量更适用于同时可用的资源为多个的情况。
Linux多线程编程_linux_
09-30
总之，Linux多线程编程涉及的内容广泛，包括线程的创建、同步、通信、资源管理等多个方面。掌握这些知识点对于开发高效、稳定的多线程应用程序至关重要。通过深入学习和实践，你将能够充分利用Linux的多线程特性来...
linux线程同步
06-13
在Linux环境下，多线程编程因其高效的资源利用和灵活的任务调度受到广泛欢迎。然而，多线程虽然提高了程序的执行效率，但也带来了新的挑战——线程之间的同步问题。本文旨在深入探讨Linux下多线程同步的各种方法，...
linux多线程编程_吸烟者问题
04-11
通过分析和理解这段代码，你可以深入学习Linux多线程编程中的同步与通信机制，以及如何在实际问题中应用这些概念。这有助于提升你在并发编程领域的技能，对于开发高效、稳定的多线程应用至关重要。
Linux多线程编程知识点总结（C语言）（csdn）————程序.pdf
12-01
总的来说，Linux多线程编程需要掌握线程的创建、管理和同步机制，理解线程与进程的区别，以及如何有效地防止和解决死锁问题。熟悉Pthreads API是编写可靠多线程应用的基础。通过深入学习和实践，开发者可以构建出...
进程间同步互斥问题——银行柜员服务问题1
08-03
在操作系统中，进程间的同步和互斥是多线程编程中的核心概念。在银行柜员服务问题中，这些概念得到了实际的应用。该问题模拟了一个银行环境，其中n个柜员为顾客提供服务。为了解决这个问题，我们需要用到P、V操作...
Linux线程同步与互斥
weixin_51885188的博客
06-21 754
Linux线程同步与互斥
Linux操作系统-线程同步与互斥
weixin_43164548的博客
06-22 327
多线程中的同步与互斥
Linux--线程同步与互斥
我的博客
07-18 441
1 线程同步与互斥的引入 互斥：对于某种资源，如果有一个进程正在访问该资源，则其它的进程必须等待，当那个进程访问完成后其它进程才能访问。 同步：某些进程的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。 1.由于同一个进程之间的线程很多东西是共享的，就会使得多个线程看到同一份资源，不同线程都可以访问该共同资源。如果多个线程并发的访问某个共享资源...
【Linux】线程同步与互斥
jhao的博客
03-28 1854
讲述了线程同步与互斥，以及基于阻塞队列和环形队列的生产者消费者模型。
线程同步与互斥【Linux】
最新发布
Man9o
04-15 1334
本文介绍了同步与异步,互斥与并发,原子性操作,临界资源和临界区,互斥锁,可重入和线程安全，死锁，线程同步，条件变量......
Linux线程的同步与互斥(一) 互斥锁+读写锁
想要上进的coder的博客
09-12 1082
为什么需要同步和互斥？ 因为多个线程共享地址空间，也就是很多资源都是共享的 优点：通信方便 缺点：缺乏访问控制 线程安全：因为一个线程的操作问题，给其他线程造成了不可控、引起崩溃、异常、逻辑不正确等问题的现象。 创建一个函数，它没有线程安全问题的的话，不要使用全局变量、STL、malloc、new等等会在全局有效的数据(会有访问控制的问题) 我们之前写的函数为什么没有线程安全问题呢 我们之前所学的都是使用的局部变量！线程都有自己的独立栈结构！ 互斥同步相关的概念 临界资源：凡是被线程共享访问的资源都是
linux操作系统之线程同步及互斥量
xx18030637774的博客
09-04 330
（1）线程同步            1）线程同步：指一个线程发出某一个功能运行时，在运行还没有结束的时候，该调用不返回。同时其它线程为保证数据的一致性，不能调用该功能。            2）多个控制流共同操作一个共享资源的时候，都需要同步。            3）数据混乱的原因：1》资源共享  2》调度随机   3》线程间缺乏必要的同步机制。                  ...
Linux线程安全同步和互斥
向未来❀去探索 的博客
07-03 771
Linux线程安全同步和互斥(函数调用和测试用例使用)
Linux多线程服务端编程——C++实战与muduo库解析
"《Linux多线程服务端编程》由陈硕编写，主要探讨了如何在Linux环境下使用C++进行多线程服务端的开发，特别关注了对象生命周期管理、线程同步、服务器编程模型以及C++多线程系统编程的关键点。书中深入浅出地分析了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值