转载时请注明出处和作者联系方式
文章出处:http://www.limodev.cn/blog
作者联系方式:李先静 <xianjimli at hotmail dot com>
Linux下的多线程编程使用pthread(POSIX Thread)函数库,使用时包含头文件pthread.h,链接共享库libpthread.so。这里顺便说一下gcc链接共享库的方式:-L用来指 定共享库所在目录,系统库目录不用指定。-l用来指定要链接的共享库,只需要指定库的名字就行了,如:-lpthread,而不是 -llibpthread.so。看起来有点怪,这样做的原因是共享库通常带有版本号,指定全文件名就意味着你要绑定到特定版本的共享库上,只指定名字则 在可以运行时通过环境变量来选择要使用的共享库,这样能够给软件升级带来的方便。
pthread函数库的使用相对比较简单,读者可以在终端下运行man pthread_create阅读相关函数的手册,也可以到网上找些例子参考。具体使用方法我们就不讲了,这里介绍一下初学者常犯的错误:
o 用临时变量作为线程参数的问题。
#include <stdio.h> #include <pthread.h> #include <assert.h> void* start_routine(void* param) { char* str = (char*)param; printf("%s:%s/n", __func__, str); return NULL; } pthread_t create_test_thread() { pthread_t id = 0; char str[] = "it is ok!"; pthread_create(&id, NULL, start_routine, str); return id; } int main(int argc, char* argv[]) { void* ret = NULL; pthread_t id = create_test_thread(); pthread_join(id, &ret); return 0; }
分析:由于新线程和当前线程是并发的,谁先谁后是无法预测的。可能create_test_thread 已经执行完了,str已经被释放了,新线程才拿到这参数,此时它的内容已经无法确定了,打印出的字符串自然是随机的。
o 线程参数共享的问题。
#include <stdio.h> #include <pthread.h> #include <assert.h> void* start_routine(void* param) { int index = *(int*)param; printf("%s:%d/n", __func__, index); return NULL; } #define THREADS_NR 10 void create_test_threads() { int i = 0; void* ret = NULL; pthread_t ids[THREADS_NR] = {0}; for(i = 0; i < THREADS_NR; i++) { pthread_create(ids + i, NULL, start_routine, &i); } for(i = 0; i < THREADS_NR; i++) { pthread_join(ids[i], &ret); } return ; } int main(int argc, char* argv[]) { create_test_threads(); return 0; }
分析:由于新线程和当前线程是并发的,谁先谁后是无法预测的。i在不断变化,所以新线程拿到的参数值是无法预知的,打印出的字符串自然也是随机的。
o 虚假并发。
#include <stdio.h> #include <pthread.h> #include <assert.h> void* start_routine(void* param) { int index = *(int*)param; printf("%s:%d/n", __func__, index); return NULL; } #define THREADS_NR 10 void create_test_threads() { int i = 0; void* ret = NULL; pthread_t ids[THREADS_NR] = {0}; for(i = 0; i < THREADS_NR; i++) { pthread_create(ids + i, NULL, start_routine, &i); pthread_join(ids[i], &ret); } return ; } int main(int argc, char* argv[]) { create_test_threads(); return 0; }
分析:因为pthread_join会阻塞直到线程退出,所以这些线程实际上是串行执行的,一个退出了,才创建下一个。当年一个同事写了一个多线程的测试程序,就是这样写的,结果没有测试出一个潜伏的问题,直到产品运行时,这个问题才暴露出来。
访问线程共享的数据时要加锁,让访问串行化,否则就会出问题。比如,可能你正在访问的双向链表的某个结点时,它已经被另外一个线程删掉了。加锁的方 式有很多种,像互斥锁(mutex= mutual exclusive lock),信号量(semaphore)和自旋锁(spin lock)等都是常用的,它们的使用同样很简单,我们就不多说了。
在加锁/解锁时,初学者常犯两个错误:
o 存在遗漏解锁的路径。初学者常见的做法就是,进入某个临界函数时加锁,在函数结尾的地方解锁,我甚至见过这种写法:
{ /*这里加锁*/ … return …; /*这里解锁*/ }
如果你也犯了这种错误,应该好好反思一下。有时候,return的地方太多,在某一处忘记解锁是可能的,就像内存泄露一样,只是忘记解锁的后果更严重。像下面这个例子:
Ret dlist_insert(DList* thiz, size_t index, void* data) { DListNode* node = NULL; DListNode* cursor = NULL; return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS); dlist_lock(thiz); if((node = dlist_create_node(thiz, data)) == NULL) { dlist_unlock(thiz); return RET_OOM; } if(thiz->first == NULL) { thiz->first = node; dlist_unlock(thiz); return RET_OK; } ... dlist_unlock(thiz); return RET_OK; }
如果一个函数有五六个甚至更多的地方返回,遗忘一两个地方是很常见的,即使没有忘记,每个返回的地方都要去解锁和释放相关资源也是很麻烦的。在这种情况下,我们最好是实现单入口单出的函数,常见的做法有两种:
一种是使用goto语句(在linux内核里大量使用)。示例如下:
Ret dlist_insert(DList* thiz, size_t index, void* data) { Ret ret = RET_OK; DListNode* node = NULL; DListNode* cursor = NULL; return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS); dlist_lock(thiz); if((node = dlist_create_node(thiz, data)) == NULL) { ret = RET_OOM; goto done; } if(thiz->first == NULL) { thiz->first = node; goto done; } ... done: dlist_unlock(thiz); return ret; }
另外一种是使用do{}while(0);语句,出于受教科书的影响(不要用goto语句),我习惯了这种做法。示例如下:
Ret dlist_insert(DList* thiz, size_t index, void* data) { Ret ret = RET_OK; DListNode* node = NULL; DListNode* cursor = NULL; return_val_if_fail(thiz != NULL, RET_INVALID_PARAMS); dlist_lock(thiz); do { if((node = dlist_create_node(thiz, data)) == NULL) { ret = RET_OOM; break; } if(thiz->first == NULL) { thiz->first = node; break; } ... }while(0); dlist_unlock(thiz); return ret; }
o 加锁顺序的问题。有时候为了提高效率,常常降低加锁的粒度,访问时不是用一个锁锁住整个数据结构,而是用多个锁来控制数据结构各个部分。这样一个线程访问 数据结构的这部分时,另外一个线程还可以访问数据结构的其它部分。但是在有的情况下,你需要同时锁几个锁,这时就要注意了:所有线程一定要按相同的顺序加 锁,相反的顺序解锁。否则就可能出现死锁,两个线程都拿到对方需要的锁,结果出现互相等待的情况。