Linux线程安全

目录

一.Linux线程互斥

1.1互斥相关概念

 1.2互斥量mutex

1.3互斥量接口

1.4互斥量原理 

二.可重入与线程安全

三.常见锁的概念

四. Linux线程同步

4.1同步概念与竞态条件

4.2条件变量

一.Linux线程互斥

1.1互斥相关概念

临界资源：多线程执行流共享的资源就叫做临界资源

临界区：每个线程内部，访问临界资源的代码，就叫做临界区

互斥：任何时刻，互斥保证有且只有一个执行流进入临界区，访问临界资源，通常对临界资源起保护作用

原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完

成

线程互斥：线程互斥 指的是在多个线程间对临界资源进行争抢访问时有可能会造成数据二义，因此通过保证同一时间只有一个线程能够访问临界资源的方式实现线程对临界资源的访问安全性。 

模拟实现一个抢票系统，定义一个全局变量来表示票的数量，后面主线程创建多个线程进行抢票，查看现象。

代码演示：

#include
using namespace std;
#include
#include
#include
#include
 
int tickets=1000;
void* getTickets(void* args)
{
  string s=(char*)args;
  while(true)
  {
    if(tickets>0)
   {
     usleep(10000);
     cout<" "<<"抢到票了，"<<"票数还剩下："<<--tickets<
   }
   else
   {
     cout<<"票已经完了"<<" "<" "<<"退出了"<
     break;
   }
 }
 return nullptr;
}
int main()
{
  pthread_t tid1;
  pthread_t tid2;
  pthread_t tid3;
  pthread_t tid4;
 
  pthread_create(&tid1,nullptr,getTickets,(void*)"pthread1");
  pthread_create(&tid2,nullptr,getTickets,(void*)"pthread2");
  pthread_create(&tid3,nullptr,getTickets,(void*)"pthread3");
  pthread_create(&tid4,nullptr,getTickets,(void*)"pthread4");
 
    int n = pthread_join(tid1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid4, nullptr);
    cout << n << ":" << strerror(n) << endl;
  return 0;
}

结果：

为何票数会出现负数？ 

原因：变量tickets就是临界资源，因为它被多个执行流同时访，并且tickets--不是原子性的。

--tickets解释

 虽然这是一条语句，但它并不是原子性的。所谓原子性：不会被任何调度机制打断的操作，该操作只有两态，要么完成，要么未完成。

--tickets可以分为三步：

1. load：将共享变量tickets从内存加载到寄存器中。
2. update：更新寄存器里面的值，执行-1操作。
3. store：将新值从寄存器写回共享变量tickets的内存地址。

 但是当它执行到其中任何一步时，该线程都有可能被中断，另外的线程也可以对该变量进行同样的操作。当线程再次被唤醒将自己寄存器的值写入时，可能该tickets已被多个线程进行了--操作，所以会出现问题。

 1.2互斥量mutex

1.3互斥量接口

初始化互斥量函数：pthread_mutex_init

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

 参数解释：

• mutex：需要初始化的互斥量。
• attr：初始化互斥量的属性，一般设置为NULL即可。

调用pthread_mutex_init函数初始化互斥量叫做动态分配，还可以用下面这种方式初始化互斥量，该方式叫做静态分配： 

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

销毁互斥量

销毁互斥量的函数：pthread_mutex_destroy

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数解释：

mutex：需要销毁的互斥量。

补充：

     1.使用PTHREAD_MUTEX_INITIALIZER初始化的互斥量不需要销毁。

     2.不要销毁一个已经加锁的互斥量。

     3.已经销毁的互斥量，要确保后面不会有线程再尝试加锁。

互斥量加锁 

互斥量加锁的函数：pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数解释：

mutex：需要加锁的互斥量

补充：

调用pthread_mutex_lock时，可能会两种情况：

1.互斥量处于未锁状态，该函数会将互斥量锁定，同时返回成功。
2.其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但没有竞争到互斥量，那么pthread_mutex_lock调用会陷入阻塞（执行流被挂起），等待互斥量解锁。

 

 互斥量解锁

互斥量解锁函数：pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数解释：

mutex：需要解锁的互斥量

补充：上面几个函数调用成功返回0，失败反回错误码。

代码演示：

int tickets=1000;
pthread_mutex_t mutex;
 
void* getTickets(void* args)
{
  string s=(char*)args;
  while(true)
  {
    pthread_mutex_lock(&mutex);//加锁
    if(tickets>0)
   {
     usleep(10000);
     cout<" "<<"抢到票了，"<<"票数还剩下："<<--tickets<
    pthread_mutex_unlock(&mutex);//解锁
    usleep(10);//模拟业务处理
   }
   else
   {
     cout<<"票已经完了"<<" "<" "<<"退出了"<
     pthread_mutex_unlock(&mutex);//解锁
     break;
   }
 }
 return nullptr;
}
int main()
{
  pthread_t tid1;
  pthread_t tid2;
  pthread_t tid3;
  pthread_t tid4;
 
  pthread_mutex_init(&mutex,nullptr);//初始化互斥量
 
  pthread_create(&tid1,nullptr,getTickets,(void*)"pthread1");
  pthread_create(&tid2,nullptr,getTickets,(void*)"pthread2");
  pthread_create(&tid3,nullptr,getTickets,(void*)"pthread3");
  pthread_create(&tid4,nullptr,getTickets,(void*)"pthread4");
 
   int n = pthread_join(tid1, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid2, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid3, nullptr);
    cout << n << ":" << strerror(n) << endl;
    n = pthread_join(tid4, nullptr);
    cout << n << ":" << strerror(n) << endl;
  return 0;
}

结果：

1.4互斥量原理 

1.在加锁之后还可以进行线程切换吗？

是可以的，在临界资源对应的临界区中上锁了，临界区还是多行代码，是多行代码就可以被切换。

但是被切换之后的其它线程去访问这块临界资源时会被阻塞挂起，不能对其访问。例如1号线程在切走的时候，绝对不会有其它线程进入临界区。既然不会有其它线程进入临界区，那么其它线程看来，1号线程对该临界区的访问就是原子性的。

2.锁需要被保护吗？

毫无疑问，锁也是被多个执行流竞争的资源， 锁本身就是临界资源。既然是临界资源，那么谁来保护锁呢？

其实锁可以自己保护自己，只需要保证申请锁的过程是原子的，那么锁就是安全的。

为了实现互斥锁操作，大多数体系结构都提供了swap或exchange指令，该指令的作用就是把寄存器和内存单元的数据相交换。由于只有一条指令，保证了原子性，即使是多处理器平台，访问内存的总线周期也有先后，一个处理器上的交换指令执行时，另一个处理器的交换指令只能等待总线周期。

3.如何看待加锁解锁的过程？

看看lock和unlock的伪代码：

我们可以认为mutex的初始值为1，al是计算机中的一个寄存器，开始值为0，当线程申请锁时。

将mutex的值与al中的值进行交换，交换后mutex的值变为了0，后面对该al中的值进行判断，若是1，则该线程申请锁成功，可以进入临界区对临界资源进行访问。若在未解锁之前发生了线程切换，其它线程的也与mutex交换，结果为0，则挂起等待。解锁的过程也是这样，将内存中的mutex置回1，使得下一个申请锁的线程在执行交换指令后能够得到1，唤醒那些因为申请锁失败而被挂起的线程。

二.可重入与线程安全

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);

#include
#include
#include
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* Routine(void* argv)
{
  pthread_detach(pthread_self());
  char* name=(char*)argv;
  printf("%s is running\n",name);
  while(1)
  {
    pthread_cond_wait(&cond, &mutex); //阻塞在这里，直到被唤醒
		printf("%s 在工作\n",name);
 
  }
}
 
int main()
{
  pthread_t tid1,tid2,tid3,tid4,tid5;
  pthread_create(&tid1,NULL,Routine,(void*)"thread1");
  pthread_create(&tid2,NULL,Routine,(void*)"thread2");
  pthread_create(&tid3,NULL,Routine,(void*)"thread3");
  pthread_create(&tid4,NULL,Routine,(void*)"thread4");
  pthread_create(&tid5,NULL,Routine,(void*)"thread5");
  while(1)
  {
    pthread_cond_signal(&cond);
    sleep(1);
  }
  return 0;
}

pthread_mutex_lock(&mutex);
while (条件为假)
	pthread_cond_wait(&cond, &mutex);
修改条件
pthread_mutex_unlock(&mutex);

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);