首页 > 代码库 > 线程同步
线程同步
线程同步
多个线程共享相同的内存时, 需要确保每个线程看到的数据视图一致. 如果每个线程的数据在其他线程不会用到, 或者变量是只读的, 这样没有一致性问题. 但是如果多个线程需要共享变量时, 就需要进行线程同步了.
举个例子, 有线程A读取变量并加1, 可分为以下三步：
1.从内存读入变量到寄存器
2.寄存器中进行变量值增加
3.把新值写回内存单元.
这时如果有线程B在 2 和 3 期间读取变量值, 就可能会得到不一致的值. 下面介绍几种常用同步机制.
互斥量
互斥量确保同一时间只有一个线程访问数据, 从本质上来说是一把锁. 在访问数据前要加锁, 访问数据后释放锁.
如果有多个线程同时试图锁住数据, 则只有一个线程能获取锁, 变成运行状态( 谁能第一个获取锁与具体实现有关). 其它线程将被阻塞直到锁释放. 在这种方式下, 只有一个线程可以向前执行.
互斥变量使用 pthread_mutex_t 数据类型表示. 在使用前需要用 pthread_mutex_init( ) 初始化, 释放内存前需要调用 pthread_mutex_destroy( );
如果线程不希望被阻塞, 它可以使用 pthread_mutex_trylock ( ) 尝试对互斥量加锁, 如果互斥量可用, 则成功锁住; 否则锁住失败, 返回EBUSY, 线程不阻塞.
#include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex,const struct timespec *restrict tsptr); int pthread_mutex_unlock(pthread_mutex_t *mutex); All return: 0 if OK, error number on failure
下面是是APUE上面一个简单的程序. 由于pthread不是系统默认库, 所以在编译是注意加入-lpthread.
gcc mutex.c -o mutex -lpthread
#include "apue.h" #include <pthread.h> /* * * 加入引用计数, 确保在所有使用该对象的线程完成数据访问之前, 该对象内存空间不会被释放. * 在加1, 减1 以及判断引用计数是否为0之前必须锁住互斥量. * * * */ struct foo{ int f_count; pthread_mutex_t f_lock; //互斥变量 }; //调用malloc() 动态分配互斥变量 struct foo *foo_alloc(void){ struct foo *fp; if((fp = malloc(sizeof(struct foo))) != NULL){ fp->f_count = 1; //初始化互斥变量 if(pthread_mutex_init(&fp->f_lock, NULL) != 0){ free(fp); return (NULL); } } return (fp); } //加1操作 void foo_hold(struct foo *fp){ pthread_mutex_lock(&fp->f_lock); fp->f_count++; printf("f_count = %d\n", fp->f_count); pthread_mutex_unlock(&fp->f_lock); } //减1操作, 如果最后一个引用被释放, 释放对象内存空间. void foo_rele(struct foo *fp){ pthread_mutex_lock(&fp->f_lock); fp->f_count--; printf("f_count = %d\n", fp->f_count); if(0 == fp->f_count){ printf("free fp\n"); pthread_mutex_unlock(&fp->f_lock); pthread_mutex_destroy(&fp->f_lock); free(fp); }else{ pthread_mutex_unlock(&fp->f_lock); } } //线程 1 执行函数 void *thr_fn1(void *arg){ struct foo *fp = (struct foo*)arg; printf("thread 1 starting\n"); foo_rele(fp); printf("thread 1 exit\n"); pthread_exit((void *)1); } //线程 2 执行函数 void *thr_fn2(void *arg){ struct foo *fp = (struct foo *)arg; printf("thread 2 starting\n"); foo_hold(fp); foo_hold(fp); printf("thread 2 exit\n"); pthread_exit((void *)2); } int main(void){ pthread_t tid1, tid2; int err; void *pret; struct foo *fp; fp = foo_alloc(); //创建线程 if((err = pthread_create(&tid1, NULL, thr_fn1, (void *)fp)) != 0){ err_quit("create thread 1 error\n", strerror(err)); } if((err = pthread_create(&tid2, NULL, thr_fn2, (void *)fp)) != 0){ err_quit("create thread 2 error\n", strerror(err)); } //获取线程退出状态 pthread_join(tid1, &pret); printf("thread 1 exit code is : %ld\n", (long)pret); pthread_join(tid2, &pret); printf("thread 2 exit code is : %ld\n", (long)pret); exit(0); }
程序运行结果如下, 这里有个问题, 那就是线程1在线程2运行之前就已经结束. 既然 fp 指针已经被释放掉了. 为何仍然在线程2中得以引用呢 ? 答案是野指针 ! 之前 fp 指向的内存没有被占用, 但是也可能被占用, 引起内存泄露.
thread 1 starting thread 2 starting f_count = 0 free fp thread 1 exit f_count = 1 f_count = 2 thread 2 exit thread 1 exit code is : 1 thread 2 exit code is : 2
避免死锁
产生死锁的几种情况
1.线程对同一互斥量多次加锁, 类似下面这种
pthread_mutex_lock(mutex);
pthread_mutex_lock(mutex);
pthread_mutex_unlock(mutex);
pthread_mutex_unlock(mutex);
第二行阻塞, 发生死锁. 这种情况比较容易避免, 取消多次加锁即可.
2.多个互斥量, 且不同线程各锁住一个互斥量, 并都在请求另一个互斥量阻塞.
//thread A pthread_mutex_lock(mutex1); pthread_mutex_lock(mutex2); pthread_mutex_unlock(mutex2); pthread_mutex_unlock(mutex1); //thread B pthread_mutex_lock(mutex2); pthread_mutex_lock(mutex1); pthread_mutex_unlock(mutex1); pthread_mutex_unlock(mutex2);
互相请求对方所占资源, 导致死锁. 避免办法是各个进程对互斥量加锁的顺序要一致. 可以是使用一个hash表锁实现.
下面程序来自APUE, 只是一种解决办法, 没有具体测试代码. 这里有两个参考文章.
http://www.cnblogs.com/xbf9xbf/p/4764747.html
https://segmentfault.com/q/1010000007227951
#include "apue.h" #include <pthread.h> #define NHASH 29 //哈希大值 #define HASH(fp) (((unsigned long)fp) % NHASH) //简单hash取模 struct foo *fh[NHASH]; //哈希表, 链表解决散列冲突 //初始化 只对静态变量分配的互斥量 pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER; struct foo{ int f_count; pthread_mutex_t f_lock; //互斥变量 struct foo *f_next; int f_id; }; //调用malloc() 动态分配互斥变量 struct foo *foo_alloc(void){ int idx; struct foo *fp; if((fp = malloc(sizeof(struct foo))) != NULL){ fp->f_count = 1; //初始化互斥变量 if(pthread_mutex_init(&fp->f_lock, NULL) != 0){ free(fp); return (NULL); } idx = HASH(fp); // 先对散列表加锁 pthread_mutex_lock(&hashlock); //头插 fp->f_next = fh[idx]; fh[idx] =fp->f_next; // 这里要加锁, 对于其它线程是全局可见的, 所以要先阻塞其它请求新结构的线程 pthread_lock(&fp->f_lock); pthread_unlock(&hashlock); /* 其它初始化操作 */ pthread_mutex_unlock(&fp->f_lock); } return (fp); } //加1操作 void foo_hold(struct foo *fp){ pthread_mutex_lock(&fp->f_lock); fp->f_count++; pthread_mutex_unlock(&fp->f_lock); } /* 第二版这个函数有错误, 这里是第三版的 */ struct foo *foo_find(int id){ struct foo *fp; /* 锁住hash表 */ pthread_mutex_lock(&hashlock); for(fp = fh[HASH(id)]; fp != NULL, fp = fp->f_next){ //命中 增加其引用计数 if(fp->f_id == id){ foo_hold(fp); break; } } pthread_mutex_unlock(&hashlock); return (fp); } //减1操作. void foo_rele(struct foo *fp){ struct foo *tfp; int idx; //锁住此节点 pthread_mutex_lock(&fp->f_lock); //是最后一个结构 if(1 == fp->f_count){ // 这里需要先解锁然后重新获取 // 为什么要重新获取呢 ? 因为释放节点必须先对其解锁, 才能进行操作! // 为什么是先获取hashlock 再获取 fp节点的锁 ? 考虑一种情况 // foo_rele获取fp的锁, 请求hashlock锁, 而foo_find获取了此hashlock的锁, 请求此fp, 造成死锁 pthread_mutex_unlock(&fp->f_lock); pthread_mutex_unlock(&hashlock); pthread_mutex_lock(&fp->f_lock); //重新判断, 防止前面调整锁的顺序, 而其它线程又对此引用计数加1. if(1 != fp_f_count){ fp->f_count--; pthread_mutex_unlock(&fp->f_lock); pthread_mutex_unlock(&hashlock); return; } idx = HASH(fp); tfp = fh[idx]; //链表查找 if(tfp == tp){ fh[idx] = fp->f_next; }else{ while(tfp->f_index != fp) tfp = tfp->f_next; tfp->f_next = fp->f_next; } pthread_mutex_unlock(&fp->f_lock); pthread_mutex_unlock(&hashlock); pthread_mutex_destroy(&fp->f_lock); free(fp); }else{ //不是最后一个结构 fp->f_count--; pthread_mutex_unlock(&fp->f_lock); } }
这里可以对锁进行简化, 用hash锁赖保护结构引用计数, 结构互斥量保护结构体内的其它任何数据. 这种锁的粒度较粗, 但是围绕hash锁和结构互斥量锁的排序问题就没有了
对上面程序稍作修改
#include "apue.h" #include <pthread.h> #define NHASH 29 //哈希大值 #define HASH(fp) (((unsigned long)fp) % NHASH) //简单hash取模 struct foo *fh[NHASH]; //哈希表, 链表解决散列冲突 //初始化 只对静态变量分配的互斥量 pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER; struct foo{ int f_count; pthread_mutex_t f_lock; //互斥变量 struct foo *f_next; int f_id; }; //调用malloc() 动态分配互斥变量 struct foo *foo_alloc(void){ int idx; struct foo *fp; if((fp = malloc(sizeof(struct foo))) != NULL){ fp->f_count = 1; //初始化互斥变量 if(pthread_mutex_init(&fp->f_lock, NULL) != 0){ free(fp); return (NULL); } idx = HASH(fp); // 先对散列表加锁 pthread_mutex_lock(&hashlock); //头插 fp->f_next = fh[idx]; fh[idx] =fp->f_next; // 这里要加锁, 对于其它线程是全局可见的, 所以要先阻塞其它请求新结构的线程 pthread_lock(&fp->f_lock); pthread_unlock(&hashlock); /* 其它初始化操作 */ pthread_mutex_unlock(&fp->f_lock); //第二版中此处应该有错误, 少了这句话. } return (fp); } //加1操作 void foo_hold(struct foo *fp){ pthread_mutex_lock(&hashlock); fp->f_count++; pthread_mutex_unlock(&hashlock); } /* 第二版这个函数有错误, 这里是第三版的 */ struct foo *foo_find(int id){ struct foo *fp; /*hash锁保护对象引用计数 */ pthread_mutex_lock(&hashlock); for(fp = fh[HASH(id)]; fp != NULL, fp = fp->f_next){ //命中 增加其引用计数 if(fp->f_id == id){ fp->f_count++; break; } } pthread_mutex_unlock(&hashlock); return (fp); } //减1操作. void foo_rele(struct foo *fp){ struct foo *tfp; int idx; //锁住hash表 pthread_mutex_lock(&hashlock); //是最后一个结构 if(--fp->f_count == 0){ idx = HASH(fp); tfp = fh[idx]; //链表查找 if(tfp == tp){ fh[idx] = fp->f_next; }else{ while(tfp->f_index != fp) tfp = tfp->f_next; tfp->f_next = fp->f_next; } pthread_mutex_unlock(&hashlock); pthread_mutex_destroy(&fp->f_lock); free(fp); }else{ //不是最后一个结构 pthread_mutex_unlock(&fp->f_lock); } }
读写锁
读写锁可以使得读操作比互斥量具有更高的并行性, 它有三种状态, 读加锁, 写加锁, 不加锁. 非常适合读操作远多余写操作的数据结构. 可以在读数据前加锁, 读完后释放, 写操作同样如此.
关键点
- 读写锁在读加锁状态时, 其它任何读操作都可以加锁.
- 读写锁在写加锁状态时, 其它任何操作都被阻塞(不管是加读锁还是写锁).
- 读写锁只有在无所状态下才能加写锁.
读写锁实现方式各不相同, 但是当读写锁处于读模式锁定状态时, 如果有线程试图加写锁操作, 那么其后的读锁请求将会被阻塞, 避免等待的写锁一直得不到满足.
其中一些API如下
初始与销毁
#include <pthread.h> int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t*restrict attr); int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); Both return: 0 if OK, error number on failure
加锁与解锁
#include <pthread.h> int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); All return: 0 if OK, error number on failure
#include <pthread.h> int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock); int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock); Both return: 0 if OK, error number on failure
#include <pthread.h> #include <time.h> int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrictrwlock,const struct timespec*restrict tsptr); int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrictrwlock,const struct timespec *restric ttsptr);
下面程序说明了读写锁的使用, 四个线程, 两个读线程, 两个写线程.
#include "apue.h" #include <pthread.h> /* 初始化读写锁 */ pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER; /* 全局资源 */ int global_num = 10; /* 读锁线程 */ void *thread_read_lock(void *arg){ char *pthread_name = (char *)arg; while(1){ /* 读加锁 */ pthread_rwlock_rdlock(&rwlock); printf("读线程 %s 进入临界区, global_num = %d\n", pthread_name, global_num); sleep(1); printf("读线程 %s 退出临界区\n", pthread_name); pthread_rwlock_unlock(&rwlock); sleep(1); } return NULL; } /* 写锁线程 */ void *thread_write_lock(void *arg){ char *pthread_name = (char *)arg; while(1){ /* 写加锁 */ pthread_rwlock_wrlock(&rwlock); global_num++; printf("写线程 %s 进入临界区, global_num = %d\n",pthread_name, global_num); sleep(1); printf("写线程 %s 退出临界区\n", pthread_name); pthread_rwlock_unlock(&rwlock); /* 这里多一秒 是因为两个写锁一起请求会导致后面的读锁饥饿. */ sleep(2); } } int main(void){ pthread_t tid_r1, tid_r2, tid_w1, tid_w2; int err; //创建四个线程, 两个读, 两个写. if((err = pthread_create(&tid_r1, NULL, thread_read_lock, "read1")) != 0) err_quit("create thread r1 error\n", strerror(err)); if((err = pthread_create(&tid_r2, NULL, thread_read_lock, "read2")) != 0) err_quit("create thread r1 error\n", strerror(err)); if((err = pthread_create(&tid_w1, NULL, thread_write_lock, "write1")) != 0) err_quit("create thread w1 error\n", strerror(err)); if((err = pthread_create(&tid_w2, NULL, thread_write_lock, "write2")) != 0) err_quit("create thread w2 error\n", strerror(err)); /* 防止主线程提前退出 */ if((err = pthread_join(tid_r1, NULL)) != 0) err_quit("cant‘t join with thread 1\n", strerror(err)); exit(0); }
运行结果 :
读线程 read2 进入临界区, global_num = 10 读线程 read1 进入临界区, global_num = 10 读线程 read2 退出临界区 读线程 read1 退出临界区 写线程 write1 进入临界区, global_num = 11 写线程 write1 退出临界区 写线程 write2 进入临界区, global_num = 12 写线程 write2 退出临界区 读线程 read2 进入临界区, global_num = 12 读线程 read1 进入临界区, global_num = 12 读线程 read2 退出临界区 读线程 read1 退出临界区 写线程 write1 进入临界区, global_num = 13 写线程 write1 退出临界区 写线程 write2 进入临界区, global_num = 14 写线程 write2 退出临界区 读线程 read2 进入临界区, global_num = 14 读线程 read1 进入临界区, global_num = 14
可以看出, 读锁可以同时进入临界区, 而写锁中间等待了一秒都没有其它线程能进来.
条件变量
暂时还没学会
线程同步
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。