Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)

文章目录

    • 1.线程同步的重要性(避免线程饥饿问题)
    • 2.线程同步的定义
    • 3.条件变量(pthread_cond_t)
    • 初始化条件变量(pthread_cond_init(pthread.h))
    • 销毁条件变量(pthread_cond_destroy(pthread.h))
    • 等待条件满足(pthread_cond_wait(pthread.h))
    • 唤醒等待线程(pthread_cond_signal(pthread.h))
    • demo1用主线程控制其他线程排队式轮循
    • 4.生产者消费者模型(三种关系,两种角色,一个交易场所)
    • 三种关系
    • 两种角色
    • 一个交易场所
    • demo2基于阻塞队列的单生产者单消费者模型完成计算任务(管道)
    • 5.POSIX信号量(sem_t)
    • 信号量本质(更细粒度的管理临界资源)
    • 信号量的P(申请)V(释放)操作
    • 信号量初始化(sem_init(semaphore.h))
    • 信号量的销毁(sem_destroy(semaphore.h))
    • 等待信号量(sem_wait(semaphore.h)将信号量的值-1P操作)
    • 发布信号量(sem_post(semaphore.h)将信号量的值+1V操作)
    • 二元信号量(信号量的value值为1)
    • demo3利用二元信号模拟互斥锁完成互斥操作(不引入同步)
    • demo4利用POSIX信号量实现无锁的环形单生产者单消费者模型

1.线程同步的重要性(避免线程饥饿问题)

根据线程互斥中可知,为了保护临界资源提出了互斥锁的概念。根据线程互斥中的案例代码可知:单纯加锁也会导致一直是一个线程访问临界资源的问题。
因为线程刚刚将锁释放,这个线程对于锁的竞争比其他线程更强,所以可能存在一个线程使得cout减少到0,这时需要引入同步机制,让每个线程都有机会使得cout-- 。

单纯加锁使个别线程竞争力很强导致其他线程的饥饿问题。

2.线程同步的定义

线程同步:保证在数据安全的前提下(线程互斥),让多执行流访问资源具有一定的顺序性,高效的使用临界资源。

3.条件变量(pthread_cond_t)

条件变量:对临界资源是否就绪的一种数据化描述。
条件变量不保护临界资源,通常要配合mutex锁一起使用

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第1张图片

初始化条件变量(pthread_cond_init(pthread.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第2张图片
两种初始化条件变量的方法
1.调用函数
2.cond=PTHREAD_COND_INITIALIZER初始化
参数解释:
cond:初始化的条件变量
attr:条件变量的属性,一般为空

销毁条件变量(pthread_cond_destroy(pthread.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第3张图片
参数解释:
cond:要销毁的条件变量

等待条件满足(pthread_cond_wait(pthread.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第4张图片
参数解释:
cond:在这个条件变量下等待
mutex:互斥锁
注意:每一次调用这个函数都是从不满足条件开始。

pthread_cond_wait函数需要传递锁的原因:
调用这个函数时这个线程往往是已经申请到锁资源的,在临界区,不能直接挂起,否则会发生死锁。

所以第二个参数的意思是:当因为某些条件不满足时需要等待,调用这个函数时会自动将线程申请到的锁资源释放
如果当前等待线程被唤醒后,这个线程会自动获得mutex锁

唤醒等待线程(pthread_cond_signal(pthread.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第5张图片
参数解释:
cond:在这个条件变量下唤醒

注意:
pthread_cond_signal:唤醒条件变量下的一个线程
pthread_cond_broadcast:唤醒条件变量下的所有线程

demo1用主线程控制其他线程排队式轮循

#include
#include
#include

pthread_mutex_t lock;

pthread_cond_t cond;

void*Run(void*arg)
{
  pthread_detach(pthread_self());
  char*Str=(char*)arg;
  std::cout<<Str<<" Run"<<std::endl;
  while(1)
  {
    pthread_cond_wait(&cond,&lock);//默认不满足条件,线程会阻塞等待条件变量就绪
    std::cout<<Str<<" open tid="<<pthread_self()<<std::endl;
  }
}

int main()
{
  pthread_mutex_init(&lock,nullptr);//初始化锁
  pthread_cond_init(&cond,nullptr);//初始化条件变量
  pthread_t tid1,tid2,tid3;
  pthread_create(&tid1,nullptr,Run,(void*)"tid1");
  pthread_create(&tid2,nullptr,Run,(void*)"tid2");
  pthread_create(&tid3,nullptr,Run,(void*)"tid3");

  while(1)
  {
    getchar();
    pthread_cond_signal(&cond);//唤醒线程
  }

  pthread_mutex_destroy(&lock);
  pthread_cond_destroy(&cond);
  return 0;
}

三个线程进入临界区时调用pthread_cond_wait阻塞,并且等待队列在条件变量中

主线程按下任意键后执行pthread_cond_signal,条件就绪。

条件变量中的等待队列中队列头的线程被唤醒打印,之后循环又调用了pthread_cond_wait阻塞。这个线程被挂到条件变量等待队列末尾。

主线程再按下任意键后执行pthread_cond_signal,条件又一次就绪。这时条件变量中的等待队列中队列头的线程被唤醒打印。依次进行达到主线程排队式控制线程

运行结果
Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第6张图片

4.生产者消费者模型(三种关系,两种角色,一个交易场所)

三种关系

1.生产者和生产者 2.消费者和消费者 3.生产者与消费者

消费者与消费者线程竞争访问资源,是竞争关系(互斥关系,需要用锁保护)

生产者与生产者线程竞争生产资源,也是竞争关系(互斥关系,需要用锁保护)

生产者与消费者线程同样也是竞争关系同时也有同步关系。竞争:生产者与消费者竞争交易场所 同步:先进行生产在进行消费(需要用锁保护和用条件变量保持同步关系)

两种角色

生产者,消费者(指的是特定的进程与线程扮演)

一个交易场所

生产者要将数据生产到交易场所中,消费者处理数据从交易场所中拿取。交易的场所一般是内存中的缓冲区(eg:数组,链表,队列)

生产线程与消费线程通过缓冲区解耦合。支持并发

demo2基于阻塞队列的单生产者单消费者模型完成计算任务(管道)

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第7张图片
Block_Queue.h(阻塞队列)

#pragma once

#include
#include
#include
#define MAX_SIZE 10

template<class T>
class BlockQueue
{
  public:
    BlockQueue(int _cap=MAX_SIZE):Capcity(_cap)
    {
      pthread_mutex_init(&lock,nullptr);
      pthread_cond_init(&full,nullptr);
      pthread_cond_init(&empty,nullptr);
    }

    bool IsFull(){return Queue.size()==Capcity;}

    bool IsEmpty(){return Queue.empty();}

    void PushDate(const T&Val){//生产者调用
      pthread_mutex_lock(&lock);//加锁
      while(IsFull()){//等待消费者消费
        pthread_cond_wait(&full,&lock);
      }
      Queue.push(Val);
      //唤醒消费者线程。
      if(Queue.size()>=Capcity/2){
        std::cout<<"数据充足,唤醒消费者"<<std::endl;
        pthread_cond_signal(&empty);
      }
      pthread_mutex_unlock(&lock);
    }

    void PopDate(T&Out){//消费者调用
      pthread_mutex_lock(&lock);
      while(IsEmpty()){//等待生产者生产
        pthread_cond_wait(&empty,&lock);
      }
      Out=Queue.front();
      Queue.pop();
      //唤醒生产者
      if(Queue.size()<=Capcity/2){
        std::cout<<"数据不足,唤醒生产者"<<std::endl;
        pthread_cond_signal(&full);
      }
      pthread_mutex_unlock(&lock);
    }

    ~BlockQueue(){
      pthread_mutex_destroy(&lock);
      pthread_cond_destroy(&full);
      pthread_cond_destroy(&empty);
    }
  private:
    std::queue<T>Queue;//临界资源
    int Capcity;
    pthread_mutex_t lock;//互斥关系
    pthread_cond_t full;//描述队列满
    pthread_cond_t empty;//描述队列空
};


task.h(任务)

#pragma once

#include

class Task
{
  public:
    Task(){}
    Task(int _x,int _y,int _z):x(_x),y(_y),ch(_z)
  {}
    int Calculate()
    {
      int ret=0;
      switch(ch){
        case '+':
          ret=x+y;
          break;
        case '-':
          ret=x-y;
          break;
        case '/':{
            if(y==0) {
              std::cout<<"erro"<<std::endl;
              ret=-1;
            }
            else {
              ret=x/y;
            }
            break;
          }
        case '*':
          ret=x*y;
          break;
      }
      std::cout<<x<<ch<<y<<"="<<ret<<std::endl;;
      return ret;
    }
  private:
    int x;int y;char ch;
};

model.cpp(主函数)

#include"Block_Queue.h"
#include
#include
#include
#include"task.h"

void*Product(void*arg)
{
  BlockQueue<Task>*Queue=(BlockQueue<Task>*)arg;
  const char*Str="+-*/";
  while(true){
    int x=rand()%100+1;
    int y=rand()%50;
    char ch=Str[rand()%4];
    Task task(x,y,ch);
    Queue->PushDate(task);//生产数据
    std::cout<<"生产数据:"<<std::endl;
  }
}

void*ConSum(void*arg)
{
  BlockQueue<Task>*Queue=(BlockQueue<Task>*)arg;
  while(true){
    Task task;
    Queue->PopDate(task);//取出数据
    std::cout<<"处理数据:"<<std::endl;
    task.Calculate();
    sleep(1);
  }
}


int main()
{
  srand(time(nullptr));
  pthread_t Pro,Con;
  BlockQueue<Task>*buff=new BlockQueue<Task>();
  pthread_create(&Pro,nullptr,Product,(void*)buff);
  pthread_create(&Con,nullptr,ConSum,(void*)buff);
  pthread_join(Pro,nullptr);
  pthread_join(Con,nullptr);
  return 0;
}

注意上述代码中使用while(IsFull())和while(IsEmpty())的原因:
1.防止pthread_cond_wait函数调用失败导致错误。
2.防止单生产者多消费者这种情况下,生产线程生产一个数据后,pthread_cond_broadcast唤醒条件变量下的所有线程,所有线程可能会在队列为空时消费数据导致崩溃。

使用while循环判断条件就绪,当任意线程被唤醒时要重新判断一次唤醒条件是否满足,保证了上面第二种情况不会出现

运行结果
Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第8张图片
阻塞队列体现在:当队列为空时消费线程挂起等待。队列满时生产线程挂起等待。这点与管道类似,管道文件自带同步互斥原理。

5.POSIX信号量(sem_t)

在实现进程间通信使用的是SystemV共享内存,Linux SystemV通信包括:共享内存,消息队列,信号量(SystemV信号量)
Linux_System V进程通信_共享内存

信号量本质(更细粒度的管理临界资源)

信号量的本质是一个计数器,这个计数器描述了临界资源中资源的数目的计数器。

条件变量实现线程同步时并不关心临界资源内的资源数目,其关注临界资源是否符合某种条件

信号量本质是一个临界资源的计数器,是一种更细粒度的临界资源管理方式

信号量的P(申请)V(释放)操作

申请信号量本质:信号量计数器- -,代表资源数减少1 P操作
释放信号量本质:信号量计数器++,代表资源数增加1 V操作

注意:

  • 线程要访问临界资源时首先要申请信号量,所以信号量也是临界资源的一种,所以信号量的PV操作也是原子的(与mutex互斥锁类似)。

所以信号量不仅仅只有计数器。还有保障原子性的mutex互斥锁和与条件变量类似的队列
Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第9张图片
队列链接的是要调度的线程,用双链表的形式组织

信号量初始化(sem_init(semaphore.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第10张图片
参数解释:
sem:要初始化的信号量
pshared:0表示线程间共享,非0表示进程间共享(基本不用)
value:信号量的值(计数器的初始值)

信号量的销毁(sem_destroy(semaphore.h))

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第11张图片
sem:要销毁的信号量

等待信号量(sem_wait(semaphore.h)将信号量的值-1P操作)

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第12张图片

发布信号量(sem_post(semaphore.h)将信号量的值+1V操作)

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第13张图片

二元信号量(信号量的value值为1)

初始化信号量时初始化信号量的值设置为1,这时的信号量为二元信号量,基本等价于互斥锁

demo3利用二元信号模拟互斥锁完成互斥操作(不引入同步)

不引入同步根据上文可知会导致一个线程连续使cout- -类似互斥锁

#include
#include
#include
#include
class Sem//封装信号量
{
  public:
    Sem(int Num)
    {
      sem_init(&sem,0,Num);
    }

    void P()//使计数器--
    {
      sem_wait(&sem);
    }

    void V()//使计数器++
    {
      sem_post(&sem);
    }

    ~Sem()
    {
      sem_destroy(&sem);
    }
  private:
    sem_t sem;
};

Sem sem(1);//二元信号量

int cout=1000;

void*Run(void*arg)
{
  char*Str=(char*)arg;
  while(true)
  {
    sem.P();
    if(cout>0){
      usleep(1000);
      cout--;
      std::cout<<Str<<"make cout-- cout="<<cout<<std::endl;
      sem.V();
    }
    else{
      sem.V();
      break;
    }
  }
  std::cout<<Str<<"quit"<<std::endl;
  pthread_exit((void*)1);
}

int main()
{
  pthread_t tid1,tid2,tid3;
  pthread_create(&tid1,nullptr,Run,(void*)"pthread1");
  pthread_create(&tid2,nullptr,Run,(void*)"pthread2");
  pthread_create(&tid3,nullptr,Run,(void*)"pthread3");

  pthread_join(tid1,nullptr);
  pthread_join(tid2,nullptr);
  pthread_join(tid3,nullptr);
  return 0;
}

运行结果:
Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第14张图片

demo4利用POSIX信号量实现无锁的环形单生产者单消费者模型

Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第15张图片
根据上图可知需要遵守的原则为:

  • 生产者于消费者指向同一个位置时要串行执行,生产者比消费者先执行。当生产者和消费者不指向同一个位置时可以并发执行
  • 当生产者线程追上消费者线程后,生产者线程要等待消费者线程消费。反之也是如此

Ring.h

#pragma once 

#include
#include
#include
#include

#define SIZE 32

template<class T>
class RingQueue
{
  private:
    std::vector<T>q;
    int Cap;

    int b_pos;//只有生产者线程会访问,单生产者不需要保护这个变量,下面也是如此
    int d_pos;

    sem_t block_Num;
    sem_t data_Num;
  private:
    void P(sem_t&s)
    {
      sem_wait(&s);
    }
    void V(sem_t&s)
    {
      sem_post(&s);
    }
  public:
    RingQueue(int cap=SIZE):Cap(cap),b_pos(0),d_pos(0)
    {
      q.resize(Cap);
      sem_init(&block_Num,0,Cap);//开始空间信号量为Cap
      sem_init(&data_Num,0,0);//开始数据信号量为0
    }
    
    void Push(const T&in)//生产数据
    {
      P(block_Num);//关心空间信号量,申请空间信号量,P操作使空间信号量-1
      q[b_pos]=in;
      V(data_Num);//生产者生产了一个数据,数据信号量,V操作使数据信号量+1
      b_pos++;
      b_pos%=Cap;
    }

    void Pop(T&out)
    {
      P(data_Num);//当数据信号量为0时,消费者线程挂起等待,所以一定是生产者线程先运行,消费者线程后运行
      out=q[d_pos];
      V(block_Num);//消费了数据,所以空间信号量V操作使空间信号量+1
      d_pos++;
      d_pos%=Cap;
    }

    ~RingQueue(){
      sem_destroy(&block_Num);
      sem_destroy(&data_Num);
    }
};

main.cpp

#include"Ring.h"
#include
#include

void*Consumer(void*arg)
{
  RingQueue<int>*rq=(RingQueue<int>*)arg;
  while(true)
  {
    sleep(2);
    int x=0;
    rq->Pop(x);
    std::cout<<"Consumer End Num="<<x<<std::endl;

  }
}

void*Product(void*arg)
{
  RingQueue<int>*rq=(RingQueue<int>*)arg;
  while(true)
  {
    sleep(1);
    int Num=rand()%100+1;
    rq->Push(Num);
    std::cout<<"Product End Num="<<Num<<std::endl;
  }
}

int main()
{
  srand((unsigned int)time(nullptr));
  RingQueue<int>*rq=new RingQueue<int>();
  pthread_t c_tid,p_tid;
  pthread_create(&c_tid,nullptr,Consumer,rq);
  pthread_create(&p_tid,nullptr,Product,rq);

  pthread_join(c_tid,nullptr);
  pthread_join(p_tid,nullptr);
  return 0;
}

运行结果:
Linux_线程同步(条件变量(pthread_cond_t)实现线程同步_POSIX信号量sem_t实现线程同步互斥_生产者消费者模型(三种关系,两种角色,一个交易场所)阻塞队列模型_环形队列模型)_第16张图片
当队列满时,空间信号量为0,生产者线程挂起。当队列为空时,数据信号量为0,消费者线程挂起。所以不会发生数据的冲突覆盖

你可能感兴趣的:(Linux,linux,运维,服务器)