锁总结

「爱情、让人受尽委屈。」 2022-05-19 07:42 116阅读 0赞

## 条件变量 ##

**原理 **

条件变量将允许你实现这样的目的：在一种情况下令线程继续运行，而相反情况下令线程阻塞。只要每个可能涉及到改变状态的线程正确使用条件变量，Linux 将保证当条件改变的时候由于一个条件变量的状态被阻塞的线程均能够被激活。

GNU/Linux 刚好提供了这个机制，每个条件变量都必须与一个互斥体共同使用，以防止这种竞争状态的发生。这种设计下，线程函数应遵循以下步骤：

1.   thread\_function中的循环首先锁定互斥体并且读取标志变量的值。 
2.    如果标志变量已经被设定，该线程将互斥体解锁然后执行工作函数
3.    如果标志没有被设置，该线程自动锁定互斥体并开始等待条件变量的信号

这里最关键的特点就在第三条。这里，GNU/Linux系统允许你用一个原子操作完成解除互斥体锁定和等待条件变量信号的过程而不会被其它线程在中途插入执行。这就避免了在thread\_function中检测标志和等待条件变量的过程中其它线程修改标志变量并对条件变量发送信号的可能性。

函数传入的参数mutex用于保护条件，因为我们在调用pthread\_cond\_wait时，如果条件不成立我们就进入阻塞，但是进入阻塞这个期间，如果条件变量改变了的话，那我们就漏掉了这个条件。因为这个线程还没有放到等待队列上，所以调用pthread\_cond\_wait前要先锁互斥量，即调用pthread\_mutex\_lock(),**pthread\_cond\_wait在把线程放进阻塞队列后，自动对mutex进行解锁，**使得其它线程可以获得加锁的权利。这样其它线程才能对临界资源进行访问并在适当的时候唤醒这个阻塞的进程。**当pthread\_cond\_wait返回的时候又自动给mutex加锁**。  
实际上边代码的加解锁过程如下：  
  
pthread\_mutex\_lock(&qlock);     
pthread\_cond\_wait(&qready, &qlock);  
pthread\_mutex\_unlock(&qlock);

**使用**

pthread\_cond\_timedwait()函数阻塞住调用该函数的线程，等待由cond指定的条件被触发（pthread\_cond\_broadcast() or pthread\_cond\_signal()）。

当pthread\_cond\_timedwait()被调用时，调用线程必须已经锁住了mutex。函数pthread\_cond\_timedwait()会对mutex进行【解锁和执行对条件的等待】（原子操作）。这里的原子意味着：解锁和执行条件的等待是原则的，一体的。（In this case, atomically means with respect to the mutex and the condition variable and other access by threads to those objects through the pthread condition variable interfaces.）

如果等待条件满足或超时，或线程被取消，调用线程需要在线程继续执行前先自动锁住mutex，如果没有锁住mutex，产生EPERM错误。即，该函数返回时，mutex已经被调用线程锁住。

等待的时间通过abstime参数（绝对系统时间，过了该时刻就超时）指定，超时则返回ETIMEDOUT错误码。开始等待后，等待时间不受系统时钟改变的影响。

尽管时间通过秒和纳秒指定，系统时间是毫秒粒度的。需要根据调度和优先级原因，设置的时间长度应该比预想的时间要多或者少点。可以通过使用系统时钟接口gettimeofday()获得timeval结构体。

多线程编程中，线程A循环计算，然后sleep一会接着计算（目的是减少CPU利用率）；存在的问题是，如果要关闭程序，通常选择join线程A等待线程A退出，可是我们必须等到sleep函数返回，该线程A才能正常退出，这无疑减慢了程序退出的速度。当然，你可以terminate线程A，但这样做很不优雅，且会存在一些未知问题。采用[pthread\_cond\_timedwait][pthread_cond_timedwait](pthread\_cond\_t \* cond, pthread\_mutex\_t \*mutex, const struct timespec \* abstime)可以优雅的解决该问题，设置等待条件变量cond，如果超时，则返回；如果等待到条件变量cond，也返回。本文暂不将内部机理，仅演示一个demo

static unsigned char flag = 1;
    
    void * thr_fn(void * arg)
    
    {
    
    while (flag)
    
    {
    
    printf(“thread sleep 10 second\n”);
    
    sleep(10);
    
    }
    
    printf(“thread exit\n”);
    
    }
    
    
    int main()
    
    {
    
    pthread_t thread;
    
    if (0 != pthread_create(&thread, NULL, thr_fn, NULL))
    
    {
    
    printf(“error when create pthread,%d\n”, errno);
    
    return 1;
    
    }
    
    
    char c ;
    
    while ((c = getchar()) != ‘q’);
    
    
    printf(“Now terminate the thread!\n”);
    
    flag = 0;
    
    printf(“Wait for thread to exit\n”);
    
    pthread_join(thread, NULL);
    
    printf(“Bye\n”);
    
    return 0;
    
    }

输入q后，需要等线程从sleep中醒来（由挂起状态变为运行状态），即最坏情况要等10s，线程才会被join。采用sleep的缺点：不能及时唤醒线程。  
采用pthread\_cond\_timedwait函数实现的如下

#include <stdio.h>
    
    #include <pthread.h>
    
    #include <stdlib.h>
    
    #include <time.h>
    
    #include <unistd.h>
    
    #include <string.h>
    
    #include <errno.h>
    
    
    pthread_t thread;
    
    pthread_cond_t cond;
    
    pthread_mutex_t mutex;
    
    unsigned char flag = 1;
    
    
    void * thr_fn(void * arg)
    
    {
    
    int loop = 0;
    
    struct timeval now;
    
    struct timespec outtime;
    
    pthread_mutex_lock(&mutex);
    
    while (flag)
    
    {
    
    printf("thread[%u] sleep now, loop=%d\n", (unsigned int)pthread_self(), loop);
    
    gettimeofday(&now, NULL);
    
    outtime.tv_sec = now.tv_sec + 1;
    
    outtime.tv_nsec = now.tv_usec * 1000;
    
    pthread_cond_timedwait(&cond, &mutex, &outtime);
    
    loop++;
    
    }
    
    pthread_mutex_unlock(&mutex);
    
    printf("[%s,%d], thread[%u] exit\n", __FUNCTION__, __LINE__, (unsigned int)pthread_self());
    
    }
    
    
    int main(int argc, char **argv)
    
    {
    
    char c ;
    
    pthread_mutex_init(&mutex, NULL);
    
    pthread_cond_init(&cond, NULL);
    
    if (0 != pthread_create(&thread, NULL, thr_fn, NULL))
    
    {
    
    printf("error when create pthread,%d\n", errno);
    
    return 1;
    
    }
    
    printf("please input any key to exit thread[%u]\n", (unsigned int)thread);
    
    while (c = getchar() != 'q')
    
    {
    
    printf("Now terminate the thread!\n");
    
    flag = 0;
    
    pthread_mutex_lock(&mutex);
    
    pthread_cond_signal(&cond);
    
    pthread_mutex_unlock(&mutex);
    
    printf("Wait for thread to exit\n");
    
    pthread_join(thread, NULL);
    
    printf("thread[%u] Bye\n", (unsigned int)thread);
    
    return 0;
    
    }
    
    }

## mutex与spinlock ##

**理论**

mutex和spinlock都是用于多进程/线程间访问公共资源时保持同步用的，只是在lock失败的时候处理方式有所不同。首先，当一个thread 给一个mutex上锁失败的时候，thread会进入sleep状态，从而让其他的thread运行，其中就包裹已经给mutex上锁成功的那个thread，被占用的lock一旦释放，就会去wake up 那个sleep的thread。其次，当一个thread给一个spinlock上锁失败的时候，thread会在spinlock上不停的轮讯，直到成功，所以他不会进入sleep状态（当然，时间片用完了，内核会自动进行调度）。

**存在的问题**

无论是mutex还是spinlock，如果一个thread去给一个已经被其他thread占用的锁上锁，那么从此刻起到其他thread对此锁解锁的时间长短将会导致mutex和spinlock出现下面的问题。

mutex的问题是，它一旦上锁失败就会进入sleep，让其他thread运行，这就需要内核将thread切换到sleep状态，如果mutex又在很短的时间内被释放掉了，那么又需要将此thread再次唤醒，这需要消耗许多CPU指令和时间，这种消耗还不如让thread去轮讯。也就是说，其他thread解锁时间很短的话会导致CPU的资源浪费。

spinlock的问题是，和上面正好相反，如果其他thread解锁的时间很长的话，这种spinlock进行轮讯的方式将会浪费很多CPU资源。

**解决方法**

对于single-core/single-CPU，spinlock将一直浪费CPU资源，如果采用mutex，反而可以立刻让其他的thread运行，可能去释放mutex lock。对于multi-core/mutil-CPU，会存在很多短时间被占用的lock，如果总是去让thread sleep，紧接着去wake up，这样会浪费很多CPU资源，从而降低了系统性能，所以应该尽量使用spinlock。

**现实情况**

由于程序员不太可能确定每个运行程序的系统CPU和core的个数，所以也不可能去确定使用那一种lock。因此现在的操作系统通常不太区分mutex和spinlock了。实际上，大多数现代操作系统已经使用了混合mutex（hybrid mutex）和混合spinlock（hybrid spinlock）。说白了就是将两者的特点相结合。

hydrid mutex：在一个multi-core系统上，hybrid mutex首先像一个spinlock一样，当thread加锁失败的时候不会立即被设置成sleep，但是，当过了一定的时间（或则其他的策略）还没有获得lock，就会被设置成sleep，之后再被wake up。而在一个single-core系统上，hybrid mutex就不会表现出spinlock的特性，而是如果加锁失败就直接被设置成sleep。

hybrid spinlock：和hybrid mutex相似，只不过，thread加锁失败后在spinlock一段很短的时间后，会被stop而不是被设置成sleep，stop是正常的进程调度，应该会比先让thread sleep然后再wake up的开销小一些。

写程序的时候，如果对mutex和spinlock有任何疑惑，请选择使用mutex。

## 信号量 ##

内核中的信号量通常用作mutex互斥体（信号量初值初始化为1就达到了互斥的效果）。  
  
如果代码需要睡眠——这往往是发生在和用户空间同步时——使用信号量是唯一的选择。由于不受睡眠的限制，使用信号量通常来说更加简单一些。【信号量使用简单】  
如果需要在自旋锁和信号量中作选择，应该取决于锁被持有的时间长短。理想情况是所有的锁都应该尽可能短的被持有，但是如果锁的持有时间较长的话，使用信号量是更好的选择。【如果锁占用的时间较长，信号量更好】  
另外，信号量不同于自旋锁，它不会关闭内核抢占，所以持有信号量的代码可以被抢占。这意味者信号量不会对影响调度反应时间带来负面影响。【信号量不会影响内核调度】

（1）一个生产者，一个消费者，公用一个缓冲区。  
定义两个同步信号量：  
empty——表示缓冲区是否为空，初值为1。  
   full——表示缓冲区中是否为满，初值为0。  
生产者进程  
while(TRUE)\{  
生产一个产品;  
     P(empty);  
     产品送往Buffer;  
     V(full);  
\}  
消费者进程  
while(True)\{  
P(full);  
   从Buffer取出一个产品;  
   V(empty);  
   消费该产品;  
   \}  
（2）一个生产者，一个消费者，公用n个环形缓冲区。  
定义两个同步信号量：  
empty——表示缓冲区是否为空，初值为n。  
full——表示缓冲区中是否为满，初值为0。

设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指  
，指向下一个可用的缓冲区。  
生产者进程  
while(TRUE)\{  
     生产一个产品;  
     P(empty);  
     产品送往buffer（in）；  
     in=(in+1)mod n；  
     V(full);  
\}  
  
消费者进程  
while(TRUE)\{  
P(full);  
   从buffer（out）中取出产品；  
   out=(out+1)mod n；  
   V(empty);  
   消费该产品;  
   \}  
（3）一组生产者，一组消费者，公用n个环形缓冲区  
    在这个问题中，不仅生产者与消费者之间要同步，而且各个生产者之间、各个消费者之间还必须互斥地访问缓冲区。  
定义四个信号量：  
empty——表示缓冲区是否为空，初值为n。  
full——表示缓冲区中是否为满，初值为0。  
mutex1——生产者之间的互斥信号量，初值为1。  
mutex2——消费者之间的互斥信号量，初值为1。

设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。  
生产者进程  
while(TRUE)\{  
     生产一个产品;  
     P(empty);  
     P(mutex1)；  
     产品送往buffer（in）；  
     in=(in+1)mod n；  
     V(mutex1);  
     V(full);  
\}  
消费者进程  
while(TRUE)\{  
P(full)  
   P(mutex2)；  
   从buffer（out）中取出产品；  
   out=(out+1)mod n；  
   V（mutex2）；  
   V(empty);  
   消费该产品;  
   \}  
  需要注意的是无论在生产者进程中还是在消费者进程中，两个P操作的次序不能颠倒。应先执行同步信号量的P操作，然后再执行互斥信号量的P操作，否则可能造成进程死锁。

桌上有一空盘，允许存放一只水果。爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。规定当盘空时一次只能放一只水果供吃者取用，请用P、V原语实现爸爸、儿子、女儿三个并发进程的同步。

**分析** 在本题中，爸爸、儿子、女儿共用一个盘子，盘中一次只能放一个水果。当盘子为空时，爸爸可将一个水果放入果盘中。若放入果盘中的是桔子，则允许儿子吃，女儿必须等待；若放入果盘中的是苹果，则允许女儿吃，儿子必须等待。本题实际上是生产者-消费者问题的一种变形。这里，生产者放入缓冲区的产品有两类，消费者也有两类，每类消费者只消费其中固定的一类产品。

**解**：在本题中，应设置三个信号量S、So、Sa，信号量S表示盘子是否为空，其初值为l；信号量So表示盘中是否有桔子，其初值为0；信号量Sa表示盘中是否有苹果，其初值为0。同步描述如下：  
int S＝1;  
int Sa＝0;  
int So＝0;  
      main()  
      \{  
        cobegin  
            father();      /\*父亲进程\*/  
            son();        /\*儿子进程\*/  
            daughter();    /\*女儿进程\*/  
        coend  
    ｝  
   father()  
    \{  
        while(1)  
          \{  
            P(S);  
            将水果放入盘中;  
            if（放入的是桔子）V(So);  
            else  V(Sa);  
           \}  
     \}  
    son()  
    \{  
        while(1)  
          \{  
             P(So);  
             从盘中取出桔子;  
             V(S);  
             吃桔子;  
            ｝  
    \}  
    daughter()  
    \{  
         while(1)  
            \{  
              P(Sa);  
              从盘中取出苹果;  
              V(S);  
              吃苹果;  
            ｝  
｝  
  
**思考题：**

四个进程A、B、C、D都要读一个共享文件F，系统允许多个进程同时读文件F。但限制是进程A和进程C不能同时读文件F，进程B和进程D也不能同时读文件F。为了使这四个进程并发执行时能按系统要求使用文件，现用PV操作进行管理，请回答下面的问题：  
    （1）应定义的信号量及初值：                    。  
    （2）在下列的程序中填上适当的P、V操作，以保证它们能正确并发工作：  
     A()                B()                  C()                 D()  
      \{                 \{                    \{                  \{  
      \[1\];                \[3\];                  \[5\];                 \[7\];  
      read F;             read F;                read F;              read F;  
     \[2\];                \[4\];                  \[6\];                 \[8\];  
      \}                  \}                    \}                  \}

思考题解答：  
（1）定义二个信号量S1、S2，初值均为1，即：S1=1，S2=1。其中进程A和C使用信号量S1，进程B和D使用信号量S2。  
（2）从\[1\]到\[8\]分别为：P(S1) V(S1) P(S2) V(S2) P(S1) V(S1) P(S2) V(S2)

[pthread_cond_timedwait]: http://publib.boulder.ibm.com/infocenter/iseries/v5r4/index.jsp?topic=%2Fapis%2Fusers_77.htm