首页 > 代码库 > Linux互斥与同步应用(一):posix线程及线程间互斥
Linux互斥与同步应用(一):posix线程及线程间互斥
【版权声明:尊重原创,转载请保留出处:blog.csdn.net/shallnet 或 .../gentleliu,文章仅供学习交流,请勿用于商业用途】
有了进程的概念,为何还要使用线程呢?
首先,回忆一下上一个系列我们讲到的IPC,各个进程之间具有独立的内存空间,要进行数据的传递只能通过通信的方式进行,这种方式不仅费时,而且很不方便。而同一个进程下的线程是共享全局内存的,所以一个线程的数据可以在另一个线程中直接使用,及快捷又方便。
其次,在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。
但是,伴随着这些优点,线程却带来了同步与互斥的问题。下面先讲讲线程基本函数:
- 线程的创建pthread_create
#include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
一个线程由一个线程ID(参数thread)标识,新的线程创建成功,其值通过指针thread返回。
参数attr为线程属性(比如:优先级、初始栈大小等),通常我们使用默认设置,设为NULL。
参数start_routine为一个函数指针,指向线程执行的函数,最后参数arg为函数start_routine唯一参数,如果需要传递多个参数,需要打包为结构,然后将其地址传给该函数。
pthread_create成功时返回0,失败为非0值,这和其他linux系统调用的习惯不一样。
- pthread_join函数
#include <pthread.h> int pthread_join(pthread_t thread, void **retval);
通过调用该函数等待一个给定线程终止,类似于线程的waitpid函数。
该函数等待参数thread指定的线程终止,该函数会阻塞,直到线程thread终止,将线程返回的(void *)指针赋值为retval指向的位置,然后回收已经终止线程占用的所有存储器资源。
- pthread_self函数
#include <pthread.h> pthread_t pthread_self(void);
该函数用于获取线程自身线程ID。类似于进程的getpid函数。
- pthread_detach函数
#include <pthread.h> int pthread_detach(pthread_t thread);
该函数可分离可结合线程,线程可以通过以pthread_self()为参数的pthread_detach调用来分离他们自己。
一个分离线程是不能被其他线程回收或杀死的,他的存储器资源在他终止时由系统自动释放。一个可结合线程能够被其他线程收回其资源和杀死,在被其他线程收回之前,他的存储器资源是没有被释放的。在任何一个时间点上,线程是可结合的或者是可分离的。默认情况下,线程是被创建成可结合的。
为了避免存储器泄露,每个可结合线程都应该要么被其他线程现实的收回,要么通过调用pthread_detach函数被分离。
在现实的程序中,我们一般都使用分离的线程。
- pthread_exit函数
#include <pthread.h> void pthread_exit(void *retval);
该函数作用就是终止线程。如果该线程未曾分离,他的线程ID和退出状态将一直保留到调用进程内某个其他线程对他调用pthread_join。
另外,当线程函数(pthread_create第三个参数)返回时,该线程将终止;当创建该线程的进程main函数返回时,该线程也将终止。
下面给一个简单的示例:
#include <stdio.h> #include <pthread.h> #include <unistd.h> void *func_th(void *arg) { unsigned int *val = (unsigned int *)arg; printf("=======%s->%d==thread%d: %u====\n", __func__, __LINE__, *val, (unsigned int)pthread_self()); return NULL; } int main(int argc, const char *argv[]) { pthread_t tid1, tid2; int a, b; a = 1; if (0 != pthread_create(&tid1, NULL, func_th, &a)) { printf("pthread_create failed!\n"); return -1; } b = 2; if (0 != pthread_create(&tid2, NULL, func_th, &b)) { printf("pthread_create failed!\n"); return -1; } pthread_join(tid1, NULL); pthread_join(tid2, NULL); return 0; }
执行2次输出为:
# ./target_bin =======func_th->9==thread1: 3077856064==== =======func_th->9==thread2: 3069463360==== # ./target_bin =======func_th->9==thread2: 3069315904==== =======func_th->9==thread1: 3077708608====
类似于进程,线程的调度随机的。
在前面开始我们说到同一个进程内的线程是共享全局内存的,那么当多个线程同时去修改一个全局变量的时候就会出问题,如果一个线程在修改某个变量时中途被挂起,操作系统去调度另外一个线程执行,那就可能导致错误。我们无法保证操作系统对这些操作都是原子的。
在我们在现在的例子中这样去复现这种问题:一个线程对一个全局变量(100)进行读-加1-读操作,另个变量对该全局进行减1操作,我们通过sleep来实现加线程先执行,减线程在加线程的加和读之间进行,最后来查看加操作是否是我们期望的结果(101)。例子如下:
(该示例只是为了强化运行时出错,并对这种错误有一个宏观的了解而写)
#include <stdio.h> #include <pthread.h> #include <unistd.h> int gval = 100; void *func_add_th(void *arg) { int *val = (int *)arg; printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); printf("before add 1, gval=%d\n", gval); gval += 1; sleep(4);//此时add线程挂起,sub线程执行键操作 printf("after add 1, gval=%d\n", gval); return NULL; } void *func_sub_th(void *arg) { int *val = (int *)arg; printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); gval -= 1; return NULL; } int main(int argc, const char *argv[]) { pthread_t tid1, tid2; int a, b; a = 1; if (0 != pthread_create(&tid1, NULL, func_add_th, &a)) { printf("pthread_create failed!\n"); return -1; } sleep(1); //保证add线程先被调度 b = 2; if (0 != pthread_create(&tid2, NULL, func_sub_th, &b)) { printf("pthread_create failed!\n"); return -1; } pthread_join(tid1, NULL); pthread_join(tid2, NULL); return 0; }
执行结果如下:
# ./target_bin ==do func_add_th==thread1: 3078355776==== before add 1, gval=100 ==do func_sub_th==thread2: 3069963072==== after add 1, gval=100
通过输出我们可以看到sub操作在加1和读之间操作,最终读取出来的值仍然是100,不是我们期望的101。
这就是两个线程不是互斥带来的结果,所以我们希望在某某一线程一段代码执行期间,只有一个线程在运行,当运行完成之后,下一个线程运行该部分代码,所以我们需要将该部分代码加锁。这就是线程编程,也是并发编程需要考虑的问题。
解决多线程共享的问题就是使用互斥锁(mutex,即mutual exliusion)来保护共享数据。在执行某一段代码是首先要持有该互斥锁,执行完成之后再释放该锁。互斥锁是类型为pthread_mutex_t的变量。使用如下方法来加锁和解锁操作。
#include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);
首先我们需要初始化锁,初始化方法有两种,一种是静态初始化,给锁变量赋值PTHREAD_MUTEX_INITIALIZER,一种动态初始化,使用函数pthread_mutex_init。
我们使用静态方法初始化:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
当试图使用pthread_mutex_lock()获得一个已经被另外线程加锁的锁时,本线程将阻塞,直到互斥锁被解锁为止。函数pthread_mutex_trylock为获取锁的非阻塞版本,当获取失败时会立即返回。
我们修改add和sub线程函数分别如下:
void *func_add_th(void *arg) { int *val = (int *)arg; pthread_mutex_lock(&mutex);//此处加锁 printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); printf("before add 1, gval=%d\n", gval); gval += 1; sleep(4); printf("after add 1, gval=%d\n", gval); pthread_mutex_unlock(&mutex);//此处释放锁 return NULL; } void *func_sub_th(void *arg) { int *val = (int *)arg; pthread_mutex_lock(&mutex); printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); gval -= 1; pthread_mutex_unlock(&mutex); return NULL; }
执行结果为:
# ./target_bin ==do func_add_th==thread1: 3077614400==== before add 1, gval=100 after add 1, gval=101 ==do func_sub_th==thread2: 3069221696====
通过结果输出可以看到,sub操作是在add操作执行完成之后才执行的,而add线程输出结果也是我们预期的,所以我们的加锁是成功的。但是如果add线程要执行很久的话,sub线程就要阻塞很久,我们可以将sub线程加锁函数改为非阻塞版本,当加锁失败时,立即返回。
修改后的sub线程函数:
void *func_sub_th(void *arg) { int *val = (int *)arg; if (0 != pthread_mutex_trylock(&mutex)) { printf("failed to lock!\n"); return NULL; } printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); gval -= 1; pthread_mutex_unlock(&mutex); return NULL; }
运行输出为:
# ./target_bin ==do func_add_th==thread1: 3077638976==== before add 1, gval=100 failed to lock! after add 1, gval=101
当多个线程同时需要多个相同锁时,可能会出现死锁的情况。比如两个线程同时需要互斥锁1和互斥锁2,线程a先获得锁1,线程b获得锁2,这是线程a、b分别还需要锁2和锁1,但此时两个锁都被加锁了,都阻塞在那里等待对方释放锁,这样死锁就出现了。我们来实现一下死锁的情况,将之前两个例子的线程函数修改如下:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mutex_sec = PTHREAD_MUTEX_INITIALIZER; void *func_add_th(void *arg) { int *val = (int *)arg; pthread_mutex_lock(&mutex);//1. add线程先加第一个锁mutex printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); sleep(2);//等待2秒,让sub线程加第二个锁mutex_sec pthread_mutex_lock(&mutex_sec);//4. add线程加锁mutex_sec失败 printf("before add 1, gval=%d\n", gval); gval += 1; sleep(4); printf("after add 1, gval=%d\n", gval); pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex_sec); return NULL; } void *func_sub_th(void *arg) { int *val = (int *)arg; pthread_mutex_lock(&mutex_sec);//2. Sub线程比add线程先加锁mutex_sec pthread_mutex_lock(&mutex);//3. Sub线程加锁mutex失败 printf("==do %s==thread%d: %u====\n", __func__, *val, (unsigned int)pthread_self()); gval -= 1; pthread_mutex_unlock(&mutex); pthread_mutex_unlock(&mutex_sec); return NULL; }
上面两个线程按照函数注释中1-2-3-4顺序执行,运行时程序就卡在那里出现了死锁。
可以使用非阻塞版本的加锁函数来加锁,不过也要注意在第二个锁加锁不成功情况下,需要释放第一个锁再返回,不然其他线程仍然得不到第一个锁。有时在线程需要多个互斥锁时,让线程按照指定的同样顺序进行加锁也可以避免死锁。程序死锁出现时很难定位,所以程序猿在编程(尤其是在设计)时需要注意避免这个问题。
本节示例代码下载:
点击打开链接
Linux互斥与同步应用(一):posix线程及线程间互斥