之前介绍了线程同步的问题，今天继续介绍线程同步的死锁。
1 死锁
1. 线程试图对同一个互斥量A加锁两次。
2. 线程1拥有A锁，请求获得B锁；线程2拥有B锁，请求获得A锁
2 读写锁
与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。
2.1 读写锁状态：
一把读写锁具备三种状态：
1. 读模式下加锁状态 (读锁)
2. 写模式下加锁状态 (写锁)
3. 不加锁状态
2.2 读写锁特性：
读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞。
读写锁是“读模式加锁”时，如果线程以读模式对其加锁会成功；如果线程以写模式加锁会阻塞。
读写锁是“读模式加锁”时，既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞，写锁优先级高
读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。写独占、读共享。
读写锁非常适合于对数据结构读的次数远大于写的情况。
2.3 主要应用函数：
pthread_rwlock_init函数
pthread_rwlock_destroy函数
pthread_rwlock_rdlock函数
pthread_rwlock_wrlock函数
pthread_rwlock_tryrdlock函数
pthread_rwlock_trywrlock函数
pthread_rwlock_unlock函数
以上7 个函数的返回值都是：成功返回0，失败直接返回错误号。
pthread_rwlock_t类型 用于定义一个读写锁变量。
pthread_rwlock_t rwlock;
2.4 pthread_rwlock_init函数
初始化一把读写锁
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);
参2：attr表读写锁属性，通常使用默认属性，传NULL即可。
pthread_rwlock_destroy函数
销毁一把读写锁
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
pthread_rwlock_rdlock函数
以读方式请求读写锁。(常简称为：请求读锁)
int pthread_rwlock_rdlock(pthread_rwlock_t*rwlock);
pthread_rwlock_wrlock函数
以写方式请求读写锁。(常简称为：请求写锁)
int pthread_rwlock_wrlock(pthread_rwlock_t*rwlock);
pthread_rwlock_unlock函数
解锁
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
pthread_rwlock_tryrdlock函数
非阻塞以读方式请求读写锁(非阻塞请求读锁)
intpthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
pthread_rwlock_trywrlock函数
非阻塞以写方式请求读写锁(非阻塞请求写锁)
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
读写锁示例
看如下示例，同时有多个线程对同一全局数据读、写操作。
#include #include #include int counter; pthread_rwlock_t rwlock; /* 3个线程不定时写同一全局资源，5个线程不定时读同一全局资源 */ void *th_write(void *arg) { int t, i = (int)arg; while (1) { pthread_rwlock_wrlock(&rwlock); t = counter; usleep(1000); printf("=======write %d: %lu: counter=%d ++counter=%d\n", i,pthread_self(), t, ++counter); pthread_rwlock_unlock(&rwlock); usleep(10000); } return NULL; } void *th_read(void *arg) { int i = (int)arg; while (1) { pthread_rwlock_rdlock(&rwlock); printf("----------------------------read %d: %lu: %d\n", i,pthread_self(), counter); pthread_rwlock_unlock(&rwlock); usleep(2000); } return NULL; } int main(void) { int i; pthread_t tid[8]; pthread_rwlock_init(&rwlock, NULL); for (i = 0; i < 3; i++) pthread_create(&tid[i], NULL, th_write, (void *)i); for (i = 0; i < 5; i++) pthread_create(&tid[i+3], NULL, th_read, (void *)i); for (i = 0; i < 8; i++) pthread_join(tid[i],NULL); pthread_rwlock_destroy(&rwlock); return 0; } |
3 条件变量：
条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。
3.1 主要应用函数：
pthread_cond_init函数
pthread_cond_destroy函数
pthread_cond_wait函数
pthread_cond_timedwait函数
pthread_cond_signal函数
pthread_cond_broadcast函数
以上6 个函数的返回值都是：成功返回0，失败直接返回错误号。
pthread_cond_t类型 用于定义条件变量
pthread_cond_t cond;
pthread_cond_init函数
初始化一个条件变量
intpthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t*restrict attr);
参2：attr表条件变量属性，通常为默认值，传NULL即可
也可以使用静态初始化的方法，初始化条件变量：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_destroy函数
销毁一个条件变量
intpthread_cond_destroy(pthread_cond_t *cond);
pthread_cond_wait函数
阻塞等待一个条件变量
int pthread_cond_wait(pthread_cond_t*restrict cond, pthread_mutex_t *restrict mutex);
函数作用：
阻塞等待条件变量cond(参1)满足
释放已掌握的互斥锁(解锁互斥量)相当于pthread_mutex_unlock(&mutex);
1.2.两步为一个原子操作。
当被唤醒，pthread_cond_wait函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex);
pthread_cond_timedwait函数
限时等待一个条件变量
intpthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrictmutex, const struct timespec *restrict abstime);
参3： 参看mansem_timedwait函数，查看struct timespec结构体。
structtimespec {
time_ttv_sec; /*seconds */ 秒
long tv_nsec; /*nanosecondes*/ 纳秒
}
形参abstime：绝对时间。
如：time(NULL)返回的就是绝对时间。而alarm(1)是相对时间，相对当前时间定时1秒钟。
struct timespec t = {1, 0};
pthread_cond_timedwait (&cond,&mutex, &t); 只能定时到 1970年1月1日00:00:01秒(早已经过去)
正确用法：
time_t cur = time(NULL); 获取当前时间。
struct timespec t; 定义timespec 结构体变量t
t.tv_sec = cur+1; 定时1秒pthread_cond_timedwait (&cond, &mutex, &t); 传参 参APUE.11.6线程同步条件变量小节
在讲解setitimer函数时我们还提到另外一种时间类型：
struct timeval {
time_t tv_sec; /* seconds */ 秒
suseconds_t tv_usec; /*microseconds */ 微秒
};
pthread_cond_signal函数
唤醒至少一个阻塞在条件变量上的线程
intpthread_cond_signal(pthread_cond_t *cond);
pthread_cond_broadcast函数
唤醒全部阻塞在条件变量上的线程
int pthread_cond_broadcast(pthread_cond_t*cond);
生产者消费者条件变量模型
线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源(一般称之为汇聚)，生产向其中添加产品，消费者从中消费掉产品。
看如下示例，使用条件变量模拟生产者、消费者问题：
#include #include #include struct msg { struct msg *next; int num; }; struct msg *head; pthread_cond_t has_product = PTHREAD_COND_INITIALIZER; pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; void *consumer(void *p) { struct msg *mp; for (;;) { pthread_mutex_lock(&lock); while (head == NULL){ //头指针为空,说明没有节点 可以为if吗 pthread_cond_wait(&has_product, &lock); } mp = head; head =mp->next; //模拟消费掉一个产品 pthread_mutex_unlock(&lock); printf("-Consume---%d\n", mp->num); free(mp); sleep(rand() % 5); } } void *producer(void *p) { struct msg *mp; while (1) { mp = malloc(sizeof(structmsg)); mp->num = rand() %1000 + 1; //模拟生产一个产品 printf("-Produce---%d\n", mp->num); pthread_mutex_lock(&lock); mp->next = head; head = mp; pthread_mutex_unlock(&lock); pthread_cond_signal(&has_product); //将等待在该条件变量上的一个线程唤醒 sleep(rand() % 5); } } int main(int argc, char *argv[]) { pthread_t pid, cid; srand(time(NULL)); pthread_create(&pid,NULL, producer, NULL); pthread_create(&cid, NULL,consumer, NULL); pthread_join(pid, NULL); pthread_join(cid, NULL); return 0; } |
条件变量的优点：
相较于mutex而言，条件变量可以减少竞争。
如直接使用mutex，除了生产者、消费者之间要竞争互斥量以外，消费者之间也需要竞争互斥量，但如果汇聚(链表)中没有数据，消费者之间竞争互斥锁是无意义的。有了条件变量机制以后，只有生产者完成生产，才会引起消费者之间的竞争。提高了程序效率。
信号量
进化版的互斥锁(1 --> N)
由于互斥锁的粒度比较大，如果我们希望在多个线程间对某一对象的部分数据进行共享，使用互斥锁是没有办法实现的，只能将整个数据对象锁住。这样虽然达到了多线程操作共享数据时保证数据正确性的目的，却无形中导致线程的并发性下降。线程从并行执行，变成了串行执行。与直接使用单进程无异。
信号量，是相对折中的一种处理方式，既能保证同步，数据不混乱，又能提高线程并发。
主要应用函数：
sem_init函数
sem_destroy函数
sem_wait函数
sem_trywait函数
sem_timedwait函数
sem_post函数
以上6 个函数的返回值都是：成功返回0，失败返回-1，同时设置errno。(注意，它们没有pthread前缀)
sem_t类型，本质仍是结构体。但应用期间可简单看作为整数，忽略实现细节(类似于使用文件描述符)。
sem_t sem; 规定信号量sem不能 < 0。头文件
信号量基本操作：
sem_wait:
1. 信号量大于0，则信号量-- (类比pthread_mutex_lock)
|
2.信号量等于0，造成线程阻塞
对应
|
sem_post： 将信号量++，同时唤醒阻塞在信号量上的线程 (类比pthread_mutex_unlock)
但，由于sem_t的实现对用户隐藏，所以所谓的++、--操作只能通过函数来实现，而不能直接++、--符号。
信号量的初值，决定了占用信号量的线程的个数。
sem_init函数
初始化一个信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
参1：sem信号量
参2：pshared取0用于线程间；取非0(一般为1)用于进程间
参3：value指定信号量初值
sem_destroy函数
销毁一个信号量
int sem_destroy(sem_t *sem);
sem_wait函数
给信号量加锁 --
int sem_wait(sem_t *sem);
sem_post函数
给信号量解锁 ++
int sem_post(sem_t*sem);
sem_trywait函数
尝试对信号量加锁 -- (与sem_wait的区别类比lock和trylock)
int sem_trywait(sem_t*sem);
sem_timedwait函数
限时尝试对信号量加锁 --
int sem_timedwait(sem_t *sem, const struct timespec*abs_timeout);
参2：abs_timeout采用的是绝对时间。
定时1秒：
time_tcur = time(NULL); 获取当前时间。
struct timespec t; 定义timespec 结构体变量t
t.tv_sec= cur+1; 定时1秒
t.tv_nsec= t.tv_sec +100;
sem_timedwait(&sem, &t); 传参
生产者消费者信号量模型
使用信号量完成线程间同步，模拟生产者，消费者问题。
分析：
规定：
如果□中有数据，生产者不能生产，只能阻塞。
如果□中没有数据，消费者不能消费，只能等待数据。
定义两个信号量：S满 = 0， S空 = 1 (S满代表满格的信号量，S空表示空格的信号量，程序起始，格子一定为空)
所以有：
T生产者主函数 {
T消费者主函数 {
sem_wait(S空);
sem_wait(S满);
生产....
消费....
sem_post(S满);
sem_post(S空);
}
}
假设： 线程到达的顺序是:T生、T生、T消。
那么： T生1 到达，将S空-1，生产，将S满+1
T生2 到达，S空已经为0， 阻塞
T消 到达，将S满-1，消费，将S空+1
三个线程到达的顺序是：T生1、T生2、T消。而执行的顺序是T生1、T消、T生2
这里，S空表示空格子的总数，代表可占用信号量的线程总数-->1。其实这样的话，信号量就等同于互斥锁。
但，如果S空=2、3、4……就不一样了，该信号量同时可以由多个线程占用，不再是互斥的形式。因此我们说信号量是互斥锁的加强版。
理解上述模型，推演，如果是两个消费者，一个生产者，是怎么样的情况。
进程间同步
互斥量mutex
进程间也可以使用互斥锁，来达到同步的目的。但应在pthread_mutex_init初始化之前，修改其属性为进程间共享。mutex的属性修改函数主要有以下几个。
主要应用函数：
pthread_mutexattr_t mattr 类型： 用于定义mutex锁的【属性】
pthread_mutexattr_init函数： 初始化一个mutex属性对象
int pthread_mutexattr_init(pthread_mutexattr_t*attr);
pthread_mutexattr_destroy函数： 销毁mutex属性对象 (而非销毁锁)
int pthread_mutexattr_destroy(pthread_mutexattr_t*attr);
pthread_mutexattr_setpshared函数： 修改mutex属性。
intpthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
参2：pshared取值：
线程锁：PTHREAD_PROCESS_PRIVATE(mutex的默认属性即为线程锁，进程间私有)
进程锁：PTHREAD_PROCESS_SHARED
进程间mutex示例
进程间使用mutex来实现同步：
#include #include #include #include struct mt { int num; pthread_mutex_t mutex; pthread_mutexattr_tmutexattr; }; int main(void) { int fd, i; struct mt *mm; pid_t pid; fd =open("mt_test", O_CREAT | O_RDWR, 0777); ftruncate(fd,sizeof(*mm)); mm = mmap(NULL,sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); close(fd); unlink("mt_test"); //mm = mmap(NULL,sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0); memset(mm, 0,sizeof(*mm)); pthread_mutexattr_init(&mm->mutexattr); //初始化mutex属性对象 pthread_mutexattr_setpshared(&mm->mutexattr,PTHREAD_PROCESS_SHARED); //修改属性为进程间共享 pthread_mutex_init(&mm->mutex, &mm->mutexattr); //初始化一把mutex琐 pid = fork(); if (pid == 0) { for (i = 0; i < 10;i++) { pthread_mutex_lock(&mm->mutex); (mm->num)++; printf("-child----num++ %d\n", mm->num); pthread_mutex_unlock(&mm->mutex); sleep(1); } } else if (pid > 0) { for ( i = 0; i <10; i++) { sleep(1); pthread_mutex_lock(&mm->mutex); mm->num += 2; printf("-parent---num+=2 %d\n", mm->num); pthread_mutex_unlock(&mm->mutex); } wait(NULL); } pthread_mutexattr_destroy(&mm->mutexattr); //销毁mutex属性对象 pthread_mutex_destroy(&mm->mutex); //销毁mutex munmap(mm,sizeof(*mm)); //释放映射区 return 0; } |
文件锁
借助 fcntl函数来实现锁机制。 操作文件的进程没有获得锁时，可以打开，但无法执行read、write操作。
fcntl函数： 获取、设置文件访问控制属性。
int fcntl(int fd, int cmd, ... /* arg */ );
参2：
F_SETLK (struct flock *) 设置文件锁(trylock)
F_SETLKW (struct flock *) 设置文件锁(lock)W -->wait
F_GETLK (struct flock *) 获取文件锁
参3：
struct flock {
...
short l_type; 锁的类型：F_RDLCK 、F_WRLCK 、F_UNLCK
short l_whence; 偏移位置：SEEK_SET、SEEK_CUR、SEEK_END
off_t l_start; 起始偏移：1000
off_t l_len; 长度：0表示整个文件加锁
pid_t l_pid; 持有该锁的进程ID：(F_GETLKonly)
...
};
进程间文件锁示例
多个进程对加锁文件进行访问：
#include #include #include void sys_err(char *str) { perror(str); exit(1); } int main(int argc, char *argv[]) { int fd; struct flock f_lock; if (argc < 2) { printf("./a.outfilename\n"); exit(1); } if ((fd = open(argv[1],O_RDWR)) < 0) sys_err("open"); //f_lock.l_type =F_WRLCK; /*选用写琐*/ f_lock.l_type =F_RDLCK; /*选用读琐*/ f_lock.l_whence = SEEK_SET; f_lock.l_start = 0; f_lock.l_len = 0; /* 0表示整个文件加锁 */ fcntl(fd, F_SETLKW,&f_lock); printf("getflock\n"); sleep(10); f_lock.l_type = F_UNLCK; fcntl(fd, F_SETLKW,&f_lock); printf("unflock\n"); close(fd); return 0; } |
依然遵循“读共享、写独占”特性。但！如若进程不加锁直接操作文件，依然可访问成功，但数据势必会出现混乱。
【思考】：多线程中，可以使用文件锁吗？
多线程间共享文件描述符，而给文件加锁，是通过修改文件描述符所指向的文件结构体中的成员变量来实现的。因此，多线程中无法使用文件锁。
哲学家用餐模型分析
多线程版：
选用互斥锁mutex，如创建5个， pthread_mutex_t m[5];
模型抽象：
5个哲学家 --> 5个线程； 5支筷子 --> 5把互斥锁 int left(左手)， right(右手)
5个哲学家使用相同的逻辑，可通用一个线程主函数，void *tfn(void *arg)，使用参数来表示线程编号：int i = (int)arg;
哲学家线程根据编号知道自己是第几个哲学家，而后选定锁，锁住，吃饭。否则哲学家thinking。
A B C D E
5支筷子，在逻辑上形成环：0 1 2 3 4 分别对应5个哲学家：
所以有：
if(i== 4)
left= i, right = 0;
else
left= i, right = i+1;
振荡：如果每个人都攥着自己左手的锁，尝试去拿右手锁，拿不到则将锁释放。过会儿五个人又同时再攥着左手锁尝试拿右手锁，依然拿不到。如此往复形成另外一种极端死锁的现象——振荡。
避免振荡现象：只需5个人中，任意一个人，拿锁的方向与其他人相逆即可(如：E，原来：左：4，右：0现在：左：0， 右：4)。
所以以上if else语句应改为：
if(i== 4)
left= 0, right = i;
else
left= i, right = i+1;
而后，首先应让哲学家尝试加左手锁：
while {
pthread_mutex_lock(&m[left]); 如果加锁成功，函数返回再加右手锁，
如果失败，应立即释放左手锁，等待。
若，左右手都加锁成功--> 吃 --> 吃完 --> 释放锁(应先释放右手、再释放左手，是加锁顺序的逆序)
}
主线程(main)中，初始化5把锁，销毁5把锁，创建5个线程(并将i传递给线程主函数)，回收5个线程。
避免死锁的方法：
1. 当得不到所有所需资源时，放弃已经获得的资源，等待。
2.保证资源的获取顺序，要求每个线程获取资源的顺序一致。如：A获取顺序1、2、3；B顺序应也是1、2、3。若B为3、2、1则易出现死锁现象。
多进程版
相较于多线程需注意问题：
需注意如何共享信号量 (注意：坚决不能使用全局变量 sem_t s[5])
实现：
main函数中：
循环sem_init(&s[i], 0, 1); 将信号量初值设为1，信号量变为互斥锁。
循环 sem_destroy(&s[i]);
循环创建 5 个子进程。 if(i < 5) 中完成子进程的代码逻辑。
循环回收 5 个子进程。
子进程中：
if(i == 4)
left = 0, right == 4;
else
left = i, right = i+1;
while(1) {
使用sem_wait(&s[left]) 锁左手，尝试锁右手，若成功 --> 吃；若不成功 --> 将左手锁释放。
吃完后， 先释放右手锁，再释放左手锁。
}
【重点注意】：
直接将sem_t s[5]放在全局位置，试图用于子进程间共享是错误的！应将其定义放置与mmap共享映射区中。main中：
sem_t *s =mmap(NULL, sizeof(sem_t) * 5, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON， -1， 0);
使用方式：将s当成数组首地址看待，与使用数组s[5]没有差异。
1019
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
