如果多个线程要同时访问（读和写）一个资源，资源的同步性和有效性就不可控。
比如以下代码
@implementation Thread1 {
pthread_t _thread0;
pthread_t _thread1;
}
void* thread_func(void *arg) {
for (int i = 0; i < 10; i++) {
printf("%d\n",i);
}
return NULL;
}
void *thread_func1(void *arg) {
for (int i = 0; i < 10; ++i) {
printf(" %d\n",i);
}
return NULL;
}
-(void) initializeThead {
pthread_mutex_init(&_mutex, NULL);
pthread_create(&_thread0, NULL, thread_func, NULL);
pthread_create(&_thread1, NULL, thread_func1, NULL);
}
@end
输出结果就不可控，如下：
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
0
1
2
0
3
1
4
2
5
3
6
4
7
5
8
6
9
7
8
9
-
-
- ... ...
-
那怎么办？
可以加个“互斥锁”pthread_mutex_t
当一个线程A先加上了“锁”时，另一个同样想加“锁”的线程B就只能先等待了。等到什么时候呢，等到那个先加上“锁”的线程A，“解锁”后，这个线程B可以“抢”到“锁”，然后执行代码。这里说的是“抢”，万一有个线程C，又先抢到了“锁”，那线程B只能再等了，就是传说中的插队了。
代码以下：
@implementation Thread1 {
pthread_t _thread0;
pthread_t _thread1;
}
pthread_mutex_t _mutex;
void* thread_func(void *arg) {
pthread_mutex_lock(&_mutex);
for (int i = 0; i < 10; i++) {
printf("%d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
void *thread_func1(void *arg) {
pthread_mutex_lock(&_mutex);
for (int i = 0; i < 10; ++i) {
printf(" %d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
-(void*) yteue:(void *) arg {
return NULL;
}
-(void) initializeThead {
pthread_mutex_init(&_mutex, NULL);
pthread_create(&_thread0, NULL, thread_func, NULL);
pthread_create(&_thread1, NULL, thread_func1, NULL);
}
@end
这段就只有两个情况，要么A先抢到锁B等，要么B先抢到锁A等。
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
有很大的进步了。
那我就是狮子座，就是想先让A执行，再进行B。
怎么办？
pthread_cond_t来了cond 应该就是condition的意思了。加条件嘛〜〜〜
一般来说"锁"和“条件”是配合来使用的，比如说，线程A抢到锁了，发现我这个主人不想让它执行（不符合条件），只能先等等喽（能有什么办法！），先让别人执行，但锁还是我手里啊。别人眼巴巴的看着线程A手里的锁，又不能执行。没办法，先扔出去，线程A在这里等条件完成的通知。通知到了（条件符合了），就把锁抢回来，继续执行线程A的代码。
代码如下：
@implementation Thread1 {
pthread_t _thread0;
pthread_t _thread1;
}
bool _flag;
pthread_mutex_t _mutex;
pthread_cond_t _cond;
void* thread_func(void *arg) {
pthread_mutex_lock(&_mutex);
while (_flag) {
printf("等\n");
//这里就是扔锁，等通知的，然后通知到了，再加锁的代码。
pthread_cond_wait(&_cond, &_mutex);
}
for (int i = 0; i < 10; i++) {
printf("%d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
void *thread_func1(void *arg) {
pthread_mutex_lock(&_mutex);
for (int i = 0; i < 10; ++i) {
printf(" %d\n",i);
}
_flag = false;
pthread_cond_signal(&_cond);
pthread_mutex_unlock(&_mutex);
return NULL;
}
-(void) initializeThread {
pthread_mutex_init(&_mutex, NULL);
pthread_cond_init(&_cond, NULL);
_flag = true;
pthread_create(&_thread0, NULL, thread_func, NULL);
pthread_create(&_thread1, NULL, thread_func1, NULL);
}
@end
这里也是两种结果：
等
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
有“等”字的说明，另一个线程先抢到锁了，但只能“等”喽了。
如果出现一种情况，同时有两个线程在“等”，
会是怎么样的？
如果有两个线程B和C，同时在“等”，A用pthread_cond_signal放出一个“别等啦”的信号，会是怎么样的？
@implementation Thread1 {
pthread_t _thread0;
pthread_t _thread1;
pthread_t _thread2;
}
bool _flag;
pthread_mutex_t _mutex;
pthread_cond_t _cond;
void* thread_func(void *arg) {
pthread_mutex_lock(&_mutex);
while (_flag) {
printf("等1\n");
//这里就是扔锁，等通知的，然后通知到了，再加锁的代码。
pthread_cond_wait(&_cond, &_mutex);
}
for (int i = 0; i < 10; i++) {
printf("A:%d\n",i);
}
_flag = true;
pthread_mutex_unlock(&_mutex);
return NULL;
}
void *thread_func1(void *arg) {
pthread_mutex_lock(&_mutex);
for (int i = 0; i < 10; ++i) {
printf(" %d\n",i);
}
_flag = false;
pthread_cond_signal(&_cond);
pthread_mutex_unlock(&_mutex);
return NULL;
}
void* thread_func2(void *arg) {
pthread_mutex_lock(&_mutex);
while (_flag) {
printf("等2\n");
//这里就是扔锁，等通知的，然后通知到了，再加锁的代码。
pthread_cond_wait(&_cond, &_mutex);
}
for (int i = 0; i < 10; i++) {
printf(" B:%d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
-(void*) yteue:(void *) arg {
return NULL;
}
-(void) initializeThead {
pthread_mutex_init(&_mutex, NULL);
pthread_cond_init(&_cond, NULL);
_flag = true;
pthread_create(&_thread2, NULL, thread_func2, NULL);
pthread_create(&_thread0, NULL, thread_func, NULL);
pthread_create(&_thread1, NULL, thread_func1, NULL);
}
@end
出现以下两种结果：
等1
等2
0
1
2
3
4
5
6
7
8
9
A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
等2
等1
0
1
2
3
4
5
6
7
8
9
B:0
B:1
B:2
B:3
B:4
B:5
B:6
B:7
B:8
B:9
嗯？好像只是让先“等”的那条线程“别等啦”，但，后等的那个好像还在“等”阿。傻了吧。
怎么办！！
这时就要用pthread_cond_broadcast广播啦，这个不像 pthread_cond_signal只触发一个“等”，broadcast是广播的意思，就是让所有用这个“_cond”在等待的线程都激活。然后所有的被激活的线程又重新去抢“锁”。
代码如下：
@implementation Thread1 {
pthread_t _thread0;
pthread_t _thread1;
pthread_t _thread2;
}
bool _flag;
pthread_mutex_t _mutex;
pthread_cond_t _cond;
void* thread_func(void *arg) {
pthread_mutex_lock(&_mutex);
while (_flag) {
printf("等1\n");
//这里就是扔锁，等通知的，然后通知到了，再加锁的代码。
pthread_cond_wait(&_cond, &_mutex);
}
for (int i = 0; i < 10; i++) {
printf("A:%d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
void *thread_func1(void *arg) {
pthread_mutex_lock(&_mutex);
for (int i = 0; i < 10; ++i) {
printf(" %d\n",i);
}
_flag = false;
pthread_cond_broadcast(&_cond);
pthread_mutex_unlock(&_mutex);
return NULL;
}
void* thread_func2(void *arg) {
pthread_mutex_lock(&_mutex);
while (_flag) {
printf("等2\n");
//这里就是扔锁，等通知的，然后通知到了，再加锁的代码。
pthread_cond_wait(&_cond, &_mutex);
}
for (int i = 0; i < 10; i++) {
printf(" B:%d\n",i);
}
pthread_mutex_unlock(&_mutex);
return NULL;
}
-(void*) yteue:(void *) arg {
return NULL;
}
-(void) initializeThead {
pthread_mutex_init(&_mutex, NULL);
pthread_cond_init(&_cond, NULL);
_flag = true;
pthread_create(&_thread2, NULL, thread_func2, NULL);
pthread_create(&_thread0, NULL, thread_func, NULL);
pthread_create(&_thread1, NULL, thread_func1, NULL);
}
@end
结果，大致有两种（没有“等”的结果就先去掉，没有意义）：
等2
等1
0
1
2
3
4
5
6
7
8
9
B:0
B:1
B:2
B:3
B:4
B:5
B:6
B:7
B:8
B:9
A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
等1
等2
0
1
2
3
4
5
6
7
8
9
A:0
A:1
A:2
A:3
A:4
A:5
A:6
A:7
A:8
A:9
B:0
B:1
B:2
B:3
B:4
B:5
B:6
B:7
B:8
B:9