死锁

一组进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放资源，而处于一种永久等待的状态

进程一占有资源A不释放，进程二占有资源B不释放，进程一申请资源B，进程二申请资源A，两个进程都属于阻塞状态

形成死锁的条件：

互斥条件：一个资源每次只能被一个执行流使用

请求与保持条件：一个执行流因请求资源而阻塞时，对已获得资源保持不放

不剥夺条件：一个执行流已获得的资源，在未使用完之前，不能强行剥夺

循环等待条件：若干执行流之间形成一种头尾相接的循环等待关系

同步：保证数据安全（实现锁的状态下）的情况下，我们的线程访问有一定顺序性

线程之间的对共享资源的访问有一定的顺序，如线程一发送数据后，发送信号到线程二，线程二再访问获取数据，实现线程一，二这样的访问顺序

其中这个信号叫条件变量决定线程挂起或者访问

在Linux系统中条件变量的接口

pthread_cond_destroy: 销毁变量

pthread_cond_init: 创建临时变量

pthread_cond_broadcast:唤醒所有线程

pthread_cond_signal: 唤醒一个线程

int cnt=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;void* Count(void* args)
{// 无符号整型uint64_t number=(uint64_t)args;pthread_detach(pthread_self()); //进程结束自动脱离不需要等待std::cout<<"thread-"<<number<<"create success"<<std::endl;while(true){pthread_mutex_lock(&mutex); //资源加锁pthread_cond_wait(&cond ,&mutex); // pthread_cond_wait让线程等待时，会自动释放锁！std::cout<<"pthread: "<<number<<" wake "<<", cnt"<<cnt++<<std::endl;pthread_mutex_unlock(&mutex);}
}
int main()
{for( uint64_t i=0;i<5;i++){pthread_t tid;pthread_create(&tid,nullptr, Count,(void*)i);}std::cout<<"main thread ctrl begin: "<<std::endl;while(true) {sleep(1);pthread_cond_signal(&cond);//唤醒在cond等待队列中的一个等待线程，默认是第一个}return 0;
}

上面的代码没有判断而是让代码直接休眠，让主线程唤醒来决定哪个线程代码运行 

实际上可以加入if判断句子

CP 问题（consumer producter）生产者-消费模型

代码实现BlockQueue模型

BlockQueue.hpp

#include<iostream>
#include<queue>
#include<pthread.h>template <class T>
class BlockQueue
{
public:BlockQueue(int defaultcap=50){std::cout<<"Init BlockQueue"<<std::endl;pthread_mutex_init(&mutex_,nullptr);pthread_cond_init(&cond_,nullptr);pthread_cond_init(&pond_,nullptr);maxcap_=50;low_water_=maxcap_/3;high_water_=maxcap_*2/3;}T pop(){pthread_mutex_lock(&mutex_);if(q_.size()==0){// 申请锁成功，发现队列为空了，释放锁,这个线程挂起pthread_cond_wait(&cond_,&mutex_);}// 队列没满T out=q_.front();q_.pop();if(q_.size()<low_water_) pthread_cond_signal(&pond_); //生产满了会自动挂起，此时到了low_water_会把挂起的线程投入生产pthread_mutex_unlock(&mutex_);return out;}void push(const T& in){// std::cout<<"run push function"<<std::endl;//加锁确认只有一个生产者输入pthread_mutex_lock(&mutex_);if(q_.size()==maxcap_){// std::cout<<"线程已满"<<std::endl;// 申请锁成功，发现队列满了，释放锁,这个线程挂起，pthread_cond_wait(&pond_,&mutex_);}// 队列没满// std::cout<<"push value"<<std::endl;q_.push(in);//发送信号，唤醒等待的线程if(q_.size()>high_water_) pthread_cond_signal(&cond_); //当数量较多时，把挂起的消费线程唤醒pthread_mutex_unlock(&mutex_);}~BlockQueue(){pthread_mutex_destroy(&mutex_);pthread_cond_destroy(&cond_);pthread_cond_destroy(&pond_);}
private:std::queue<T> q_; //共享资源int maxcap_;    //极值pthread_mutex_t mutex_; //锁pthread_cond_t cond_; pthread_cond_t pond_;//共享变量int low_water_=0;int high_water_=0;
};

main.cc

#include "BlockQueue.hpp"
#include<unistd.h>
void* Consumer(void*args)
{//consumer获取数据BlockQueue<int> *bq=static_cast<BlockQueue<int>*>(args);while(true){int data=bq->pop();std::cout<<"消费了一个临时变量: "<<data<<std::endl;}
}
void*Productor(void*args)
{// production获取数据// std::cout<<"run function Productor"<<std::endl;BlockQueue<int> *bq=static_cast<BlockQueue<int>*>(args);int data=0;while(true){data++;bq->push(data);std::cout<<"生产一个数据"<<data<<std::endl;}
}
int main()
{BlockQueue<int> *bq=new BlockQueue<int>();pthread_t c,p;// 只有两个线程，一个访问，一个生产pthread_create(&c,nullptr,Consumer,bq);pthread_create(&p,nullptr,Productor,bq);pthread_join(c,nullptr);pthread_join(p,nullptr);delete bq;return 0;
}