linux线程安全

最新推荐文章于 2024-08-22 17:52:37 发布
最新推荐文章于 2024-08-22 17:52:37 发布
阅读量508 收藏 4
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43692920/article/details/90049327
版权

线程安全：

  1. 多个线程同时对操作临界资源而不会出现数据二义性
  2. 在线程中对临界资源进行了非原子操作

      可重入/不可重入 ：多个执行流同时进入函数中运行而不会出现问题

如何实现线程安全：

  1. 同步：临界资源的合理访问
  2. 互斥：临界资源的同一时间访问

互斥的实现： 

     互斥锁：0/1计数器

                 1表示可以加锁，加锁后-1

                 操作完了之后要解锁，解锁后 +1

                 0表示不可以加锁，不能加锁则等待

     互斥锁的操作步骤：

互斥锁的实现：简单的黄牛抢票

  1. 定义 互斥锁变量：   pthread_mutex_t 
  2. 初始化互斥锁变量：pthread_mutex_init
  3. 加锁 ：                     pthread_mutex_lock
  4. 解锁                          pthread_mutex_unlock
  5. 销毁互斥锁               pthread_mutex_destroy
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>
#include<errno.h>
int ticket=10000;
pthread_mutex_t mutex;
void* thr_start(void* arg){
    while(1){
    //加锁一定要在访问临界资源之前
    //int pthread_mutex_lock(pthread_mutex_t* mutex);
    //阻塞加锁，加不上就阻塞    
    //int pthread_mutex_trylock(pthread_mutex_t* mutex);
    //尝试加锁，加不上锁直接报错返回
    //int pyhread_mutex_timelock(pthread_mutex_t* mutex);
    //限时阻塞加锁
    pthread_mutex_lock(&mutex);
    if(ticket>0){
        sleep(1);
        printf("yellow bull---%d---get a ticket is %d \n",(int)arg,ticket);
        ticket--;
    }else{
        //在任何有可能的地方要解锁
        pthread_mutex_unlock(&mutex);
        pthread_exit(NULL);

    }

    pthread_mutex_unlock(&mutex);

    }
    return NULL;
}
int main(){
    pthread_t tid[4];
    int i=0,ret;
    //int pthread_mutex_init(pthread_t thread,pthread_mutexattr_t* attr);
    //thread:互斥锁变量
    //attr:属性，通常置NULL
    pthread_mutex_init(&mutex,NULL);
    for(i=0;i<4;++i){
        int ret=pthread_create(&tid[i],NULL,thr_start,(void*)i);
        if(ret!=0){
            printf("yellow %d is not exist\n",i);
            return -1;
        }
    }
    for(i=0;i<4;++i){
        //此时不关心返回值 置NULL就可以
        pthread_join(tid[i],NULL);
    }
    //int pthread_mutex_destroy(pthread_mutex_t* mutex );
    //mutex : 互斥锁变量
    pthread_mutex_destroy(&mutex);
    return 0;
}

 

同步的实现：

         临界资源访问的合理性-------生产出来才能使用----等待+唤醒。没有资源一直死等，生产资源出来后唤醒等待

         条件变量：

                        1，定义条件变量：pthread_cond_t;

                        2,初始化条件变量：pthread_cond_init;

                        3,等待/唤醒：         pthread_cond_wait/pthread_cond_signal

                        4,销毁条件变量：  pthread_cond_destroy

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<errno.h>
pthread_cond_t boss;
pthread_cond_t customer;
pthread_mutex_t mutex;
int have_noodle=1;
void* thr_boss(void* arg){
    while(1){
        pthread_mutex_lock(&mutex);
        //若面没有卖出去，则等待
        while(have_noodle==1){
            //int pthread_cond_timedwait(pthread_cond_t* cond,
            //pthread_mutex_t* mutex,struct timespec* abstime);
            //cond :条件变量
            //mutex:互斥锁
            //abstime：显示等待时长，
            //int pthread_cond_wait(pthread_cond_t* cond,pthread_mutex_t* mutex);
            //死等  原子操作不可被打断
            //pthread_cond_wait 中集合了先解锁--唤醒---唤醒后加锁
            //若有面先解锁然后一直等待被人唤醒
            //若被唤醒则唤醒后加锁
            pthread_cond_wait(&boss,&mutex);
        }
        printf("noodle has been complete\n");
        have_noodle+=1;
        //面做好了，唤醒顾客
        pthread_cond_signal(&customer);
        //解锁
        pthread_mutex_unlock(&mutex);
        }
        return NULL;

}
void* thr_customer(void* arg){
    while(1){
        //第一件事情先加锁
        pthread_mutex_lock(&mutex);
        while(have_noodle==0){
                pthread_cond_wait(&customer,&mutex);

        }
    //接下来吃面
    printf("noodle is delicious\n");
    have_noodle-=1;
    //你吃完了就要唤醒老板再做一碗
    pthread_cond_signal(&boss);
    //解锁
    pthread_mutex_unlock(&mutex);
    }

    return NULL;

}
int main(){
    pthread_t tid1,tid2;
    pthread_cond_init(&boss,NULL);
    pthread_cond_init(&customer,NULL);
    pthread_mutex_init(&mutex,NULL);
    int i=0,ret;
    for(i=0;i<2;++i){
        ret=pthread_create(&tid1,NULL,thr_boss,NULL);
        if(ret!=0){
            printf("boss error\n");
            return -1;
        }
    }
    for(i=0;i<2;++i){
        ret=pthread_create(&tid2,NULL,thr_customer,NULL);
        if(ret!=0){
            printf("customer error\n");
            return -1;
        }
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_cond_destroy(&boss);
    pthread_cond_destroy(&customer);
    pthread_mutex_destroy(&mutex);
    return 0;
    }

            信号量：计数器+等待队列+等待+唤醒

                           功能：实现线程/进程间同步与互斥

                           计数器就是判断条件----当计数器只有0/1的时候就实现了互斥

                           等待队列+等待+唤醒实现同步的功能

           system V信号量：信号量原语：p(-1+阻塞)  /  v(+1+唤醒)操作

           prosix信号量：

                          定义：sem_t  信号量变量

                          初始化：sem_init

                          数据操作前资源计数判断：sem wait

                                    计数>0则计数-1，直接返回，往下操作

                                    计数<=0则阻塞等待

                          生产数据后+1          sem_post

                          销毁：       sem_destroy

  1 #include<iostream>
  2 #include<pthread.h>
  3 #include<semaphore.h>
  4 #include<vector>
  5 class RingQueue{
  6     public:
  7     //对信号量初始化
  8     RingQueue(int cap=10):_queue(10),_capacity(cap),_write_step(0),_read_step(0){
  9         //int sem_init(sem_t* sem,int pshared,unsigned int value);
 10         //sem:信号量变量
 11         //pshared:选项标志，决定信号量用于线程间还是进程间的同步与互斥
 12         //        0：线程间
 13         //        !0：进程间
 14         //value: 信号量初始计数
 15         sem_init(&_sem_data,0,0);
 16         sem_init(&_sem_idle,0,cap);
 17         sem_init(&_sem_lock,0,1);
 18     }
 19     //销毁信号量
 20     ~RingQueue(){
 21     //int sem_destroy(sem_t* sem);
 22     sem_destroy(&_sem_data);
 23     sem_destroy(&_sem_idle);
 24     sem_destroy(&_sem_lock);
 25     }
 26     //将用户传进来的数据放到环形队列当中
 27     bool QueuePush(int data){
 28         //首先再放入数据时需要判断是否满足条件
 29         ProductorWait();
 30         //队列操作进行上锁
 31         QueueLock();
 32         //将数据放入队列当中
 33         _queue[_write_step]=data;
 34         //因为是循环队列，所以
 35         _write_step=(_write_step+1) % _capacity;
 36         //在对队列进行解锁
 37         QueueUnLock();
 38         //然后唤醒消费者
 39         ConsumerWakeUp();
 40         return true;
 41     }
 42     bool QueuePop(int* data){
 43         //消费者等待
 44         ConsumerWait();
 45         //上锁
 46         QueueLock();
 47         //读取数据
 48         *data=_queue[_read_step];
 49         //修改当前下标
 50         _read_step=(_read_step+1) % _capacity;
 51         QueueUnLock();
 52         ProductorWakeUp();
 53         return true;
 54     }
 55     private:
 56     void QueueLock(){
 57     //通过计数判断是否有资源可用，如果有计数-1+等待
 58     //int sem_wait(sem_t* sem);
 59     //若计数<=0则阻塞
 60     //int sem_trywait(sem_t* sem);
 61     //若
 62     //计数<=则报错返回
 63     //int sem_timewait(sem_t* sem,struct timespec* abs_timeout);
 64     //若计数<=0则限时等待，超时则报错返回
 65     //通过用信号量计数的方式实现互斥锁 原子操作
 66     sem_wait(&_sem_lock);
 67 
 68     }
 69     void QueueUnLock(){
 70     //计数+1，并唤醒等待
 71     //int sem_post(sem_t* sem);
 72     //计数+1，唤醒互斥锁信号
 73     sem_post(&_sem_lock);
 74 
 75     }
 76     void ProductorWait(){
 77         //当空闲数据<=0时，阻塞等待
 78         sem_wait(&_sem_idle);
 79     }
 80     void ProductorWakeUp(){
 81         //当空闲位置+1时唤醒生产者
 82         sem_post(&_sem_idle);
 83     }
 84     void ConsumerWait(){
 85         //当数据<=0时阻塞等待
 86         sem_wait(&_sem_data);
 87     }
 88     void ConsumerWakeUp(){
 89         //当有数据产生时唤醒消费者
 90         sem_post(&_sem_data);
 91     }
 92     private:
 93     std::vector<int> _queue;
 94     int _capacity;
 95     int _write_step;
 96     int _read_step;
 97     sem_t _sem_data;//数据资源计数
 98     sem_t _sem_idle;//空闲空间计数
 99     sem_t _sem_lock;//实现互斥
100 
101 };
102 //生产者线程入口函数
103 void* thr_productor(void* arg){
104     int i=0;
105     RingQueue* q=(RingQueue*)arg;
106     while(1){
107         q->QueuePush(i);
108         std::cout<<"productor thread put data is "<<i<<std::endl;
109         i++;
110     }
111     return NULL;
112 }
113 //消费者入口函数
114 void* thr_consumer(void* arg){
115     RingQueue* q=(RingQueue*)arg;
116     while(1){
117         int data;
118         q->QueuePop(&data);
119         std::cout<<"consumer thread read data is "<<data<<std::endl;
120     }
121     return NULL;
122 }
123 int main(){
124     pthread_t pro[4],con[4];
125     RingQueue q;
126     int ret,i;
127     for(i=0;i<4;++i){
128         ret=pthread_create(&pro[i],NULL,thr_productor,(void*)&q);
129         if(ret!=0){
130             std::cout<<"thread is error"<<std::endl;
131             return -1;
132         }
133     }
134     for(i=0;i<4;++i){
135         ret=pthread_create(&con[i],NULL,thr_consumer,(void*)&q);
136         if(ret!=0){
137             std::cout<<"thread is error"<<std::endl;
138             return -1;
139         }
140     }
141     for(i=0;i<4;++i){
142         pthread_join(pro[i],NULL);
143     }
144 
145     for(i=0;i<4;++i){
146         pthread_join(con[i],NULL);
147     }
148     return 0;
149 }

线程安全的单例模式

饿汉方式

template <typename T>
class Singleton {
    static T data;
public:
    static T* GetInstance() {
        return &data;
    }
};

懒汉方式

非安全版本

template <typename T>
    class Singleton {
    static T* inst;
public:
    static T* GetInstance() {
        if (inst == NULL) {
            inst = new T();
        }
    return inst;
    }
};

安全版本

/ 懒汉模式, 线程安全
template <typename T>
    class Singleton {
    volatile static T* inst; // 需要设置 volatile 关键字, 否则可能被编译器优化.
    static std::mutex lock;
public:
    static T* GetInstance() {
        if (inst == NULL) { // 双重判定空指针, 降低锁冲突的概率, 提高性能.
            lock.lock(); // 使用互斥锁, 保证多线程情况下也只调用一次 new.
                if (inst == NULL) {
                    inst = new T();
                }
            lock.unlock();
        }
        return inst;
    }
};

STL中的容器是否是线程安全的?

不是.
原因是, STL 的设计初衷是将性能挖掘到极致, 而一旦涉及到加锁保证线程安全, 会对性能造成巨大的影响.
而且对于不同的容器, 加锁方式的不同, 性能可能也不同(例如hash表的锁表和锁桶).
因此 STL 默认不是线程安全. 如果需要在多线程环境下使用, 往往需要调用者自行保证线程安全.

其他常见的锁

  • 悲观锁：在每次取数据时，总是担心数据会被其他线程修改，所以会在取数据前先加锁（读锁，写锁，行锁等），当其他线程想要访问数据时，被阻塞挂起。
  • 乐观锁：每次取数据时候，总是乐观的认为数据不会被其他线程修改，因此不上锁。但是在更新数据前，会判断其他数据在更新前有没有对数据进行修改。主要采用两种方式：版本号机制和CAS操作。
  • CAS操作：当需要更新数据时，判断当前内存值和之前取得的值是否相等。如果相等则用新值更新。若不等则失败，失败则重试，一般是一个自旋的过程，即不断重试

 

 

 

&罗毅
关注
专栏目录
Linux线程安全
天使也有爱
11-18 115
共享数据：可访问的全局变量和堆数据 简单变量（共享数据）：原子操作（原子指令操作） 复杂的数据结构：锁；锁有信号量、互斥量； 一个初值为N的信号量就允许N个线程并发访问，类似资源池 ...
Linux：线程安全
zw_ss
01-26 964
什么是线程安全？ 当我们多线程对临界资源，或者全局变量静态变量，（多线程执行流共享的资源）进行操作时，容易造成的问题。因为在cpu足够的情况下，多个线程的运行也可能是并行的，因此对临界资源的访问，就会造成争抢操作，然而这种争抢操作，会造成数据的二义性问题，因此线程安全，就是讨论如何保证线程对临界资源的安全访问。 解决线程安全问题的方法 同步与互斥操作，同步就是对临界资源访问的时序可控性，互...
Linux —— 线程安全
M的博客
08-08 1592
一、Linux线程互斥1. 进程线程间的互斥相关背景概念1. 临界资源与临界区的理解2. 互斥与原子性的理解2. 互斥量mutex3. 互斥量的接口1. 互斥量初始化2. 互斥量销毁3. 互斥量加锁4. 互斥量解锁5. 互斥量的使用4. 互斥量实现原理探究1. 加锁是如何保证原子性2. 如何保证锁是原子性的二、可重入vs线程安全1. 概念2. 常见的线程不安全的情况3. 常见的线程安全的情4. 常见的不可重入的情况......
Linux：Linux线程安全
最新发布
2302_79054145的博客
08-22 811
因为该执行流第一次申请锁的时候是申请成功的，但第二次申请锁时因为该锁已经被申请过了，于是申请失败导致被挂起直到该锁被释放时才会被唤醒，但是这个锁本来就在自己手上，自己现在处于被挂起的状态根本没有机会释放锁，所以该执行流将永远不会被唤醒，此时该执行流也就处于一种死锁的状态。临界区内的线程完全可能进行线程切换，但即便该线程被切走，其他线程也无法进入临界区进行资源访问，因为此时该线程是拿着锁被切走的，锁没有被释放也就意味着其他线程无法申请到锁，也就无法进入临界区进行资源访问了。由于只有一条指令，保证了原子性。
Linux之线程安全
flyingcloud6的博客
11-24 486
假设一个线程拿到的时间片是200ms，在这个时间片范围内，他会先判断，面人如果当前碗里没有面那么他就continue退出这一次循环，但是这时候还没200ms，所以他就会一直在这里重复这个判断和continue，也可能他在刚加完锁时间片就到了，这时候他退出了，然后做面人来了，但是因为锁是加着的，所以做面人也访问不到碗，那么在这个时间片范围内就是在做无用功，时间白白给浪费掉了。这就是同步要去解决的问题。我们在吃面的生活，不可能我们边吃碗里的面，厨师边往碗里做面，防止这样的事就是互斥的原理，但是还有一个。
Linux 线程安全
qq_61500888的博客
05-07 1050
例如有两个线程访问一块临界区，一个写入数据，另一个读取数据，但负责写入的线程的竞争力特别强，每次都能竞争到锁，那么该线程就一直在执行写入操作直到临界区被写满，此后该线程就一直在进行申请锁和释放锁。当该线程被唤醒时，会接着执行临界区的代码，此时便要求该线程必须立马获得对应的互斥锁，因此当线程被唤醒时会自动获得对应的互斥锁。，当线程进入临界区时需要先加锁，然后判断内部资源的情况，若不满足执行条件，则需要进行等待，但此时该线程是拿着锁被挂起的，也就意味着这个锁不会被释放，此时就会发生死锁问题。
linux 多线程安全定时器
08-16
总结来说，`linux 多线程安全定时器`主要涉及以下知识点： 1. `timerfd`：一种基于文件描述符的定时器，适合与I/O复用机制结合。 2. `epoll`：I/O多路复用技术，用于高效监控多个文件描述符。 3. 多线程安全：在多...
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
linux c 多线程安全日志系统
04-29
在Linux C环境中，多线程安全日志系统是一种常见的需求，尤其在服务器应用程序中，它能够确保在高并发环境下正确地记录系统事件。本项目利用线程锁、信号量和文件操作技术，构建了一个安全的日志系统，同时考虑了...
Linux下的线程安全
weixin_42357849的博客
07-04 277
一、互斥锁
【Linux】线程安全
qq_53893431的博客
11-22 359
Linux线程安全
Linux---线程安全
qq_42708024的博客
02-23 223
线程安全 多个执行流对临界资源进行争抢访问，而不会造成数据二义性或者逻辑混乱。在线程争抢访问的过程是线程安全的。 线程安全的实现 同步：通过条件判断，实现对临界资源访问的时序合理性。 互斥：通过唯一访问，实现对临界资源访问的安全性。 同步与互斥也可以实现进程之间的安全，信号量不但能实现同步，也能实现同步。 互斥的实现原理** 同一时间只有一个执行流能够访问临界资源。 对临界资源进行标记：没人...
Linux——线程安全
qq_44824574的博客
12-06 202
线程安全 概念 线程安全即就是在多线程运行的时候，不论线程的调度顺序怎样，最终的结果都是一样的、正确的，那么就说这些线程是安全的。 要保证线程安全需要做到： 对线程同步，保证同一时刻只有一个线程访问临界资源 在多线程中使用线程安全的函数（可重入函数），所谓线程安全的函数指的是：如果一个函数能被多个线程同时调用且不发生竞态时间，则我们称它是线程安全的。 由于线程是并发运行的，并且一个进程中的线程之间共享地址空间、如果这个多线程的程序运行过程中存在多线程去修改共享的数据时，会造成执行结果的二义性。 多线程修
linux中的线程安全（二）
BuZiShuoquoto的博客
08-02 445
信号量 进化版的互斥锁（1 --> N） 由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。 信号量，是相对折中的一种处理方式，既能保证...
Linux || 线程安全(安全,请放心执行)
Template Code
05-28 258
我的安全怎么保证呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值