前言
提示：以下是本篇文章正文内容，下面案例可供参考
一、线程互斥
（1）互斥：
任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
要了解互斥需要了解以下的概念
1.临界资源：多线程执行流共享的资源就叫做临界资源,比如全局变量
2.临界区：每个线程内部，访问临界资源的代码，就叫做临界区
原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成
怎么理解呢，例如 i++,i--实际上是分两步，i++等于i=i+1
计算机从内存读取i在cpu寄存器计算之后在写回内存，这个过程被编译成汇编指令有很多条，不可以一步完成，这不是原子性的；要保证原子性，可以理解为完成这个过程，只有一条汇编指令。
(2) 多线程抢票
多个线程对全局变量ticket进行抢票，ticket是临界区资源，访问临界区资源的代码是临界区.
我们创建10个线程进行抢票，执行抢票代码.
void route(ThreadDate* td)
{//模拟抢票
while(true)
{ // LockGuard mutex(td->_mutex);if(td->_tickets>0){usleep(1000);cout<<"thread name:"<<td->_name<<"....."<<"ticket:"<<td->_tickets<<"....."<<"total:"<<td->_total<<endl;td->_tickets--;td->_total++;}else{break;}}
}
int ticket=1000;
我们发现票数被多抢了，ticket是-1，为什么会是这样的结果呢？
因为我们对临界资源没进行保护，线程调度时间片到了，就会切换其他在等待的 线程进行调度。如果这时内存中ticket已经为1，恰好2个线程判断ticket为1，进入抢票。线程1把票抢了，内存中ticket变为0，这时又调度了线程1，进行执行剩下代码，这从内存读取就是0，在执行ticket---。就变成了-1.
解决方法就是加一把锁，把访问临界资源的代码保护起来，只让拥有锁的线程执行这段涉及临界区资源的代码。持有锁的线程，就算调度了其他的线程，没有锁也没法访问资源，等到拥有锁的线程被调度访问资源就解锁，在让下一个线程持有锁，访问资源。。。
void route(ThreadDate* td)
{//模拟抢票
while(true)
{ LockGuard mutex(td->_mutex);//加锁，这里我们封装了锁，出了作用域，执行析构就解锁了。if(td->_tickets>0){usleep(1000);cout<<"thread name:"<<td->_name<<"....."<<"ticket:"<<td->_tickets<<"....."<<"total:"<<td->_total<<endl;td->_tickets--;td->_total++;}else{break;}}LockGuard.hpp
#include<iostream>class LockGuard{
public:
LockGuard(pthread_mutex_t* mutex)
:_mutex(mutex)
{pthread_mutex_lock(_mutex);//申请锁
}
~LockGuard()
{pthread_mutex_unlock(_mutex);//解锁
}
private:
pthread_mutex_t* _mutex;
};
二.加锁和解锁
1.全局锁和局部锁
（1）申请全局锁并且初始化锁：pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
（2）局部锁：
申请：ptread_mutex_t gmutex;
初始化：pthread_mutex_init(&mutex, nullptr);
2.锁的原理
为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性。
交换的本质不是把内存中mutex值拷贝到寄存器，而是通过一条汇编指令，交换寄存器和mutex的值，这个过程只有一条指令，所有线程看到的mutex只有一个，举例：线程1申请了锁，汇编指令直接将寄存器值和内存中mutex交换，由于进程的切换时随机的，cpu寄存器的硬件只有一套，这时候将上下文数据保存了，线程带走了寄存器的数据，其他线程被调度发现寄存器不是1，就挂起等待。等到线程1再被调度，把它的上下文数据还原包括寄存器值，直到线程1访问完资源，把寄存器值和内存中变量mutex值通过一条指令交换，就完成解锁操作，这个过程是原子性。
锁可以解决线程安全问题，容易造成线程饥饿，比如有一个线程一申请到锁访问资源解锁之后，又申请到了锁，其他线程申请不到。
三.条件变量
例子：放苹果和拿苹果
多线程中光有互斥会有饥饿问题，有了条件变量可以避免无效的申请锁的操作，同时保证了执行的一定顺序性。比如如果没有铃铛，那么拿苹果（访问资源）的线程就会一直申请，导致放苹果的线程一直饥饿，操作无效（cpu资源浪费），有资源了，就会敲响铃铛（条件就绪），唤醒队列前面的线程，访问资源。访问完就去队列排队，不会让这个线程一直拿苹果，导致其他线程饥饿问题。
所以，条件变量=铃铛+队列
条件变量的操作：
全局：
局部：
如果我们申请了局部的必须初始化它，最后不要了，也要释放它
1.初始化
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict
attr);参数： cond：要初始化的条件变量attr：NULL
2.等待
这个函数的作用是，如果线程处于等待，它会释放所拥有的锁，让其他线程竞争，当被唤醒时，这个线程会再去竞争锁，如果竞争锁成功，函数返回，继续执行。没有竞争锁成功就一直等待
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
参数： cond：要在这个条件变量上等待mutex：
3.唤醒等待：唤醒一个/唤醒一批
int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒所有等待的线程
int pthread_cond_signal(pthread_cond_t *cond)//唤醒一个等待的线程
4.销毁
如果我们定义了局部的条件变量，最后要释放。
int pthread_cond_destroy(pthread_cond_t *cond)
（1）通过条件变量可以让一个线程可控制另一个线程
#include<iostream>
#include<pthread.h>
#include<vector>
#include<string>
#include<unistd.h>//全局的条件变量
pthread_cond_t gcond=PTHREAD_COND_INITIALIZER;
//全局锁
pthread_mutex_t gmutex=PTHREAD_MUTEX_INITIALIZER;void* MasterCore(void* argv)
{std::string name=static_cast<const char*>(argv);while(true){sleep(3);std::cout<<"Master working....."<<std::endl;pthread_cond_signal(&gcond);//std::cout<<name<<std::endl;// sleep(1);}}
void* SlaverCore(void* argv)
{std::string name=static_cast<const char*>(argv);while(true){//加锁pthread_mutex_lock(&gmutex);// std::cout<<name<<std::endl;//唤醒某个线程pthread_cond_wait(&gcond,&gmutex);//唤醒所有等待的线程//pthread_cond_broadcast(&gcond);sleep(1);std::cout<<"当前被唤醒的线程是："<<name<<std::endl;pthread_mutex_unlock(&gmutex);}}
void StartMaster(std::vector<pthread_t>* td)
{pthread_t tid;int n=pthread_create(&tid,nullptr,MasterCore,(void*)"Master Thread");if(n==0){std::cout<<"Materthread create sucess"<<std::endl;}td->emplace_back(tid);
}void StartSlaver(std::vector<pthread_t>* td,int num=6)
{for(int i=0;i<num;i++){char* name=new char[64];snprintf(name,64,"thread_%d",i+1);pthread_t tid;int n=pthread_create(&tid,nullptr,SlaverCore,(void*)name);if(n==0){std::cout<<name<<":create sucess"<<std::endl;}td->emplace_back(tid);}
}void WaiteThread(std::vector<pthread_t>& td)
{for(auto& e:td){pthread_join(e,nullptr);}}
int main()
{std::vector<pthread_t> tids;
StartMaster(&tids);
StartSlaver(&tids);
WaiteThread(tids);return 0;
} 
![[论文笔记]Mistral 7B](https://img-blog.csdnimg.cn/img_convert/dcb696bb82e2282965055499ff7679a6.png)
