Linux C++多线程同步的四种方式（非常详细）

一.互斥锁

本质就是一个特殊的全局变量，拥有lock和unlock两种状态，unlock的互斥锁可以由某个线程获得，一旦获得，这个互斥锁会锁上变成lock状态，此后只有该线程由权力打开该锁，其他线程想要获得互斥锁，必须得到互斥锁再次被打开之后

采用互斥锁来同步资源:

#include <iostream>
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>

using namespace std;

int ticket_sum=20;
pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

void *sell_ticket(void *arg)
{
    for(int i=0; i<20; i++)
    {
        pthread_mutex_lock(&mutex_x);//atomic opreation through mutex lock
        if(ticket_sum>0)
        {
            sleep(1);
            cout<<"sell the "<<20-ticket_sum+1<<"th"<<endl;
            ticket_sum--;
        }
        pthread_mutex_unlock(&mutex_x);
    }
    return 0;
}

int main()
{
    int flag;
    pthread_t tids[4];

    for(int i=0; i<4; i++)
    {
        flag=pthread_create(&tids[i],NULL,&sell_ticket,NULL);
        if(flag)
        {
            cout<<"pthread create error ,flag="<<flag<<endl;
            return flag;
        }
    }

    sleep(20);
    void *ans;
    for(int i=0; i<4; i++)
    {
        flag=pthread_join(tids[i],&ans);
        if(flag)
        {
            cout<<"tid="<<tids[i]<<"join erro flag="<<flag<<endl;
            return flag;
        }
        cout<<"ans="<<ans<<endl;
    }
    return 0;
}

分析：通过为售票的核心代码段加互斥锁使得其变成了一个原子性操作！不会被其他线程影响

1.互斥锁的初始化

互斥锁的初始化分为静态初始化和动态初始化

静态：pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

动态：pthread_mutex_init函数

ps：互斥锁静态初始化和动态初始化的区别？

待补充。。。。

2.互斥锁的相关属性及分类

//初始化互斥锁属性
pthread_mutexattr_init(pthread_mutexattr_t attr);

//销毁互斥锁属性
pthread_mutexattr_destroy(pthread_mutexattr_t attr);

//用于获取互斥锁属性
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr , int *restrict pshared);

//用于设置互斥锁属性
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr , int pshared);

attr表示互斥锁的属性

pshared表示互斥锁的共享属性，由两种取值：

1）PTHREAD_PROCESS_PRIVATE：锁只能用于一个进程内部的两个线程进行互斥（默认情况）

2）PTHREAD_PROCESS_SHARED：锁可用于两个不同进程中的线程进行互斥，使用时还需要在进程共享内存中分配互斥锁，然后为该互斥锁指定属性就可以了

互斥锁的分类：

//获取互斥锁类型
int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr , int *restrict type);

//设置互斥锁类型
int pthread_mutexattr_settype(const pthread_mutexattr_t *restrict attr , int type);

参数type表示互斥锁的类型，总共有以下四种类型：

1.PTHREAD_MUTEX_NOMAL:标准互斥锁，第一次上锁成功，第二次上锁会失败并阻塞

2.PTHREAD_MUTEX_RECURSIVE:递归互斥锁，第一次上锁成功，第二次上锁还是会成功，可以理解为内部有一个计数器，每加一次锁计数器加1，解锁减1

3.PTHREAD_MUTEX_ERRORCHECK:检查互斥锁，第一次上锁会成功，第二次上锁出错返回错误信息，不会阻塞

4.PTHREAD_MUTEX_DEFAULT:默认互斥锁，第一次上锁会成功，第二次上锁会失败

3，测试加锁函数

int pthread_mutex_lock(&mutex):测试加锁函数在锁已经被占据时返回EBUSY而不是挂起等待，当然，如果锁没有被占领的话可以获得锁

为了清楚的看到两个线程争用资源的情况，我们使得其中一个函数使用测试加锁函数进行加锁，而另外一个使用正常的加锁函数进行加锁

#include <iostream>
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
using namespace std;

int ticket_sum=20;
pthread_mutex_t mutex_x=PTHREAD_MUTEX_INITIALIZER;//static init mutex

void *sell_ticket_1(void *arg)
{
    for(int i=0; i<20; i++)
    {
        pthread_mutex_lock(&mutex_x);
        if(ticket_sum>0)
        {
            sleep(1);
            cout<<"thread_1 sell the "<<20-ticket_sum+1<<"th ticket"<<endl;
            ticket_sum--;
        }
        sleep(1);
        pthread_mutex_unlock(&mutex_x);
        sleep(1);
    }
    return 0;
}

void *sell_ticket_2(void *arg)
{
    int flag;
    for(int i=0; i<10; i++)
    {
        flag=pthread_mutex_trylock(&mutex_x);
        if(flag==EBUSY)
        {
            cout<<"sell_ticket_2:the variable is locked by sell_ticket_1"<<endl;
        }
        else if(flag==0)
        {
            if(ticket_sum>0)
            {
                sleep(1);
                cout<<"thread_2 sell the "<<20-ticket_sum+1<<"th tickets"<<endl;
                ticket_sum--;
            }
            pthread_mutex_unlock(&mutex_x);
        }
        sleep(1);
    }
    return 0;
}
int main()
{
    int flag;
    pthread_t tids[2];

    flag=pthread_create(&tids[0],NULL,&sell_ticket_1,NULL);
    if(flag)
    {
        cout<<"pthread create error ,flag="<<flag<<endl;
        return flag;
    }

    flag=pthread_create(&tids[1],NULL,&sell_ticket_2,NULL);
    if(flag)
    {
        cout<<"pthread create error ,flag="<<flag<<endl;

        return flag;
    }

    void *ans;
    sleep(30);
    flag=pthread_join(tids[0],&ans);
    if(flag)
    {
        cout<<"tid="<<tids[0]<<"join erro flag="<<flag<<endl;
        return flag;
    }
    else
    {
        cout<<"ans="<<ans<<endl;
    }

    flag=pthread_join(tids[1],&ans);
    if(flag)
    {
        cout<<"tid="<<tids[1]<<"join erro flag="<<flag<<endl;
        return flag;
    }
    else
    {
        cout<<"ans="<<ans<<endl;
    }

    return 0;
}

分析：通过测试加锁函数我们可以清晰的看到两个线程争用资源的情况

二.条件变量

互斥量不是万能的，比如某个线程正在等待共享数据内某个条件出现，可可能需要重复对数据对象加锁和解锁（轮询），但是这样轮询非常耗费时间和资源，而且效率非常低，所以互斥锁不太适合这种情况

我们需要这样一种方法：当线程在等待满足某些条件时使线程进入睡眠状态，一旦条件满足，就换线因等待满足特定条件而睡眠的线程

如果我们能够实现这样一种方法，程序的效率无疑会大大提高，而这种方法正是条件变量！

样例：

#include <iostream>
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>
using namespace std;

pthread_cond_t qready=PTHREAD_COND_INITIALIZER;   //cond
pthread_mutex_t qlock=PTHREAD_MUTEX_INITIALIZER;  //mutex

int x=10,y=20;

void *f1(void *arg)
{
  cout<<"f1 start"<<endl;
  pthread_mutex_lock(&qlock);
  while(x<y)
  {
    pthread_cond_wait(&qready,&qlock);
  }
  pthread_mutex_unlock(&qlock);
  sleep(3);
  cout<<"f1 end"<<endl;
  return 0;
}

void *f2(void *arg)
{
  cout<<"f2 start"<<endl;
  pthread_mutex_lock(&qlock);
  x=20;
  y=10;
  cout<<"has a change,x="<<x<<" y="<<y<<endl;
  pthread_mutex_unlock(&qlock);
  if(x>y)
  {
    pthread_cond_signal(&qready);
  }
  cout<<"f2 end"<<endl;
  return 0;
}

int main()
{
  pthread_t tids[2];
  int flag;

  flag=pthread_create(&tids[0],NULL,f1,NULL);
  if(flag)
  {
    cout<<"pthread 1 create error "<<endl;
    return flag;
  }

  sleep(2);

  flag=pthread_create(&tids[1],NULL,f2,NULL);
  if(flag)
  {
    cout<<"pthread 2 create erro "<<endl;
    return flag;
  }

  sleep(5);
  return 0;
}