---

前言

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、线程互斥

（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;
}