互斥锁和条件变量

忘是亡心i 2022-09-23 08:45 217阅读 0赞

# [互斥锁和条件变量][Link 1] #

http://www.cnblogs.com/Anker/archive/2013/01/09/2852442.html

为了允许在线程或进程之间共享数据，同步时必须的，互斥锁和条件变量是同步的基本组成部分。

1、互斥锁

互斥锁是用来保护临界区资源，实际上保护的是临界区中被操纵的数据，互斥锁通常用于保护由多个线程或多进程分享的共享数据。一般是一些可供线程间使用的全局变量，来达到线程同步的目的,即保证任何时刻只有一个线程或进程在执行其中的代码。一般加锁的轮廓如下：

pthread_mutex_lock() 临界区 pthread_mutex_unlock()

互斥锁API

**pthread\_mutex\_lock(pthread\_mutex\_t \*mutex);**

用此函数加锁时，如果mutex已经被锁住，当前尝试加锁的线程就会阻塞，直到互斥锁被其他线程释放。当此函数返回时，说明互斥锁已经被当前线程成功加锁.

**pthread\_mutex\_trylock(pthread\_mutex\_t \*mutex);**

用此函数加锁时，如果mutex已经卑琐主，当前尝试加锁的线程不会阻塞，而是立即返回，返回的错误码为EBUSY,而不是阻塞等待。

**pthread\_mutex\_unlock(pthread\_mutex\_t \*mutex);**

注意使用锁之前要记得初始化。互斥锁的初始化有两种初始化方式:

1.对于静态分配的互斥锁一半用宏赋值的方式初始化

eg: static pthread\_mutex\_t mutex = PTHREAD\_MUTEX\_INITIALIZER;

2.对于动态分配的互斥锁（如调用malloc）或分配在共享内存中，则必须调用pthread\_mutex\_init(pthread\_mutex \*mutex, pthread\_mutexattr\_t \*mutexattr)函数来进行初始化。

例子1：写个程序实现生产者—消费者问题，先只考虑多个生产者线程之间的同步，直到所有的生产者线程都完成工作以后，才启动消费者线程。程序如下：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

1 #include <stdio.h>
     2 #include <stdlib.h>
     3 #include <unistd.h>
     4 #include <pthread.h>
     5 #include <errno.h>
     6 
     7 #define     MAXNITEMS        1000000
     8 #define     MAXNTHREADS     100
     9 
    10 int nitems;
    11 
    12 struct
    13 {
    14     pthread_mutex_t     mutex;
    15     int                 buff[MAXNITEMS];
    16     int                 nput;
    17     int                 nval;
    18 } shared = {
    19     PTHREAD_MUTEX_INITIALIZER
    20 };
    21 
    22 void *produce(void*);
    23 void *consume(void*);
    24 
    25 int main(int argc,char *argv[])
    26 {
    27     int     i,nthreads,count[MAXNTHREADS];
    28     pthread_t tid_produce[MAXNTHREADS],tid_consume;
    29     if(argc != 3)
    30     {
    31         printf("usage: producongs2 <#itmes> <#threads>.\n");
    32         exit(0);
    33     }
    34     nitems = atoi(argv[1]);
    35     nthreads = atoi(argv[2]);
    36     pthread_setconcurrency(nthreads);  //设置线程并发级别
    37     for(i=0;i<nthreads;++i)
    38     {
    39         count[i] = 0;
    40         pthread_create(&tid_produce[i],NULL,produce,&count[i]);
    41     }
    42     for(i=0;i<nthreads;i++)
    43     {
    44         pthread_join(tid_produce[i],NULL); //等待线程退出
    45         printf("count[%d] = %d\n",i,count[i]);
    46     }
    47     pthread_create(&tid_consume,NULL,consume,NULL);
    48     pthread_join(tid_consume,NULL);  //等待线程退出
    49     exit(0);
    50 }
    51 
    52 void *produce(void *arg)
    53 {
    54     for(; ;)
    55     {
    56         pthread_mutex_lock(&shared.mutex); //加锁
    57         if(shared.nput >= nitems)
    58         {
    59             pthread_mutex_unlock(&shared.mutex); //释放锁
    60             return ;
    61         }
    62         shared.buff[shared.nput] = shared.nval;
    63         shared.nput++;
    64         shared.nval++;
    65         pthread_mutex_unlock(&shared.mutex); //加锁
    66         *((int*) arg) += 1;
    67     }
    68 }
    69 void *consume(void *arg)
    70 {
    71     int     i;
    72     for(i=0;i<nitems;i++)
    73     {
    74         if(shared.buff[i] != i)
    75             printf("buff[%d] = %d\n",i,shared.buff[i]);
    76     }
    77     return;
    78 }

![复制代码][copycode.gif]

程序执行结果如下：

![09105823-d9036436f29a4cdd966b6808a04a1dc6.png][]

例子2：改进例子1，所有生产者线程启动后立即启动消费者线程，这样生产者线程产生数据的同时，消费者线程就能出来它，此时必须同步生产者和消费者，程序如下：

![ContractedBlock.gif][]

存在的问题：当消费者获取的条目尚没有准备好时，消费者线程一次次的循环去判断，每次给互斥锁解锁又上锁，这种轮询的办法浪费CPU时间。

2、条件变量

互斥锁用于上锁，条件变量用于等待，条件变量的使用是与互斥锁共通使用的。

2.1等待与信号发送

条件变量类型是pthread\_cond\_t，调用函数如下：

**pthread\_cond\_wait(pthread\_cond\_t \*cond, pthread\_mutex\_t \*pmutex);**

**pthread\_cond\_signal(pthread\_cond\_t \*pcond);**

每个条件变量总是有一个互斥锁与之关联。现在采用条件变量实现生产者与消费者问题，程序如下：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

1 #include <stdio.h>
     2 #include <stdlib.h>
     3 #include <unistd.h>
     4 #include <pthread.h>
     5 #include <errno.h>
     6 
     7 #define     MAXNITEMS        1000000
     8 #define     MAXNTHREADS     100
     9 
    10 int nitems;
    11 
    12 struct
    13 {
    14     pthread_mutex_t     mutex;
    15     int                 buff[MAXNITEMS];
    16     int                 nput;
    17     int                 nval;
    18 } shared = {
    19     PTHREAD_MUTEX_INITIALIZER
    20 };
    21 //条件变量
    22 struct {
    23     pthread_mutex_t mutex;  
    24     pthread_cond_t  cond;
    25     int nready;
    26 }nready = {
    27   PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER
    28 };
    29 
    30 void *produce(void*);
    31 void *consume(void*);
    32 
    33 int main(int argc,char *argv[])
    34 {
    35     int     i,nthreads,count[MAXNTHREADS];
    36     pthread_t tid_produce[MAXNTHREADS],tid_consume;
    37     if(argc != 3)
    38     {
    39         printf("usage: producongs2 <#itmes> <#threads>.\n");
    40         exit(0);
    41     }
    42     nitems = atoi(argv[1]);
    43     nthreads = atoi(argv[2]);
    44     pthread_setconcurrency(nthreads+1);
    45     for(i=0;i<nthreads;++i)
    46     {
    47         count[i] = 0;
    48         pthread_create(&tid_produce[i],NULL,produce,&count[i]);
    49     }
    50     pthread_create(&tid_consume,NULL,consume,NULL);
    51     for(i=0;i<nthreads;i++)
    52     {
    53         pthread_join(tid_produce[i],NULL);
    54         printf("count[%d] = %d\n",i,count[i]);
    55     }
    56     pthread_join(tid_consume,NULL);
    57     exit(0);
    58 }
    59 
    60 void *produce(void *arg)
    61 {
    62     printf("producer begins work\n");
    63     for(; ;)
    64     {
    65         pthread_mutex_lock(&shared.mutex);
    66         if(shared.nput >= nitems)
    67         {
    68             pthread_mutex_unlock(&shared.mutex);
    69             return ;
    70         }
    71         shared.buff[shared.nput] = shared.nval;
    72         shared.nput++;
    73         shared.nval++;
    74         pthread_mutex_unlock(&shared.mutex);
    75         pthread_mutex_lock(&nready.mutex);
    76         if(nready.nready == 0)
    77            pthread_cond_signal(&nready.cond); //通知消费者
    78         nready.nready++;
    79         pthread_mutex_unlock(&nready.mutex);
    80         *((int*) arg) += 1;
    81     }
    82 }
    83 void *consume(void *arg)
    84 {
    85     int     i;
    86     printf("consuemer begins work.\n");
    87     for(i=0;i<nitems;i++)
    88     {
    89         pthread_mutex_lock(&nready.mutex);
    90         while(nready.nready == 0)
    91            pthread_cond_wait(&nready.cond,&nready.mutex); //等待生产者
    92         nready.nready--;
    93         pthread_mutex_unlock(&nready.mutex);
    94         if(shared.buff[i] != i)
    95             printf("buff[%d] = %d\n",i,shared.buff[i]);
    96     }
    97     return;
    98 }

![复制代码][copycode.gif]

程序执行结果如下：

![09113351-b1a7bb1d0efc45e4a4e60febc6c2cc15.png][]

总的来说，给条件变量发送信号的过程代码如下：

![复制代码][copycode.gif]

struct
    {
        pthread_mutex_t    mutex;
        pthread_cond_t       cond;
        //维护本条件的各个变量
    }var = {PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER,...}
    
    pthread_mutex_lock(&var.mutex);
    设置条件为真
    pthread_cond_signal(&var.cond);
    pthread_mutex_unlock(&var.mutex);

![复制代码][copycode.gif]

测试条件并进入睡眠以等待条件变为真的代码大体如下：

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

2.2定时等待和广播

通常pthread\_cond\_signal只是唤醒等待在相应条件变量上的一个线程，在某些情况下需要唤醒多个线程（例如读写者问题），可以调用pthread\_cond\_broadcast唤醒阻塞在相应条件变量上的所有线程。pthread\_cond\_timewait允许线程就阻塞时间设置一个限制值。API如下：

pthread\_cond\_broadcast(pthread\_cond\_t \*cond);

pthread\_cond\_timedwait(pthread\_cond\_t \*cond, pthread\_mutex, const struct timespec \*abstime);

[Link 1]: http://www.cnblogs.com/Anker/archive/2013/01/09/2852442.html
[ExpandedBlockStart.gif]: /images/20220720/d3bb923c93e745bc800588a29fe4e6c6.png
[copycode.gif]: /images/20220720/83401aedd6a440ee8ec53942d0c2ccf4.png
[09105823-d9036436f29a4cdd966b6808a04a1dc6.png]: /images/20220720/f670965604624dd59d12eb3fbb278645.png
[ContractedBlock.gif]: /images/20220720/0d38f388147a4027a27c0c26bf4e291d.png
[09113351-b1a7bb1d0efc45e4a4e60febc6c2cc15.png]: /images/20220720/60238797c40549c8b779c3cb3d6b5285.png