[Linux]线程与同步机制

最新推荐文章于 2022-04-23 23:16:12 发布
最新推荐文章于 2022-04-23 23:16:12 发布
阅读量134 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csy_best/article/details/102856138
版权

一、单线程

1.1 源码

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>

void sleep_us(unsigned long uSec){
    struct timeval tv;
    tv.tv_sec=uSec/1000000;
    tv.tv_usec=uSec%1000000;

   int err;
   do{
        err=select(0,NULL,NULL,NULL,&tv);
    }while(err<0 && errno==EINTR);
}

void* route(void *arg)
{
    char* thread_name = (char*)arg;

    while(1){
        if(ticket > 0){
           printf("thread:%s sells ticket:%d\n",thread_name,ticket);
           ticket--;

           sleep_us(1000000);
        }else{
           break;
        }

    }
}

void test_single_thread(){
    pthread_t t1;

    pthread_create(&t1,NULL,route,(void*)"thread_1");

    pthread_join(t1,NULL);
}

int main(){

    test_single_thread(); 

    return 0;
}

1.2 结果

thread:thread_1 sells ticket:10
thread:thread_1 sells ticket:9
thread:thread_1 sells ticket:8
thread:thread_1 sells ticket:7
thread:thread_1 sells ticket:6
thread:thread_1 sells ticket:5
thread:thread_1 sells ticket:4
thread:thread_1 sells ticket:3
thread:thread_1 sells ticket:2
thread:thread_1 sells ticket:1

二、多线程

2.1 源码

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>

int ticket = 10;

void sleep_us(unsigned long uSec){
    struct timeval tv;
    tv.tv_sec=uSec/1000000;
    tv.tv_usec=uSec%1000000;

   int err;
   do{
        err=select(0,NULL,NULL,NULL,&tv);
    }while(err<0 && errno==EINTR);
}

void* route(void *arg)
{
    char* thread_name = (char*)arg;

    while(1){
        if(ticket > 0){
           printf("thread:%s sells ticket:%d\n",thread_name,ticket);
           ticket--;

           sleep_us(1000000);
        }else{
           break;
        }

    }
}

void test_multi_thread(){
    pthread_t t1;
    pthread_t t2;

    pthread_create(&t1,NULL,route,(void*)"thread_1");
    pthread_create(&t2,NULL,route,(void*)"thread_2");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
}


int main(){

    test_multi_thread();

    return 0;
}

2.2 结果

thread:thread_2 sells ticket:10
thread:thread_1 sells ticket:10
thread:thread_1 sells ticket:8
thread:thread_2 sells ticket:8
thread:thread_2 sells ticket:6
thread:thread_1 sells ticket:6
thread:thread_1 sells ticket:4
thread:thread_2 sells ticket:4
thread:thread_2 sells ticket:2
thread:thread_1 sells ticket:2
thread:thread_2 sells ticket:0

错误结果：线程1和线程2同时卖同一票

 

三、多线程与同步机制

3.1 互斥锁(mutex)

3.1.1 函数

  • 初始化锁

    静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

    动态分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr)

  • 加锁

    int pthread_mutex_lock(pthread_mutex *mutex)

    int pthread_mutex_trylock(pthread_mutex_t *mutex)

  • 解锁

    int pthread_mutex_unlock(pthread_mutex_t *mutex)

  • 销毁锁

    int pthread_mutex_destroy(pthread_mutex *mutex)

3.1.2 源码

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>


pthread_mutex_t mutex; //定义

int ticket = 10;

void sleep_us(unsigned long uSec){
    struct timeval tv;
    tv.tv_sec=uSec/1000000;
    tv.tv_usec=uSec%1000000;

   int err;
   do{
        err=select(0,NULL,NULL,NULL,&tv);
    }while(err<0 && errno==EINTR);
}


void* route_mutex(void *arg)
{   
    char* thread_name = (char*)arg;
    
    while(1){
        pthread_mutex_lock(&mutex);
        if(ticket > 0){
           printf("thread:%s sells ticket:%d\n",thread_name,ticket);
           ticket--;
           pthread_mutex_unlock(&mutex);
           
           sleep_us(1000000);//注意休眠的位置
        }else{
           pthread_mutex_unlock(&mutex);
           break;
        }
    
    }
}

void test_multi_thread_mutex(){
    pthread_t t1;
    pthread_t t2;
    
    pthread_mutex_init(&mutex,NULL); //初始化锁

    pthread_create(&t1,NULL,route_mutex,(void*)"thread_1");
    pthread_create(&t2,NULL,route_mutex,(void*)"thread_2");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

    pthread_mutex_destroy(&mutex);//销毁锁
}

int main(){

    test_multi_thread_mutex();

    return 0;
}

3.1.3 结果

thread:thread_1 sells ticket:10
thread:thread_2 sells ticket:9
thread:thread_2 sells ticket:8
thread:thread_1 sells ticket:7
thread:thread_2 sells ticket:6
thread:thread_1 sells ticket:5
thread:thread_2 sells ticket:4
thread:thread_1 sells ticket:3
thread:thread_1 sells ticket:2
thread:thread_2 sells ticket:1

正确结果：某一张票只能由线程1或者线程2卖出

 

3.2 条件变量(cond)

3.2.1 函数

  • 初始化条件变量

    静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER

    动态初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

  • 等待条件成立(释放锁,同时阻塞等待条件变量为真才行)

    int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

    int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime)

  • 唤醒条件变量

    int pthread_cond_signal(pthread_cond_t *cond)

    int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞

  • 清除条件变量

    int pthread_cond_destroy(pthread_cond_t *cond)

3.2.2 源码

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>


pthread_mutex_t mutex;

pthread_cond_t cond; //定义

int ticket = 10;

void sleep_us(unsigned long uSec){
    struct timeval tv;
    tv.tv_sec=uSec/1000000;
    tv.tv_usec=uSec%1000000;

   int err;
   do{
        err=select(0,NULL,NULL,NULL,&tv);
    }while(err<0 && errno==EINTR);
}

void* route_consume_cond(void *arg)
{
    char* thread_name = (char*)arg;

    while(1){
        pthread_mutex_lock(&mutex);  //上锁
        if(ticket <= 0){
           printf("thread:%s has ticket:%d,waiting...\n",thread_name,ticket);
           pthread_cond_wait(&cond,&mutex);//条件不成立时挂起等待
        }

        if(ticket > 0){
           printf("thread:%s sells ticket:%d\n",thread_name,ticket);
           ticket--;                   //修改
        }
        pthread_mutex_unlock(&mutex);   //解锁

        sleep_us(1000000);
    }
}

void* route_produce_cond(void *arg)
{
    char* thread_name = (char*)arg;

    while(1){
           pthread_mutex_lock(&mutex);  //上锁
           printf("thread:%s sells ticket:%d\n",thread_name,ticket);
           ticket++;
           pthread_cond_signal(&cond);   //唤醒
           pthread_mutex_unlock(&mutex);  //解锁

           sleep_us(1200000);
    }
}

void test_multi_thread_available(){
    pthread_t t1;
    pthread_t t2;

    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);

    pthread_create(&t1,NULL,route_consume_cond,(void*)"consume");
    pthread_create(&t2,NULL,route_produce_cond,(void*)"produce");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
}

int main(){


    test_multi_thread_available();

    return 0;
}

3.2.3 结果

thread:consume sells ticket:10
thread:produce sells ticket:10
thread:consume sells ticket:10
thread:produce sells ticket:9
thread:consume sells ticket:10
thread:produce sells ticket:9
thread:consume sells ticket:10
...
thread:consume sells ticket:1
thread:produce sells ticket:0
thread:consume sells ticket:1
thread:produce sells ticket:0
thread:consume sells ticket:1
thread:produce sells ticket:0
thread:consume sells ticket:1
thread:produce sells ticket:0
thread:consume sells ticket:1

正常结果：(案例是：窗口票卖出快，窗口进票慢)最后出现，只有等到produce线程进了1正票之后，consume线程才能再卖出1张

3.2.4 pthread_cond_wait 参数二

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);

cond： 要在这个条件变量上等待（把当前线程挂起）
mutex： 互斥量（把当前线程拿到的锁释放）

为什么第二个参数要传互斥量？
因为等待条件满足是在临界区里等待的，如果某个线程直接进行等待，那么就会抱着锁去等待，此时，其他线程也无法进入临界资源。

剖析：pthread_cond_wait临时将当前线程拿到的mutex释放，允许其他线程占有mutex，不必等待.

这里route_consume_cond通过pthread_mutex_lock先占有mutex，之后通过pthread_cond_wait等待条件变量但会先临时释放mutex,使得其他线程可临时能占有锁；

这样，route_produce_cond线程到达pthread_mutex_lock时，是能占有mutex，不必等待.之后会pthread_cond_signal唤醒条件变量.

3.2.5 条件变量使用规范

(1)等待条件

pthread_mutex_lock(&lock);        #上锁
while(条件不成立)
{
    pthread_cond_wait(&cond);    #条件不成立时挂起等待（注意是while）
}
进行操作......                               #操作
pthread_mutex_unlock(&lock);   #解锁

(2)给条件发信号

pthread_mutex_lock(&lock);       #上锁
设置条件为真...                          #符合条件
pthread_cond_signal(&cond);    #唤醒
pthread_mutex_unlock(&lock);   #解锁
 

3.3 信号量(sem)

3.3.1 函数

  • 信号量初始化

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

    #sem：指定的信号量进行初始化，

    #pshared:表示此信号量是在进程间共享还是线程间共享，设置好它的共享选项(linux 只支持为0，即表示它是当前进程的局部        信号量)，

    #value:信号量的初始值

  • 等待信号量

    int sem_wait(sem_t *sem)

    #如果信号量的值大于0,将信号量的值减1,立即返回。如果信号量的值为0,则线程阻塞

  • 释放信号量。信号量值加1。并通知其他等待线程

    int sem_post(sem_t *sem)

  • 销毁信号量

    int sem_destroy(sem_t *sem)

3.3.2 源码

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdlib.h>
#include <errno.h>
#include <semaphore.h>

sem_t sem[2];

int ticket = 10;

void* route_consume_sem(void *arg)
{
    char* customer_name = (char*)arg;

    while(1){
         sem_wait(&sem[0]);//add lock for sem[0]
         ticket--;
         printf("thread:%s consume ticket:%d\n",customer_name,ticket);
         sem_post(&sem[1]);//release lock for sem[0]

         sleep_us(1000000);
    }
}

void* route_produce_sem(void *arg)
{
    char* customer_name = (char*)arg;

    while(1){
         sem_wait(&sem[1]); //add lock for sem[1]
         ticket++;
         printf("thread:%s produce ticket:%d\n",customer_name,ticket);
         sem_post(&sem[0]); //release lock for sem[0]

         sleep_us(1000000);
    }

}

void test_multi_thread_sem(){
    pthread_t t1;
    pthread_t t2;

    sem_init(&sem[0],0,0);  //For consume thread, init value is 0
    sem_init(&sem[1], 0, 1);//For produce thread, init value is 1 //

    pthread_create(&t1,NULL,route_consume_sem,(void*)"consume");
    pthread_create(&t2,NULL,route_produce_sem,(void*)"produce");

    pthread_join(t1,NULL);
    pthread_join(t2,NULL);

    sem_destroy(&sem[0]);
    sem_destroy(&sem[1]);

}


int main(){
    test_multi_thread_sem();

    return 0;

}

3.3.3 结果

thread:produce produce ticket:11
thread:consume consume ticket:10
thread:produce produce ticket:11
thread:consume consume ticket:10
thread:produce produce ticket:11
thread:consume consume ticket:10
thread:produce produce ticket:11
thread:consume consume ticket:10

3.4 区别

[参考:https://blog.csdn.net/a987073381/article/details/52029070]

互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：主要是流程上的概念，是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的

(1)互斥锁：互斥，一个线程占用了某个资源，那么其它的线程就无法访问，直到这个线程解锁，其它线程才可以访问

(2)条件变量：同步，一个线程完成了某一个动作就通过条件变量发送信号告诉别的线程，别的线程再进行某些动作

(3)信号量：同步，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动

 

附Makefile:

##dir
PWD_DIR=$(shell pwd)
OBJ_DIR=$(PWD_DIR)/obj
BIN_DIR=$(PWD_DIR)/bin

##compiler
CC=gcc

##target
TARGET=e_pthread

##build
$(TARGET):main.o
        $(CC) main.o -o $@ -lpthread
main.o:main.cpp
        $(CC) -c $^ 
clean:
        rm -rf *.o $(TARGET)

 

 

sy_cong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux线程同步的三种方法
Shannon_ying的博客
04-29 7424
Linux 线程同步的三种方法线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 一、互斥锁(mutex) 通过锁机制实现线程间的同步。 1. 初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。 静态分配：pthread_mutex_t
linux线程同步
06-13
### Linux线程同步详解 #### 一、引言 随着计算机技术的发展，多核处理器的普及使得并发编程成为提升程序性能的重要手段。在Linux环境下，多线程编程因其高效的资源利用和灵活的任务调度受到广泛欢迎。然而，多...
Linux互斥锁线程同步
brook666
01-20 347
在学习之前，一直以为同步就是保持工作步调一致。其实不然，线程同步的任务是对多个线程在执行上进行协调，使线程按照一定的规则共享资源，并能很好地相互合作。 互斥锁是线程同步最常见的技术手段，它也被称为互斥量，实质上它就是一个pthread_mutex_t类型的变量。相关的使用函数如下： (1)初始化互斥锁 int pthread_mutex_init(pthread_mutex_t *mutex...
Linux线程同步之互斥锁
青山绿水
06-20 830
1.互斥锁作用： 互斥锁mutex是用来保护线程间共享的全局变量安全的一种机制，保证多线程中在某一时刻只允许某一个线程对临界区的访问。 2.初始化方式： 互斥锁对象的数据类型是 pthread_mutex_t ； 互斥锁的初始方式分为静态方式和动态方式： //动态初始化互斥锁方式 int pthread_mutex_init(pthread_mutex_t *restrict mutex, con...
linux 线程同步的三种方法
hktkfly6的专栏
03-23 668
线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 一、互斥锁(mutex) 通过锁机制实现线程间的同步。 初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。 静态分配：pthread_mutex_t mutex
【Linux】线程互斥与同步
m0_51064412的博客
03-12 3570
文章目录一. 什么是互斥？二. 为什么要有互斥？三. 互斥量实现互斥 一. 什么是互斥？ 在介绍什么是互斥之前需要了解下面三个概念： 临界资源：多线程执行流共享的资源就叫做临界资源。 临界区：每个线程内部，访问临界资源的代码，就叫做临界区。 原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。 互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用 二. 为什么要有互斥？ 大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程私有栈空间
【Linux】线程同步与互斥
jhao的博客
03-28 2118
讲述了线程同步与互斥，以及基于阻塞队列和环形队列的生产者消费者模型。
Linux线程同步
抚琴弹出情凋零的博客
04-23 2708
1.同步 同步即协同步调，按预定的先后次序运行。 线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该函数。 解决同步的问题：加锁！ 2.数据混乱原因 1.资源共享（独享资源则不会） 2.调度随机（意味着数据访问会出现竞争） 3.线程间缺乏必要的同步机制 以上3点钟，前2点不能改变，欲提高效率，传递数据，资源必须共享。只要共享资源，就一定会出现竞争。只要存在竞争关系，数据就很容易出现混乱。 ...
Linux线程同步与Windows线程同步
路过的熊的博客
03-07 725
简介 线程同步概念：在多线程下，在一段时间内只允许一个线程访问资源，不允许其它线程访问。 在WIN32中，同步机制主要有以下几种： （1）事件(Event); （2）信号量(semaphore); （3）互斥量(mutex); （4）临界区(Critical section)。 事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类： （1）手动设置：这种
Linux 线程间同步机制
08-09
互斥锁是一个二元变量，其状态为开锁（允许0）和上锁（禁止1），将某个共享资源与某个特定互斥锁绑定后，对该共享资源的访问如下操作： （1）在访问该资源前，首先申请该互斥锁，如果该互斥处于开锁状态，则申请到该...
Linux线程同步机制深度解析与实用指南.zip
05-01
Linux下的线程同步机制是实现多线程编程的关键。通过合理使用互斥锁、条件变量、读写锁和信号量等机制，可以确保多个线程之间的协调运行和数据一致性。在实际编程中，需要根据具体需求选择合适的同步机制并遵循最佳...
linux线程间的同步与互斥知识点总结
09-14
条件变量提供了灵活的同步机制，允许线程在满足特定条件时才继续执行，而互斥锁则确保了对临界资源的独占访问。理解并熟练运用这些机制，开发者可以在编写多线程程序时有效地管理并发，防止数据错误和死锁等问题的...
Linux多线程同步方法
08-13
"Linux多线程同步方法" Linux多线程同步方法是指在Linux操作系统中，多个线程之间为了访问共享资源而进行的同步操作。由于多线程的存在，可能会出现多个线程同时访问共享资源的情况，从而导致数据的不一致性和混乱...
Linux — 浅析线程以及多线程的同步与互斥
阿亮的博客
06-04 2568
线程 链接：http://blog.csdn.net/ctthuangcheng/article/details/8914712 关于linux线程 在许多经典的操作系统教科书中, 总是把进程定义为程序的执行实例, 它并不执行什么, 只是维护应用程序所需的各种资源. 而线程则是真正的执行实体. 为了让进程完成一定的工作, 进程必须至少包含一个线程. 如
单片机项目方案医用点滴WIFI远程监控,报警系统
最新发布
09-01
单片机项目方案医用点滴WIFI 远程监控、报警系统提取方式是百度网盘分享地址
单片机项目方案消防报警器,光电感烟探测设计
09-01
单片机项目方案消防报警器，光电感烟探测设计提取方式是百度网盘分享地址
OpenCV 读取 MP4 视频
09-01
OpenCV 读取 MP4 视频
Autotsf-0.0.5-py3-none-any.whl.zip
09-01
Autotsf-0.0.5-py3-none-any.whl.zip
Linux线程取消机制：异步与同步
这篇资源主要探讨的是线程取消机制，这是多线程编程中的一个重要概念，特别是在Linux操作系统环境下。线程取消允许一个线程请求另一个线程提前终止，而不仅仅是通过正常结束（线程函数返回或调用pthread_exit）来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值