【计算】锁机制初探

zonyee
370 阅读10分钟

1. 锁机制总览

由于多线程之间是并发执行的，而系统调度又是随机的，因此在写多线程程序时会出现很多问题，这时就免不了要用到各种锁机制来保证线程安全且按我们的意愿正确执行。

2 常用锁

常见的锁有如下几类：

  • 互斥锁
  • 读写锁
  • 自旋锁

2.1 互斥锁

互斥锁用于控制多个线程对它们之间共享资源互斥访问的一个信号量。也就是说是为了避免多个线程在某一时刻同时操作一个共享资源。例如线程池中的有多个空闲线程和一个任务队列。任何一个线程都要使用互斥锁互斥访问任务队列，以避免多个线程同时访问任务队列以发生错乱。
在某一时刻，只有一个线程可以获取互斥锁，在释放互斥锁之前其他线程都不能获取该互斥锁。如果其他线程想要获取这个互斥锁，那么这个线程只能以阻塞方式进行等待。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;
int piaopiao=10;
pthread_mutex_t mutex;

void *ticket(void* arg)
{
  char* str=static_cast<char*>(arg);
  while(1)
  {
    pthread_mutex_lock(&mutex);
    if(piaopiao<=0)
    {
      pthread_mutex_unlock(&mutex);
      break;
    }
    piaopiao--;
    cout<<str<<"sale:"<<piaopiao+1<<endl;
    pthread_mutex_unlock(&mutex);
    usleep(10000);
  }
}

int main()
{
  pthread_t t1,t2,t3,t4;
  pthread_mutex_init(&mutex,NULL);
  pthread_create(&t1,NULL,ticket,(void*)"pthread t1");
  pthread_create(&t2,NULL,ticket,(void*)"pthread t2");
  pthread_create(&t3,NULL,ticket,(void*)"pthread t3");
  pthread_create(&t4,NULL,ticket,(void*)"pthread t4");

  pthread_join(t1,NULL);
  pthread_join(t2,NULL);
  pthread_join(t3,NULL);
  pthread_join(t4,NULL);
  pthread_mutex_destroy(&mutex);
}

2.2 读写锁

读共享，读写互斥，读优先级高；应用于大量读进程，少量写进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
int count=0;
pthread_rwlock_t rwlock;
void* route_read(void *arg)
{
    int i=*(int *)arg;
    free(arg);
    while(1)
    {
        pthread_rwlock_rdlock(&rwlock);
        printf("%d read %d\n",i,count);
        pthread_rwlock_unlock(&rwlock);
        usleep(1000);
    }
}
void* route_write(void *arg)
{
    int i=*(int *)arg;
    free(arg);
    while(1)
    {
        pthread_rwlock_wrlock(&rwlock);
        printf("%d write %d\n",i,++count);
        pthread_rwlock_unlock(&rwlock);
        usleep(1000);
    }
}

int main()
{
    pthread_t id[8];
    int i=0;
    pthread_rwlock_init(&rwlock,NULL);
    for(i=0;i<5;i++)
    {
        int *p=(int *)malloc(sizeof(int));
        *p=i;
        pthread_create(&id[i],NULL,route_read,(void *)p);
    }
    for(i=5;i<8;i++)
    {
        int *p=(int *)malloc(sizeof(int));
        *p=i;
        pthread_create(&id[i],NULL,route_write,(void *)p);
    }

    for(i=0;i<8;i++)
    {
        pthread_join(id[i],NULL);
    }
    pthread_rwlock_destroy(&rwlock);
}

2.3 自旋锁

一般用于实时性较高的场合。Linux的的内核最常见的锁是自旋锁。
自旋锁最多只能被一个可执行线程持有。如果一个执行线程试图获得一个被已经持有（争用）的自旋锁，那么该线程就会一直进行忙循环-旋转-等待锁重新可用。要是锁未被争用，请求锁的执行线程就可以立即得到它，继续执行。

假设我们有一个两个处理器core1和core2计算机，现在在这台计算机上运行的程序中有两个线程：T1和T2分别在处理器core1和core2上运行，两个线程之间共享着一个资源。
首先我们说明互斥锁的工作原理，互斥锁是是一种sleep-waiting的锁。假设线程T1获取互斥锁并且正在core1上运行时，此时线程T2也想要获取互斥锁（pthread_mutex_lock），但是由于T1正在使用互斥锁使得T2被阻塞。当T2处于阻塞状态时，T2被放入到等待队列中去，处理器core2会去处理其他任务而不必一直等待（忙等）。也就是说处理器不会因为线程阻塞而空闲着，它去处理其他事务去了。
而自旋锁就不同了，自旋锁是一种busy-waiting的锁。也就是说，如果T1正在使用自旋锁，而T2也去申请这个自旋锁，此时T2肯定得不到这个自旋锁。与互斥锁相反的是，此时运行T2的处理器core2会一直不断地循环检查锁是否可用（自旋锁请求），直到获取到这个自旋锁为止。
从“自旋锁”的名字也可以看出来，如果一个线程想要获取一个被使用的自旋锁，那么它会一直占用CPU请求这个自旋锁使得CPU不能去做其他的事情，直到获取这个锁为止，这就是“自旋”的含义。
当发生阻塞时，互斥锁可以让CPU去处理其他的任务；而自旋锁让CPU一直不断循环请求获取这个锁。通过两个含义的对比可以我们知道“自旋锁”是比较耗费CPU的。

pthread_spin_t spin;
pthread_spin_init();
pthread_spin_lock();//得不到，忙等待busyloop，一直占用cpu；而互斥锁在得不到时会挂起等待，让出CPU
pthread_spin_unlock();
pthread_spin_destroy();

3. 锁属性

3.1 悲观锁 与 乐观锁

悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量。

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

3.1.2 乐观锁的实现方式

乐观锁一般会使用版本号机制或CAS算法实现。

3.1.2.1 版本号机制

一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取version值，在提交更新时，若刚才读取到的version值为当前数据库中的version值相等时才更新，否则重试更新操作，直到更新成功。

举一个简单的例子：
假设数据库中帐户信息表中有一个 version 字段，当前值为 1；而当前帐户余额字段（ balance ）为 $100 。当需要对账户信息表进行更新的时候，需要首先读取version字段。

  1. 操作员 A 此时将其读出（ version=1 ），并从其帐户余额中扣除 $50（ $100-$50 ）。
  2. 在操作员 A 操作的过程中，操作员B 也读入此用户信息（ version=1 ），并从其帐户余额中扣除 $20 （ $100-$20 ）。
  3. 操作员 A 完成了修改工作，提交更新之前会先看数据库的版本和自己读取到的版本是否一致，一致的话，就会将数据版本号加1（ version=2 ），连同帐户扣除后余额（ balance=$50 ），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。
  4. 操作员 B 完成了操作，提交更新之前会先看数据库的版本和自己读取到的版本是否一致，但此时比对数据库记录版本时发现，操作员B提交的数据版本号为2，而自己读取到的版本号为1，不满足“当前最后更新的version与操作员第一次读取的版本号相等“的乐观锁策略，因此，操作员B的提交被驳回。这样，就避免了操作员 B 用基于version=1的旧数据修改的结果覆盖操作员A的操作结果的可能。

3.1.2.2 CAP算法

即compare and swap（比较与交换），是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blockingSynchronization）。 CAS算法的过程是这样：它包含三个参数CAS(V,E,N):
V表示要更新的变量，E表示预期值，N表示新值。仅当V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS返回当前V的真实值。例子：
（1）从内存中读取value值，假设为10，称之为A
（2）B=A+1，得到B=11
（3）用A的值和内存的值相比，如果相等（过去的一段时间内，没人修改过A），就把B写入内存，如果不相等的，说明A在这段时间内被修改了，就放弃这次修改，返回第一步。

CAP算法存在如下缺陷：

  1. ABA 问题 如果一个变量V初次读取的时候是A值，并且在准备赋值的时候检查到它仍然是A值，那我们就能说明它的值没有被其他线程修改过了吗？很明显是不能的，因为在这段时间它的值可能被改为其他值，然后又改回A，那CAS操作就会误认为它从来没有被修改过。这个问题被称为CAS操作的 "ABA"问题。 通过给每次修改增加一个版本号机制可以解决ABA问题。

  2. 循环时间长开销大 自旋CAS（也就是不成功就一直循环执行直到成功）如果长时间不成功，会给CPU带来非常大的执行开销。

  3. 只能保证一个共享变量的原子操作 CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。

3.1 公平锁 与 非公平锁

公平锁
是指多个线程按照申请锁的顺序来获取锁。

非公平锁
是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获锁。非公平锁一上来就尝试占用锁，如果尝试占用失败，就采用公平锁的方式到末尾排队。在高并发的情况下，有可能造成优先级反转或饥饿现象。非公平锁的优点在于吞吐量比公平锁大。

我们可以看到公平锁就是在获取锁之前会先判断等待队列是否为空或者自己是否位于队列头部，该条件通过才能继续获取锁。在结合兔子喝水的图分析，非公平锁获取所得顺序基本决定在9、10、11这三个事件发生的先后顺序。

  1. 若在释放锁的时候总是没有新的兔子来打扰，则非公平锁等于公平锁；
  2. 若释放锁的时候，正好一个兔子来喝水，而此时位于队列头的兔子还没有被唤醒（因为线程上下文切换是需要不少开销的），此时后来的兔子则优先获得锁，成功打破公平，成为非公平锁。

其实对于非公平锁，只要线程进入了等待队列，队列里面依然是FIFO的原则，跟公平锁的顺序是一样的。

avatar
文章
阅读
粉丝