首页 › 线程间通信 › 一点关于pthread_cond_t条件锁的思考以及实验

一点关于pthread_cond_t条件锁的思考以及实验

第七根弦 2014 年 12 月 2 日 线程间通信 发表评论 (0)

APUE上，关于条件锁。其中有这么几条总结：

1。使用条件锁前必须先锁住对应的互斥锁。

2。条件锁进入阻塞(pthread_cond_wait)时自动解开对应互斥锁，而一旦跳出阻塞立即再次取得互斥锁，而这两个操作都是原子操作。

好，现在考虑到这一点，假如有如下函数：

C++
1
2
3
4
5
6
7
8
9
10
11
12
void* run(void *s)
{
    pthread_mutex_lock(&mutex);
    while (i==1)
    {
        printf("线程%u进入等待状态/n",pthread_self());
        pthread_cond_wait(&cond_l,&mutex);
    }
    printf("已经解开%u/n",pthread_self());
    pthread_mutex_unlock(&mutex);
    i = 1;
}

根据前面两条规则，我们可以知道，如果多个线程同时调用这个函数，当一个线程取得同步锁之后，其他线程就会阻塞在pthread_mutex_lock函数，而当那个取得锁的线程执行到pthread_cond_wait并阻塞之后，在从这个函数返回（条件满足）之前，会释放掉锁，所以其他线程也能一个一个都执行到pthread_cond_wait这里阻塞。这时就有多个线程阻塞在这里了。

假设这时候在另外某个线程条件被满足，并发出了pthread_cond_signal，那么这么多阻塞的线程会不会全部一下就都被解开了呢？

答案是否。

因为根据第二条规则，从阻塞的函数返回并尝试再次锁住互斥锁，这是一个原子操作。也就是说，第一个成功解套的线程会再次锁上互斥锁，而其他线程这时候要想跳出阻塞状态就不可能了，因为他们无法取得互斥锁，只能继续等待（根据我的测试是等待下一次pthread_cond_singal。

（以上是错误的，后来发现，原来pthread_cond_signal本来就只会唤醒一个条件锁，而实验证明，唤醒的顺序跟阻塞在条件锁的顺序相同)

现在看以下代码：

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<error.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_l = PTHREAD_COND_INITIALIZER;
int i = 1;
void* run(void *);
void main(int argc, char **argv)
{
    pthread_t pid1;
    pthread_t pid2;
    pthread_t pid3;
    pthread_t pid4;
    pthread_create(&pid1,NULL,run,NULL);
    printf("new thread:%u/n",pid1);
    sleep(1);
    pthread_create(&pid2,NULL,run,NULL);
    printf("new thread:%u/n",pid2);
    sleep(1);
    pthread_create(&pid3,NULL,run,NULL);
    printf("new thread:%u/n",pid3);
    sleep(1);
    pthread_create(&pid4,NULL,run,NULL);
    printf("new thread:%u/n",pid4);
    sleep(1);
    i = 2;
    pthread_mutex_lock(&mutex);
    pthread_cond_signal(&cond_l);
    printf("release signal/n");
    sleep(1);
    i = 2;
    pthread_cond_signal(&cond_l);
    printf("release signal/n");
    pthread_join(pid1,NULL);
    pthread_join(pid2,NULL);
    pthread_join(pid3,NULL);
    pthread_join(pid4,NULL);
}
void* run(void *s)
{
    pthread_mutex_lock(&mutex);
    while (i==1)
    {
        printf("线程%u进入等待状态/n",pthread_self());
        pthread_cond_wait(&cond_l,&mutex);
    }
    printf("已经解开%u/n",pthread_self());
    pthread_mutex_unlock(&mutex);
    i = 1;
}

最后的输出是：

new thread:3085007776

线程3085007776进入等待状态

new thread:3076615072

线程3076615072进入等待状态

new thread:3068222368

线程3068222368进入等待状态

new thread:3059829664

线程3059829664进入等待状态

release signal

已经解开3085007776

release signal

已经解开3076615072
一切正常，每次pthread_cond_signal就能放掉一个线程。那么为了验证前面我的分析是正确的，加入在执行pthread_cond_signal的时候，阻塞在对应条件锁的pthread_cond_wait处的线程的互斥锁全都是被锁住的，还会有线程能成功解套么？看以下代码：

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<error.h>
#include <unistd.h>
#include <pthread.h>
#include <stdio.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_l = PTHREAD_COND_INITIALIZER;
int i = 1;
void* run(void *);
void main(int argc, char **argv)
{
    pthread_t pid1;
    pthread_t pid2;
    pthread_t pid3;
    pthread_t pid4;
    pthread_create(&pid1,NULL,run,NULL);
    printf("new thread:%u/n",pid1);
    sleep(1);
    pthread_create(&pid2,NULL,run,NULL);
    printf("new thread:%u/n",pid2);
    sleep(1);
    pthread_create(&pid3,NULL,run,NULL);
    printf("new thread:%u/n",pid3);
    sleep(1);
    pthread_create(&pid4,NULL,run,NULL);
    printf("new thread:%u/n",pid4);
    sleep(1);
    i = 2;
    pthread_mutex_lock(&mutex);   //注意这里
    pthread_cond_signal(&cond_l);
    printf("release signal/n");
    sleep(1);
    i = 2;
    pthread_cond_signal(&cond_l);
    printf("release signal/n");
    pthread_join(pid1,NULL);
    pthread_join(pid2,NULL);
    pthread_join(pid3,NULL);
    pthread_join(pid4,NULL);
}
void* run(void *s)
{
    pthread_mutex_lock(&mutex);
    while (i==1)
    {
        printf("线程%u进入等待状态/n",pthread_self());
        pthread_cond_wait(&cond_l,&mutex);
    }
    printf("已经解开%u/n",pthread_self());
    pthread_mutex_unlock(&mutex);
    i = 1;
}

注意带注释的地方，在执行pthread_cond_signal之前，我又把互斥锁锁住了。之所以这里敢这么写，是因为其他几个子线程最后卡在pthread_cond_wait的时候都会把锁给释放掉的，所以我能在主线程里取得互斥锁。这样的话，其他子线程接到条件满足的信号后还会从等待中跳出来吗？运行结果如下：

new thread:3085290400

线程3085290400进入等待状态

new thread:3076897696

线程3076897696进入等待状态

new thread:3068504992

线程3068504992进入等待状态

new thread:3060112288

线程3060112288进入等待状态

release signal

release signal

Oh，No，果然，没有一个线程跑出来。事实上，如果不是这么改，而是让每个线程在run函数最后不释放互斥锁，最后只会有第一个跑出来的线程解套成功。所以，从目前来看，我的分析应该是正确的。

|

发表评论