如果我们再编译的时候，不链接我们的pthread库

mythread:mythread.ccg++ -o mythread mythread.cc -std=c++11
.PHONY:clean
clean:rm -f mythread

我们语言的底层必须支持原生线程库，不然就会产生下面的报错，语言层面的库其实是对系统的库的封装。

只要我们依旧加上我们的pthread库，就可以正常运行了

mythread:mythread.ccg++ -o mythread mythread.cc -std=c++11  -lpthread
.PHONY:clean
clean:rm -f mythread

六、线程互斥

进程线程间的互斥相关背景概念
临界资源：多线程执行流共享的资源就叫做临界资源
临界区：每个线程内部，访问临界资源的代码，就叫做临界区
互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用
原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成

互斥量mutex
大部分情况，线程使用的数据都是局部变量，变量的地址空间在线程栈空间内，这种情况，变量归属单个线程，其他线程无法获得这种变量。
但有时候，很多变量都需要在线程间共享，这样的变量称为共享变量，可以通过数据的共享，完成线程之间的交互。
多个线程并发的操作共享变量，会带来一些问题。

多线程抢票

#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
//如果多线程访问一个全局变量，并对它进行数据计算，多线程会相互影响吗？
//这里的tickets就是临界资源
int tickets=100;
void *getTickets(void* args)
{(void)args;while(true){if(tickets>0)//1.判断的本质也是计算的一种//把数据读取到寄存器本质上是将数据放入上下文数据当中//{usleep(1000);printf("%p: %d\n",pthread_self(),tickets);tickets--;//2.也可能出现问题}else{break;}}
}
int main()
{pthread_t t1,t2,t3;//多线程抢票的逻辑pthread_create(&t1,nullptr,getTickets,nullptr);pthread_create(&t2,nullptr,getTickets,nullptr);pthread_create(&t3,nullptr,getTickets,nullptr);pthread_join(t1,nullptr);pthread_join(t2,nullptr);pthread_join(t3,nullptr);
}

这里我们观察到了两个100，甚至还有0，-1。
每个线程都有自己的时间片，一个线程可以在自己的时间片内多次抢票。如果我们的线程切换越多，我们的程序就可能会出问题。

如果我们的每一个线程都想要访问我们的共享区当中的tickets，如果要–，我们要完成3个动作。
1.我们将tickets读取到线程的上下文当中
2.进行–
3.写回我们的共享区中。
在这三个命令运行的期间，都可能由于线程的调度，导致我们并没有–，我们的线程就被切换走了。当前的所有数据都会被保存给当前线程，作为我们的线程的上下文，但是我们的数据并没有写回。这期间，别的线程进行–。当我们这个线程又重新运行的时候，上下文的数据会被重新写回去，也就会把别的线程的–给覆盖掉。

因为tickets被访问的时候，没有被保护，所以在并发访问的时候，导致了我们的数据不一致的问题。

也就是说我们执行了上面的1-3部，假如我们的线程1执行了1,2，但是并没有执行3，就被切换掉了，然后我们的线程2开始执行，我们的读取到的数据依旧是100。
如果我们的线程2并没有被打断，并且成功地写回，我们的tickets就会被–，变成99。
假设我们的线程2一直–，成功将tickets变成了50

执行完成之后，如果我们的线程2被切走了，我们的线程1被恢复了，我们的操作系统需要将我们线程1的相关的上下文重新写回内存当中，所以我们的tickets又变成了99这将会导致我们的数据出现错误。

加锁保护

互斥锁 （全局）

pthread_mutex_t

pthread_mutex_t就是原生线程库提供的一个数据类型。

pthread_mutex_lock

pthread_mutex_unlock

#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
using namespace std;  
//如果多线程访问一个全局变量，并对它进行数据计算，多线程会相互影响吗？  
//这里的tickets就是临界资源  
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;//初始化我们的锁  
int tickets=100;  
void *getTickets(void* args)  
{  (void)args;  while(true)  {  //访问临界资源的代码区域：临界区。  //对我们的临界区数据进行加锁  //任何一个时刻，只允许一个线程拿到临界区资源，别的线程进行等待，直到这个线程释放掉这个锁的资源。  pthread_mutex_lock(&mtx);  if(tickets>0)  {  usleep(1000);  printf("%p: %d\n",pthread_self(),tickets);  tickets--;  pthread_mutex_unlock(&mtx);  }else{  pthread_mutex_unlock(&mtx);  break;  }  }  
}  
int main()  
{  pthread_t t1,t2,t3;  //多线程抢票的逻辑  pthread_create(&t1,nullptr,getTickets,nullptr);  pthread_create(&t2,nullptr,getTickets,nullptr);  pthread_create(&t3,nullptr,getTickets,nullptr);  pthread_join(t1,nullptr);  pthread_join(t2,nullptr);  pthread_join(t3,nullptr);  
}

这样我们就解决了我们的抢票问题。

但是我申请锁成功了，别的资源就不能进行访问了，那我们的程序的效率就会降低。

我们可以修改我们的代码，让我们的线程的抢票更加明显

#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
using namespace std;  
//如果多线程访问一个全局变量，并对它进行数据计算，多线程会相互影响吗？  
//这里的tickets就是临界资源  
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;//初始化我们的锁  
int tickets=100000;  
void *getTickets(void* args)  
{  (void)args;  while(true)  {  //访问临界资源的代码区域：临界区。  //对我们的临界区数据进行加锁  //任何一个时刻，只允许一个线程拿到临界区资源，别的线程进行等待，直到这个线程释放掉这个锁的资源。  //加锁的时候，我们需要保证加锁的范围越小越好。pthread_mutex_lock(&mtx);  if(tickets>0)  {  usleep(rand()%1500);  printf("%s: %d\n",args,tickets);  tickets--;  pthread_mutex_unlock(&mtx);  }else{  pthread_mutex_unlock(&mtx);  break;  }  usleep(rand()%200000);  }  
}  
int main()  
{  srand((unsigned long)time(nullptr)^getpid()^0x147);  pthread_t t1,t2,t3;  //多线程抢票的逻辑  pthread_create(&t1,nullptr,getTickets,(void*)"thread 1");  pthread_create(&t2,nullptr,getTickets,(void*)"thread 2");  pthread_create(&t3,nullptr,getTickets,(void*)"thread 3");  pthread_join(t1,nullptr);  pthread_join(t2,nullptr);  pthread_join(t3,nullptr);  
}

互斥锁（局部）

#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
#include  
using namespace std;  
//创建现成的数量  
#define THREAD_NUM 100  class ThreadData  
{  
public:  ThreadData(const std::string &n,pthread_mutex_t *pm): tname(n),pmtx(pm){};  
public:  std::string tname;  pthread_mutex_t *pmtx;  
};  int tickets=10000;  
void *getTickets(void* args)  
{  ThreadData *td=(ThreadData*)args;  while(true)  {  int n=pthread_mutex_lock(td->pmtx);  assert(n==0);  if(tickets>0)  {  usleep(rand()%1500);  printf("%s: %d\n",td->tname.c_str(),tickets);  tickets--;  n=pthread_mutex_unlock(td->pmtx);  assert(n==0);  }else{  n=pthread_mutex_unlock(td->pmtx);  assert(n==0);  break;  }  usleep(rand()%2000);  }  delete td;  return nullptr;  
}  int main()  
{  time_t start=time(nullptr);  pthread_mutex_t mtx;  pthread_mutex_init(&mtx,nullptr);  srand((unsigned long)time(nullptr)^getpid()^0x147);  pthread_t t1,t2,t3;  pthread_t t[THREAD_NUM];  //多线程抢票的逻辑  for(int i=0;i  std::string name="thread";  name+=std::to_string(i+1);  ThreadData *td=new  ThreadData(name,&mtx);  pthread_create(t+i,nullptr,getTickets,(void*)td);  }  //阻塞式地等待所有的线程  for(int i=0;i  pthread_join(t[i],nullptr);  }  time_t end=time(nullptr);  cout<<"cast: "<<(int)(end-start)<