Linux多线程可重入函数

Reentrant和Thread-safe

在单线程程序中,整个程序都是顺序执行的,一个函数在同一时刻只能被一个函数调用,但在多线程中,由于并发性,一个函数可能同时被多个函数调用,此时这个函数就成了临界资源,很容易造成调用函数处理结果的相互影响,如果一个函数在多线程并发的环境中每次被调用产生的结果是不确定的,我们就说这个函数是"不可重入的"/"线程不安全"的。为了解决这个问题,POSIX多线程库提出了一种机制,用来解决多线程环境中的线程数据私有化问题,这套机制的主要思想是利用同步和互斥维护一个同名不同值的表,这个表会维护每个线程自己的资源地址,表面上是同一个变量,实质上这个变量在不同的线程中的地址是不一样,这样就保证了每个线程其实都在使用自己的资源,实现了"thread-safe"。

其实,随着多线程程序的逐渐流行,除了这种利用系统机制保护线程私有数据的方法,还有一部分人重新编写了一些多线程库函数,这些函数的主要特点就是实现了算法和数据的分离,函数内部只负责实现算法,需要的数据由线程传入,这样就保证了函数的多线程安全,eg


  1. char *asctime(const struct tm *tm); 
  2. char *asctime_r(const struct tm *tm, char *buf);    //这个就是asctime的thread-safe版,有_r后缀 

但由于接口不同,完全重写的函数推广尚需时日。

当下用的更多的是使用_REENTRANT来在原来的函数的基础上改造,如果编译的时候定义了这个宏,相关的库函数就会被编译成"thread-safe"的版本。

模型

如果要查看这些函数的man手册,可以安装相关的man手册


  1. pthread_key_t key           //创建用于保护线程私有资源的 
  2. keypthread_once_t once_key     //创建用于初始化key的once_key,要求用PTHREAD_INIT_ONCE来赋值,否则结果不确定 
  3.  
  4. pthread_key_create()        //创建 
  5. keypthread_once()              //初始化 
  6. keypthread_getspedifc()        //从key表中获得线程私有资源的地址 
  7.  
  8. pthread_setspedifc()        //将线程私有资源的地址放到key中... 

例子

表面上每个函数调用了reverse()都会得到rev的地址,其实这个rev地址在不同的线程中并不相同,一旦一个线程调用了reverse()函数,函数首先会到key标识的表中去搜索这个线程以前是否调用过这个函数,如果调用过,就将表中属于这个线程的rev地址返回,如果没有,就分配rev,并将该线程和它的专属rev地址注册到表中,这样就把reverse()打造成了一个可重入的函数。


  1. #include<stdio.h> 
  2. #include<pthread.h> 
  3. #include<stdlib.h> 
  4. #include<string.h> 
  5.  
  6. pthread_key_t key; 
  7. pthread_once_t once_key=PTHREAD_ONCE_INIT; 
  8.  
  9. #ifdef _REENTRANT 
  10. void myDestructor(void*p){ 
  11.     free(p); 
  12. void myCreateKey(void){    //创建key 
  13.     pthread_key_create(&key,myDestructor); 
  14. #endif 
  15.  
  16. char* reverse(char* buf,int len){ 
  17. #ifdef _REENTRANT 
  18.     //初始化key 
  19.     pthread_once(&once_key,myCreateKey);  //从key中获取一个thread-specific的数据 
  20.     char* rev=(char*)pthread_getspecific(key); 
  21.     if(NULL==rev){ 
  22.         rev=(char*)malloc(len+1);        //将thread-specific的数据放到key中 
  23.         pthread_setspecific(key,rev); 
  24.     } 
  25. #else 
  26.     static char rev[100]; 
  27. #endif 
  28.     bzero(rev,sizeof(rev));    //翻转buf 
  29.     while(len--) 
  30.         rev[len]=*buf++; 
  31.     return rev; 
  32. void* fcn1(void* p){ 
  33.     while(1){ 
  34.         char buf[100]="123456789"; 
  35.         printf("[%lu]:%s\n",pthread_self(),buf); 
  36.         char* rev=reverse(buf,strlen(buf)); 
  37.         sleep(1); 
  38.         printf("[%lu]:%s\n",pthread_self(),rev); 
  39.     } 
  40.  
  41. void* fcn2(void* p){ 
  42.     while(1){ 
  43.         char buf[100]="abcdef"; 
  44.         printf("[%lu]:%s\n",pthread_self(),buf);         
  45.         char* rev=reverse(buf,strlen(buf)); 
  46.         sleep(2);         
  47.         printf("[%lu]:%s\n",pthread_self(),rev); 
  48.  
  49.     } 
  50. }int main(int argc, const char *argv[]){ 
  51.     pthread_t tid[4]; 
  52.     pthread_create(&tid[0],NULL,fcn1,NULL); 
  53.     pthread_create(&tid[1],NULL,fcn2,NULL); 
  54.     pause();     
  55.     return 0; 
  56. }  

本文作者:佚名

来源:51CTO

时间: 2024-08-22 15:06:24

Linux多线程可重入函数的相关文章

【Linux】可重入函数和线程安全的区别与联系【转】

转自:http://blog.csdn.net/scenlyf/article/details/52074444 版权声明:本文为博主原创文章,未经博主允许不得转载. *****可重入函数       函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入.       当程序运行到某一个函数的时候,可能因为硬件中断或者异常而使得在用户正在执行的代码暂时终端转而进入你内核,这个时候如有一个信号需要被处理,而处理的这个信号的时候又会重新调用刚才中断的函数,如果函数内部有

简介Linux中的可重入函数和不可重入函数

可重入函数 可重入函数(即可以被中断的函数)可以被一个以上的任务调用,而不担心数据破坏.可重入函数在任何时候都可以被中断,而一段时间之后又可以恢复运行,而相应的数据不会破坏或者丢失. 可重入函数使用的变量有两种情况: 1.使用局部变量,变量保存在CPU寄存器中或者堆栈中: 2.使用全局变量,但是这时候要注意保护全局变量(防止任务中断后被其它任务改变变量). void strcpy(*dest,*src) { while(* dest++ = *src ++){;} *dest = NUL; }

linux编程基础(六) 可重入函数、sig_atomic_t类型和volatile限定符

一. POSIX 中对可重入和线程安全这两个概念的定义: Reentrant Function:A function whose effect, when called by two or more threads,is guaranteed to be as if the threads each executed the function one after another in an undefined order, even if the actual execution is inte

2信号处理之:信号产生原因,进程处理信号行为,信号集处理函数,PCB的信号集,sigprocmask()和sigpending(),信号捕捉设定,sigaction,C标准库信号处理函数,可重入函数,

 1信号产生原因 2.进程处理信号行为 manpage里信号3中处理方式: SIG_IGN SIG_DFL                                            默认Term动作 a signal handling function 进程处理信号 A默认处理动作 term   中断 core    core(调试的时候产生) gcc –g file.c     ulimit –c 1024     gdb a.out core ign      忽略 stop

什么是可重入函数

什么叫可重入: 可重入是一个并发下才有的概念.如果说,程序是串行的,自然也就不会有可重入这回事了.因为并发,所以任何个步骤都可能在运行中途被中断,然后跑另一个代码.这样就会出现一种可能,比如说两段代码都操作了一个全局变量,就会造成意想不到的错误. 可重入函数指的是,有多个线程在并发的执行一个函数.这个时候,如果两个函数会操作同一个全局的变量.这就是上面说的场景了. 什么样的函数不可重入: 函数体内使用了静态的数据结构(全局变量等). 函数体内调用了malloc()或者free()函数. 函数体内

可重入函数与不可重入函数

主要用于多任务环境中,一个可重入的函数简单来说就是可以被中断的函数,也就是说,可以在这个函数执行的任何时刻中断它,转入OS调度下去执行另外一段代码,而返回控制时不会出现什么错误:而不可重入的函数由于使用了一些系统资源,比如全局变量区,中断向量表等,所以它如果被中断的话,可能会出现问题,这类函数是不能运行在多任务环境下的. 也可以这样理解,重入即表示重复进入,首先它意味着这个函数可以被中断,其次意味着它除了使用自己栈上的变量以外不依赖于任何环境(包括static),这样的函数就是purecode(

银行取款[多线程]{使用重入锁Lock接口ReentrantLock锁确保线程同步}

经典例子:老婆(朱丽叶)老公(罗密欧),使用银行卡和存折,或者网银等,同时对同一账户操作的安全问题.  此处用多线程实现,同时取款的模拟实现,使用使用Lock接口ReentrantLock锁确保线程同步,查看取款安全隐患问题,代码如下: -----------------------------------------------------------------------------------------------------------------------------------

linux可重入、异步信号安全和线程安全

一 可重入函数 当一个被捕获的信号被一个进程处理时,进程执行的普通的指令序列会被一个信号处理器暂时地中断.它首先执行该信号处理程序中的指令.如果从信号处理程序返回(例如没有调用exit或longjmp),则继续执行在捕获到信号时进程正在执行的正常指令序列(这和当一个硬件中断发生是所发生的事情相似.)但是在信号处理器里,我们并不知道当信号被捕获时进程正在执行哪里的代码. 如果进程正使用malloc在它的堆上分配额外的内存,而此时由于捕捉到信号而插入执行该信号处理程序,其中又调用了malloc,这会

Linux多线程编程小结

前一段时间由于开题的事情一直耽搁了我搞Linux的进度,搞的我之前学的东西都遗忘了,非常烦躁的说,如今抽个时间把之前所学的做个小节.文章内容主要总结于<Linux程序设计第3版>. 1.Linux进程与线程 Linux进程创建一个新线程时,线程将拥有自己的栈(由于线程有自己的局部变量),但与它的创建者共享全局变量.文件描写叙述符.信号句柄和当前文件夹状态. Linux通过fork创建子进程与创建线程之间是有差别的:fork创建出该进程的一份拷贝,这个新进程拥有自己的变量和自己的PID,它的时间