linux线程浅析

linux线程浅析

2009-09-1211:58

关于linux线程

在许多经典的操作系统教科书中,总是把进程定义为程序的执行实例,它并不执行什么,只是维护应用程序所需的各种资源.而线程则是真正的执行实体.

为了让进程完成一定的工作,进程必须至少包含一个线程.如图1.

进程所维护的是程序所包含的资源(静态资源),如:地址空间,打开的文件句柄集,文件系统状态,信号处理handler,等;

线程所维护的运行相关的资源(动态资源),如:运行栈,调度相关的控制信息,待处理的信号集,等;

然而,一直以来,linux内核并没有线程的概念.每一个执行实体都是一个task_struct结构,通常称之为进程.如图2.

进程是一个执行单元,维护着执行相关的动态资源.同时,它又引用着程序所需的静态资源.通过系统调用clone创建子进程时,可以有选择性地让子进程共享父进程所引用的资源.这样的子进程通常称为轻量级进程.

linux上的线程就是基于轻量级进程,由用户态的pthread库实现的.

使用pthread以后,在用户看来,每一个task_struct就对应一个线程,而一组线程以及它们所共同引用的一组资源就是一个进程.

但是,一组线程并不仅仅是引用同一组资源就够了,它们还必须被视为一个整体.

对此,POSIX标准提出了如下要求:

1,查看进程列表的时候,相关的一组task_struct应当被展现为列表中的一个节点;

2,发送给这个"进程"的信号(对应kill系统调用),将被对应的这一组task_struct所共享,并且被其中的任意一个"线程"处理;

3,发送给某个"线程"的信号(对应pthread_kill),将只被对应的一个task_struct接收,并且由它自己来处理;

4,当"进程"被停止或继续时(对应SIGSTOP/SIGCONT信号),对应的这一组task_struct状态将改变;

5,当"进程"收到一个致命信号(比如由于段错误收到SIGSEGV信号),对应的这一组task_struct将全部退出;

6,等等(以上可能不够全);

linuxthreads

在linux2.6以前,pthread线程库对应的实现是一个名叫linuxthreads的lib.

linuxthreads利用前面提到的轻量级进程来实现线程,但是对于POSIX提出的那些要求, linuxthreads除了第5点以外,都没有实现(实际上是无能为力):

1,如果运行了A程序,A程序创建了10个线程,那么在shell下执行ps命令时将看到11个A进程,而不是1个(注意,也不是10个,下面会解释);

2,不管是kill还是pthread_kill,信号只能被一个对应的线程所接收;

3,SIGSTOP/SIGCONT信号只对一个线程起作用;

还好linuxthreads实现了第5点,我认为这一点是最重要的.如果某个线程"挂"了,整个进程还在若无其事地运行着,可能会出现很多的不一致状态.进程将不是一个整体,而线程也不能称为线程.

或许这也是为什么linuxthreads虽然与POSIX的要求差距甚远,却能够存在,并且还被使用了好几年的原因吧~

但是,linuxthreads为了实现这个"第5点",还是付出了很多代价,并且创造了linuxthreads本身的一大性能瓶颈.

接下来要说说,为什么A程序创建了10个线程,但是ps时却会出现11个A进程了.因为linuxthreads自动创建了一个管理线程.上面提到的"第5点"就是靠管理线程来实现的.

当程序开始运行时,并没有管理线程存在(因为尽管程序已经链接了pthread库,但是未必会使用多线程).

程序第一次调用pthread_create时,linuxthreads发现管理线程不存在,于是创建这个管理线程.这个管理线程是进程中的第一个线程(主线程)的儿子.

然后在pthread_create中,会通过pipe向管理线程发送一个命令,告诉它创建线程.即是说,除主线程外,所有的线程都是由管理线程来创建的,管理线程是它们的父亲.

于是,当任何一个子线程退出时,管理线程将收到SIGUSER1信号(这是在通过clone创建子线程时指定的).管理线程在对应的sig_handler中会判断子线程是否正常退出,如果不是,则杀死所有线程,然后自杀.

那么,主线程怎么办呢?主线程是管理线程的父亲,其退出时并不会给管理线程发信号.于

是,在管理线程的主循环中通过getppid检查父进程的ID号,如果ID号是1,说明父亲已经退出,并把自己托管给了ini t进程(1号进程).这时候,管理线程也会杀掉所有子线程,然后自杀.

可见,线程的创建与销毁都是通过管理线程来完成的,于是管理线程就成了linuxthreads的一个性能瓶颈.

创建与销毁需要一次进程间通信,一次上下文切换之后才能被管理线程执行,并且多个请求会被管理线程串行地执行.

NPTL

到了linux2.6,glibc中有了一种新的pthread线程库--NPTL(Native POSIX Threading Library). NPTL实现了前面提到的POSIX的全部5点要求.但是,实际上,与其说是NPTL实现了,不如说是linux内核实现了.

在linux2.6中,内核有了线程组的概念,task_struct结构中增加了一个tgid(thread group id)字段.如果这个task是一个"主线程",则它的tgid等于pid,否则tgid等于进程的pid(即主线程的pid).

在clone系统调用中,传递CLONE_THREAD参数就可以把新进程的tgid设置为父进程的tgid(否则新进程的tgid会设为其自身的pid).

类似的XXid在task_struct中还有两个：task->signal->pgid保存进程组的打头进程的pid、task->signal->session保存会话打头进程的pid。通过这两个id来关联进程组和会话。

有了tgid,内核或相关的shell程序就知道某个tast_struct是代表一个进程还是代表一个线程,也就知道在什么时候该展现它们,什么时候不该展现(比如在ps的时候,线程就不要展现了).而getpid(获取进程ID)系统调用返回的也是tast_struct中的tgid,而tast_struct中的pid则由gettid系统调用来返回.

在执行ps命令的时候不展现子线程，也是有一些问题的。比如程序a.out运行时，创建了一个线程。假设主线程的pid是10001、子线程是10002（它们的tgid都是10001）。这时如果你kill10002，是可以把10001和10002这两个线程一起杀死的，尽管执行ps命令的时候根本看不到10002这个进程。如果你不知道linux线程背后的故事，肯定会觉得遇到灵异事件了。

为了应付"发送给进程的信号"和"发送给线程的信号",task_struct里面维护了两套signal_pending,一套是线程组共享的,一套是线程独有的.

通过kill发送的信号被放在线程组共享的signal_pending中,可以由任意一个线程来处理;通过pthread_kill发送的信号(pthread_kill是pthread库的接口,对应的系统调用中tkill)被放在线程独有的signal_pending中,只能由本线程来处理.

当线程停止/继续,或者是收到一个致命信号时,内核会将处理动作施加到整个线程组中. NGPT

说到这里,也顺便提一下NGPT(Next Generation POSIX Threads).

上面提到的两种线程库使用的都是内核级线程(每个线程都对应内核中的一个调度实体),这种模型称为1:1模型(1个线程对应1个内核级线程);

而NGPT则打算实现M:N模型(M个线程对应N个内核级线程),也就是说若干个线程可能是在同一个执行实体上实现的.

线程库需要在一个内核提供的执行实体上抽象出若干个执行实体,并实现它们之间的调度.这样被抽象出来的执行实体称为用户级线程.

大体上,这可以通过为每个用户级线程分配一个栈,然后通过longjmp的方式进行上下文切换.(百度一下"setjmp/longjmp",你就知道.)

但是实际上要处理的细节问题非常之多.

目前的NGPT好像并没有实现所有预期的功能,并且暂时也不准备去实现.

用户级线程的切换显然要比内核级线程的切换快一些,前者可能只是一个简单的长跳转,而后者则需要保存/装载寄存器,进入然后退出内核态.(进程切换则还需要切换地址空间等.)

而用户级线程则不能享受多处理器,因为多个用户级线程对应到一个内核级线程上,一个内核级线程在同一时刻只能运行在一个处理器上.

不过,M:N的线程模型毕竟提供了这样一种手段,可以让不需要并行执行的线程运行在一个内核级线程对应的若干个用户级线程上,可以节省它们的切换开销.

据说一些类UNIX系统(如Solaris)已经实现了比较成熟的M:N线程模型,其性能比起linux的线程还是有着一定的优势

实验七：Linux多线程编程(实验分析报告)

实验七：Linux多线程编程(实验报告)

————————————————————————————————作者：————————————————————————————————日期：

实验七：Linux多线程编程（4课时） 实验目的：掌握线程的概念；熟悉Linux下线程程序编译的过程；掌握多线程程序编写方法。 实验原理：为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 1 多线程概念 使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间。 使用多线程的理由之二是线程间方便的通信机制。同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。2多线程编程函数 Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义： typedef unsigned long int pthread_t; 它是一个线程的标识符。 函数pthread_create用来创建一个线程，它的原型为： extern int pthread_create((pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)); 第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。 函数pthread_join用来等待一个线程的结束。函数原型为： extern int pthread_join(pthread_t th, void **thread_return); 第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。 函数pthread_exit的函数原型为： extern void pthread_exit(void *retval); 唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。 3 修改线程的属性 线程属性结构为pthread_attr_t，它在头文件/usr/include/pthread.h中定义。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。 设置线程绑定状态的函数为pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。 另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。 4 线程的数据处理

Linux多线程编程的基本的函数

Posix线程编程指南（一） 线程创建与取消 这是一个关于Posix线程编程的专栏。作者在阐明概念的基础上，将向您详细讲述Posix线程库API。本文是第一篇将向您讲述线程的创建与取消。 线程创建 1．1 线程与进程 相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。在串行程序基础上引入线程和进程是为了提高程序的并发度，从而提高程序运行效率和响应时间。 线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。 1．2 创建线程 POSIX通过pthread_create()函数创建线程，API定义如下： 与fork()调用创建一个进程的方法不同，pthread_create()创建的线程并不具备与主线程（即调用pthread_create()的线程）同样的执行序列，而是使其运行 start_routine(arg)函数。thread返回创建的线程ID，而attr是创建线程时设置的线程属性（见下）。pthread_create()的返回值表示线程创建是否成功。尽管arg是void *类型的变量，但它同样可以作为任意类型的参数传给start_routine()函数；同时，start_routine()可以返回一个void *类型的返回值，而这个返回值也可以是其他类型，并由pthread_join()获取。 1．3 线程创建属性 pthread_create()中的attr参数是一个结构指针，结构中的元素分别对应着新线程的运行属性，主要包括以下几项： __detachstate，表示新线程是否与进程中其他线程脱离同步，如果置位则新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源。缺省为 PTHREAD_CREATE_JOINABLE状态。这个属性也可以在线程创建并运行以后用pthread_detach()来设置，而一旦设置为PTHREAD_CREATE_DETACH状态（不论是创建时设置还是运行时设置）则不能再恢复到PTHREAD_CREATE_JOINABLE状态。

实验二-Linux进程、线程及编程

实验二Linux进程、线程及编程实验 一、实验目的 1、通过编写一个完整的守护进程，掌握守护进程编写和调试的方法 2、进一步熟悉如何编写多进程程序 二、实验环境 硬件：PC机一台，JXARM9－2410教学实验平台。 软件：Windows98/XP/2000系统，虚拟机环境下的Linux系统。 三、预备知识 1、fork() fork()函数用于从已存在的进程中创建一个新进程。新进程称为子进程，而原进程称为父进程。使用fork()函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间，包括进程上下文、代码段、进程堆栈、存信息、打开的文件描述符、信号控制设定、进程优先级、进程组号、当前工作目录、根目录、资源限制和控制终端等，而子进程所独有的只有它的进程号、资源使用和计时器等 2、exit()和_exit()的区别 _exit()函数的作用最为简单：直接使进程停止运行，清除其使用的存空间，并销毁其在核中的各种数据结构； exit()函数则在这些基础上作了一些包装，在执行退出之前加了若干道工序。 exit()函数在调用exit系统调用之前要检查文件的打开情况，把文件缓冲区中的容写回文件，就是图中的"清理I/O缓冲"一项。 3、wait()和waitpid() wait()函数是用于使父进程（也就是调用wait()的进程）阻塞，直到一个子进程结束或者该进程接到了一个指定的信号为止。如果该父进程没有子进程或者他的子进程已经结束，则wait()就会立即返回。 四、实验容 在该实验中，读者首先创建一个子进程1（守护进程），然后在该子进程中新建一个子进程2，该子进程2暂停10s，然后自动退出，并由子进程1收集子线程退出的消息。在这里，子进程1和子进程2的消息都在系统日志文件（例如“/var/log/messages”，日志文件的全路径名因版本的不同可能会有所不同）中输出。在向日志文件写入消息之后，守护进程（子进程1）循环暂停，其间隔时间为10s。 五、实验步骤

Linux下查看进程和线程

在Linux中查看线程数的三种方法 1、top -H 手册中说：-H : Threads toggle 加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。 2、ps xH 手册中说：H Show threads as if they were processes 这样可以查看所有存在的线程。 3、ps -mp 手册中说：m Show threads after processes 这样可以查看一个进程起的线程数。 查看进程 1. top 命令 top命令查看系统的资源状况 load average表示在过去的一段时间内有多少个进程企图独占CPU zombie 进程：不是异常情况。一个进程从创建到结束在最后那一段时间遍是僵尸。留在内存中等待父进程取的东西便是僵尸。任何程序都有僵尸状态，它占用一点内存资源，仅仅是表象而已不必害怕。如果程序有问题有机会遇见，解决大批量僵尸简单有效的办法是重起。kill是无任何效果的stop模式：与sleep进程应区别，sleep会主动放弃cpu，而stop 是被动放弃cpu ，例单步跟踪，stop(暂停)的进程是无法自己回到运行状态的。 cpu states： nice：让出百分比irq：中断处理占用 idle：空间占用百分比iowait：输入输出等待(如果它很大说明外存有瓶颈，需要升级硬盘(SCSI)) Mem：内存情况 设计思想：把资源省下来不用便是浪费，如添加内存后free值会不变，buff值会增大。判断物理内存够不够，看交换分区的使用状态。 交互命令： [Space]立即刷新显示 [h]显示帮助屏幕

操作系统实验报告(包括线程,进程,文件系统管理,linux+shell简单命令)

操作系统实验报告 班级：030613 学号：03061331 姓名：裴帅帅

实验一：进程的建立 一、实验内容 创建进程及子进程，在父子进程间实现进程通信，创建进程并显示标识等进 程控制块的属性信息，显示父子进程的通信信息和相应的应答信息。 使用匿名管道实现父子进程之间的通信。 二、源程序 1、创建匿名管道 SECURITY_ATTRIBUTES sa; sa.bInheritHandle=true; sa.lpSecurityDescriptor=NULL; sa.nLength=sizeof(SECURITY_ATTRIBUTES); if(!CreatePipe(&m_hRead,&m_hWrite,&sa,0)) { MessageBox("创建匿名管道失败"); return false; } 2、创建子进程 STARTUPINFO si; ZeroMemory(&si,sizeof(STARTUPINFO)); si.cb=sizeof(STARTUPINFO); si.dwFlags=STARTF_USESTDHANDLES; si.hStdInput=m_hRead; si.hStdOutput=m_hWrite; si.hStdError=GetStdHandle(STD_ERROR_HANDLE); if(!CreateProcess(NULL,"子 进.exe",NULL,NULL,true,0,NULL,NULL,&si,&pi)) { MessageBox("创建子进程失败"); CloseHandle(m_hRead); CloseHandle(m_hWrite); m_hRead=NULL; m_hWrite=NULL; return; } 3、销毁子进程 if(m_hRead) CloseHandle(m_hRead);

linux下的多线程编程常用函数

Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特 有的系统调用，他的使用方式类似fork. int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr, void *(*start_rtn)(void),void *restrict arg); 返回值：若是成功建立线程返回0,否则返回错误的编号 形式参数： pthread_t *restrict tidp 要创建的线程的线程id指针 const pthread_attr_t *restrict attr 创建线程时的线程属性 void* (start_rtn)(void) 返回值是void类型的指针函数 void *restrict arg start_rtn的行参 进行编译的时候要加上-lpthread 向线程传递参数。 例程2： 功能：向新的线程传递整形值 #include #include #include void *create(void *arg) { int *num; num=(int *)arg; printf("create parameter is %d \n",*num); return (void *)0; } int main(int argc ,char *argv[]) { pthread_t tidp; int error; int test=4; int *attr=&test; error=pthread_create(&tidp,NULL,create,(void *)attr); if(error) { printf("pthread_create is created is not created ... \n"); return -1; } sleep(1); printf("pthread_create is created ...\n");

Linux 线程实现机制分析

Linux 线程实现机制分析 杨沙洲 国防科技大学计算机学院 2003 年 5 月 19 日 自从多线程编程的概念出现在 Linux 中以来，Linux 多线应用的发展总是与两个问题脱不开干系：兼容性、 效率。本文从线程模型入手，通过分析目前 Linux 平台上最流行的 LinuxThreads 线程库的实现及其不足，描述了 Linux 社区是如何看待和解决兼容性和效率这两个问题的。 一 .基础知识：线程和进程 按照教科书上的定义，进程是资源管理的最小单位，线程是程序执行的最小单位。在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持 SMP 以及减小（进程/线程）上下文切换开销。 无论按照怎样的分法，一个进程至少需要一个线程作为它的指令执行体，进程管理着资源（比如cpu 、内存、 文件等等），而将线程分配到某个cpu 上执行。一个进程当然可以拥有多个线程，此时，如果进程运行在SMP 机器上，它就可以同时使用多个cpu 来执行各个线程，达到最大程度的并行，以提高效率；同时，即使是在单cpu 的机器上，采用多线程模型来设计程序，正如当年采用多进程模型代替单进程模型一样，使设计更简 洁、功能更完备，程序的执行效率也更高，例如采用多个线程响应多个输入，而此时多线程模型所实现的功能实际上也可以用多进程模型来实现，而与后者相比，线程的上下文切换开销就比进程要小多了，从语义上 来说，同时响应多个输入这样的功能，实际上就是共享了除cpu 以外的所有资源的。 针对线程模型的两大意义，分别开发出了核心级线程和用户级线程两种线程模型，分类的标准主要是线程的调度者在核内还是在核外。前者更利于并发使用多处理器的资源，而后者则更多考虑的是上下文切换开销。在目前的商用系统中，通常都将两者结合起来使用，既提供核心线程以满足smp 系统的需要，也支持用线程 库的方式在用户态实现另一套线程机制，此时一个核心线程同时成为多个用户态线程的调度者。正如很多技 术一样，"混合"通常都能带来更高的效率，但同时也带来更大的实现难度，出于"简单"的设计思路，Linux 从 一开始就没有实现混合模型的计划，但它在实现上采用了另一种思路的"混合"。 在线程机制的具体实现上，可以在操作系统内核上实现线程，也可以在核外实现，后者显然要求核内至少实现了进程，而前者则一般要求在核内同时也支持进程。核心级线程模型显然要求前者的支持，而用户级线程模型则不一定基于后者实现。这种差异，正如前所述，是两种分类方式的标准不同带来的。 当核内既支持进程也支持线程时，就可以实现线程-进程的"多对多"模型，即一个进程的某个线程由核内调度，而同时它也可以作为用户级线程池的调度者，选择合适的用户级线程在其空间中运行。这就是前面提到的"混合"线程模型，既可满足多处理机系统的需要，也可以最大限度的减小调度开销。绝大多数商业操作系统（如Digital Unix 、Solaris 、Irix ）都采用的这种能够完全实现POSIX1003.1c 标准的线程模型。在核外实现的线程又可以分为"一对一"、"多对一"两种模型，前者用一个核心进程（也许是轻量进程）对应一个线程，将线程调度等同于进程调度，交给核心完成，而后者则完全在核外实现多线程，调度也在用户态完成。后者就是前面提到的单纯的用户级线程模型的实现方式，显然，这种核外的线程调度器实际上只需要完成线程运行栈的切换，调度开销非常小，但同时因为核心信号（无论是同步的还是异步的）都是以进程为单位的，因而无法定位到线程，所以这种实现方式不能用于多处理器系统，而这个需求正变得越来 内容： 一.基础知识：线程和进程 二.Linux 2.4内核中的轻量进程实现 三.LinuxThread 的线程机制 四.其他的线程实现机制 参考资料 关于作者 对本文的评价 订阅: developerWorks 时事通讯

linux线程

关于linux线程 在许多经典的操作系统教科书中, 总是把进程定义为程序的执行实例, 它并不执行什么, 只是维护应用程序所需的各种资源. 而线程则是真正的执行实体.为了让进程完成一定的工作, 进程必须至少包含一个线程. 如图1. 进程所维护的是程序所包含的资源(静态资源), 如: 地址空间, 打开的文件句柄集, 文件系统状态, 信号处理handler, 等; 线程所维护的运行相关的资源(动态资源), 如: 运行栈, 调度相关的控制信息, 待处理的信号集, 等; 然而, 一直以来, linux内核并没有线程的概念. 每一个执行实体都是一个task_struct结构, 通常称之为进程. 如图2. 进程是一个执行单元, 维护着执行相关的动态资源. 同时, 它又引用着程序所需的静态资源.通过系统调用clone创建子进程时, 可以有选择性地让子进程共享父进程所引用的资源. 这样的子进程通常称为轻量级进程.linux上的线程就是基于轻量级进程, 由用户态的pthread库实现的.使用pthread以后, 在用户看来, 每一个task_struct就对应一个线程, 而一组线程以及它们所共同引用的一组资源就是一个进程.但是, 一组线程并不仅仅是引用同一组资源就够了, 它们还必须被视为一个整体.对此, POSIX标准提出了如下要求: 1, 查看进程列表的时候, 相关的一组task_struct应当被展现为列表中的一个节点; 2, 发送给这个"进程"的信号(对应kill系统调用), 将被对应的这一组task_struct所共享, 并且被其中的任意一个"线程"处理; 3, 发送给某个"线程"的信号(对应pthread_kill), 将只被对应的一个task_struct接收, 并且由它自己来处理; 4, 当"进程"被停止或继续时(对应SIGSTOP/SIGCONT信号), 对应的这一组task_struct 状态将改变; 5, 当"进程"收到一个致命信号(比如由于段错误收到SIGSEGV信号), 对应的这一组task_struct将全部退出; 6, 等等(以上可能不够全); linuxthreads

Step by Step：Linux C多线程编程入门(基本API及多线程的同步与互斥)

介绍：什么是线程，线程的优点是什么 线程在Unix系统下，通常被称为轻量级的进程，线程虽然不是进程，但却可以看作是Unix进程的表亲，同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈(call stack)，自己的寄存器环境（register context)，自己的线程本地存储(thread-local storage)。 一个进程可以有很多线程，每条线程并行执行不同的任务。 线程可以提高应用程序在多核环境下处理诸如文件I/O或者socket I/O等会产生堵塞的情况的表现性能。在Unix系统中，一个进程包含很多东西，包括可执行程序以及一大堆的诸如文件描述符地址空间等资源。在很多情况下，完成相关任务的不同代码间需要交换数据。如果采用多进程的方式，那么通信就需要在用户空间和内核空间进行频繁的切换，开销很大。但是如果使用多线程的方式，因为可以使用共享的全局变量，所以线程间的通信（数据交换）变得非常高效。 Hello World(线程创建、结束、等待） 创建线程 pthread_create 线程创建函数包含四个变量，分别为： 1. 一个线程变量名，被创建线程的标识 2. 线程的属性指针，缺省为NULL即可 3. 被创建线程的程序代码 4. 程序代码的参数 For example： - pthread_t thrd1? - pthread_attr_t attr? - void thread_function(void argument)? - char *some_argument? pthread_create(&thrd1, NULL, (void *)&thread_function, (void *) &some_argument); 结束线程 pthread_exit 线程结束调用实例：pthread_exit(void *retval); //retval用于存放线程结束的退出状态 线程等待 pthread_join pthread_create调用成功以后，新线程和老线程谁先执行，谁后执行用户是不知道的，这一块取决与操作系统对线程的调度，如果我们需要等待指定线程结束，需要使用pthread_join函数，这个函数实际上类似与多进程编程中的waitpid。 举个例子，以下假设 A 线程调用 pthread_join 试图去操作B线程，该函数将A线程阻塞，直到B线程退出，当B线程退出以后，A线程会收集B线程的返回码。 该函数包含两个参数：pthread_t th //th是要等待结束的线程的标识 void **thread_return //指针thread_return指向的位置存放的是终止线程的返回状态。 调用实例：pthread_join(thrd1, NULL); example1： 1 /************************************************************************* 2 > F i l e N a m e: t h r e a d_h e l l o_w o r l d.c 3 > A u t h o r: c o u l d t t(f y b y) 4 > M a i l: f u y u n b i y i@g m a i l.c o m 5 > C r e a t e d T i m e: 2013年12月14日 星期六 11时48分50秒 6 ************************************************************************/ 7 8 #i n c l u d e 9 #i n c l u d e 10 #i n c l u d e

11 12 v o i d p r i n t_m e s s a g e_f u n c t i o n (v o i d *p t r)? 13 14 i n t m a i n() 15 { 16 i n t t m p1, t m p2?

Linux进程同步

Linux进程同步 1.概述 Linux系统同一时间可能有多个进程在执行，因此需要一些同步机制来同步各个进程对于共享资源的访问。在Linux内核中有相应的同步技术实现，包括原子操作、信号量、读写信号量、自旋锁和等待队列等等。本文从同步的机制出发，重点研究讨论了Linux系统非阻塞的同步机制、Linux系统内核同步机制、Linux系统多线程的同步机制。 我们在实际生活中经常碰到这样的一类问题：有时候我们在使用打印机实现某种功能的时候，有可能使多个任务的打印结果交织在一起，造成混乱。这时多任务之间的同步操作便显得非常重要。比如在工业控制中的多个相互合作的任务，可以将数据采集、数据处理和数据输出划分为不同的任务。在它们之间建立一种必要的通信机制，使得采集任务可以通知数据处理任务。在新采集的数据已经处理完毕的时候，数据处理任务可以及时的通知输出任务，告诉输出任务需要实现的结果已经经过计算完成，需要通过输出设备输出。多任务的引入主要有以下有点：多任务的引入改善了系统的资源利用率，并且提高了系统的吞吐量，尤其是在嵌入式多任务操作系统中，但是与此同时多任务的引入也带来了另外的问题，那就是多个任务间如何协调、合作共同完成一个大的系统功能。特别是当我们在竞争使用临界资源，或是需要相互通知某些事件发生时。 另外在Linux操作系统里，在某一个时间段里，有些资源可能被很多内核同时来调用，这时我们便需要一套同步机制来同步各内核执行单元对共享数据的访问。尤其是在多核通信的机制上更需要同步机制来协调进程之间的通信。在Linux内核中有相应的技术实现，主要包括原子操作、信号量、读写信号量、自旋锁和等待队列。利用常用的同步机制可以有效地实现多任务、多内核之间的优化，实现其之间的合理调度。 2.同步机制 2.1临界资源与临界区 我们把在一段时间内只允许一个任务访问的资源叫做临界资源。这里与vxworks中的信号量的使用比较的类似。任务在占有CPU之后，还需要相应的资源才可以正常的执行。如果此时任务需要的资源被其它任务所占有，那么当前任务必须等待前一个任务完成并释放该资源后，才可以执行。把程序中使用临界资源的代码称为临界区。如果此刻临界资源未能访问，该任务便可以进入临界区，并将其设置为被访问状态。然后，即可以对临界资源进行操作。待任务完成后释放其占用的资源。

操作系统实验报告理解Linux下进程和线程的创建并发执行过程。

操作系统上机实验报告 实验名称： 进程和线程 实验目的： 理解unix/Linux下进程和线程的创建、并发执行过程。 实验内容： 1．进程的创建 2．多线程应用 实验步骤及分析： 一、进程的创建 下面这个C程序展示了UNIX系统中父进程创建子进程及各自分开活动的情况。 fork( ) 创建一个新进程。 系统调用格式： pid=fork( ) 参数定义： int fork( ) fork( )返回值意义如下： 0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。 >0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。 -1：创建失败。 如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。此时OS在内存中建立一个新进程，所建的新进程是调用fork( )父进程（parent process）的副本，称为子进程（child process）。子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。父进程与子进程并发执行。 2、参考程序代码 /*process.c*/ #include #include main(int argc,char *argv[]) { int pid; /* fork another process */ pid = fork(); if (pid < 0) { /* error occurred */ fprintf(stderr, "Fork Failed"); exit(-1);

Linux系统下的多线程遵循POSIX线程接口

Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序example1.c。 /* example.c*/ #include #include void thread(void) { int i; for(i=0;i<3;i++) printf("This is a pthread.\n"); } int main(void) { pthread_t id; int i,ret; ret=pthread_create(&id,NULL,(void *) thread,NULL); if(ret!=0){ printf ("Create pthread error!\n"); exit (1); } for(i=0;i<3;i++) printf("This is the main process.\n"); pthread_join(id,NULL); return (0); } 我们编译此程序： gcc example1.c -lpthread -o example1 运行example1，我们得到如下结果： This is the main process. This is a pthread. This is the main process. This is the main process. This is a pthread. This is a pthread. 再次运行，我们可能得到如下结果： This is a pthread. This is the main process. This is a pthread. This is the main process. This is a pthread.

linux多线程编程

2.终止线程 (2) 3. 等待线程终止 (2) pthread_exit和pthread_join进一步说明： (3) 4.分离线程 (7) 5.获取线程标识符 (8) 6.比较线程ID (8) 7.一次性初始化 (8) 8. 设置线程的调度策略和优先级 (9) 9. 获取线程的优先级 (11) 10.取消线程 (12) 取消线程，是否会释放线程的所有资源？例子： (14) 设置取消类型 (16) 11.初始化属性 (17) 12.设置分离状态 (18) 13.设置范围 (18) 14. 设置继承的调度策略 (18) 16. 设置调度参数 (19) 17.初始化互斥锁 (21) 18.销毁互斥锁 (21) 19.锁定互斥锁 (22) 20.解除锁定互斥锁 (23) 21. 互斥锁的类型： (23) 22. 初始化互斥锁属性对象 (23) 23. 销毁互斥锁属性对象 (23) 24.设置互斥锁类型的属性 (24) 互斥锁动态初始化和静态初始化区别： (26) 销毁互斥锁：事实上没做任何销毁操作，如下： (27) 非递归类型的互斥锁解锁和加锁操作： (27) 29.初始化条件变量 (27) 30.基于条件变量阻塞 (27) 31.解除阻塞一个线程 (28) 31.解除阻塞所有线程 (29) 33. 在指定的时间之前阻塞 (30) 32.唤醒丢失问题 (31) 33. 计数信号量概述 (31) 34. 初始化信号 (31) 35. 增加信号 (31) 36. 基于信号计数进行阻塞 (32) 37.多线程链表添加删除例子（使用条件变量实现互斥）： (32) 38.为线程特定数据创建键 (34) 39. 删除线程特定数据键 (35) 40.设置线程特定数据 (35) 41. 获取线程特定数据 (35)

linux操作系统-实验-Linux-多线程编程

《操作系统》实验报告

用gcc编译的时候需要加-lpthread,否则会出现以下错误： 五、思考题 多进程编程与多线程编程有何区别？ 相同点：Linux下不管是多线程编程还是多进程编程，最终都是用do_fork 实现 不同点：父子进程变量是互不影响的，由于父子进程地址空间是完全隔开的，变量的地址可以是完全相同的。Linux下编程多用多进程编程少用多线程编程。多线程比多进程成本低，但性能更低：多进程是立体交通系统，虽然造价高，上坡下坡多耗点油，但是不；多线程是平面交通系统，造价低，但红绿灯太多，老堵车。 1、多进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。 2、多线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。两者都可以提高程序的并发度，提高程序运行效率和响应时间。 3、线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在5MP机器上运行，而进程则可以跨机器迁移。

代码： #include #include #include #include #include char globe_buffer[100]; void *read_buffer_thread(void *arg); int main() { int res,i; pthread_t read_thread; for(i=0;i<20;i++) globe_buffer[i]=i; printf("\nxiancheng thread : write buffer finish\n"); sleep(3); res = pthread_create(&read_thread, NULL, read_buffer_thread, NULL); if (res != 0) { printf("Read Thread creat Error!"); exit(0); } sleep(1); printf("waiting for read thread to finish...\n"); res = pthread_join(read_thread, NULL); if (res != 0) { printf("read thread join failed!\n"); exit(0); } printf("read thread xiancheng OK, have fun!! exit ByeBye\n"); return 0; } void *read_buffer_thread(void *arg) { int i,x;

Linux多线程编程小结

Linux多线程编程小结 愤怒的小狐狸----博客专栏 前一段时间因为开题的事情一直耽搁了我搞Linux的进度，搞的我之前学的东西都遗忘了，很烦躁的说，现在抽个时间把之前所学的做个小节。文章内容主要总结于《Linux程序设计第3版》。 1.Linux进程与线程 Linux进程创建一个新线程时，线程将拥有自己的栈（因为线程有自己的局部变量），但与它的创建者共享全局变量、文件描述符、信号句柄和当前目录状态。 Linux通过fork创建子进程与创建线程之间是有区别的：fork创建出该进程的一份拷贝，这个新进程拥有自己的变量和自己的PID，它的时间调度是独立的，它的执行几乎完全独立于父进程。 进程可以看成一个资源的基本单位，而线程是程序调度的基本单位，一个进程内部的线程之间共享进程获得的时间片。 2._REENTRANT宏 在一个多线程程序里，默认情况下，只有一个errno变量供所有的线程共享。在一个线程准备获取刚才的错误代码时，该变量很容易被另一个线程中的函数调用所改变。类似的问题还存在于fputs之类的函数中，这些函数通常用一个单独的全局性区域来缓存输出数据。 为解决这个问题，需要使用可重入的例程。可重入代码可以被多次调用而仍然工作正常。编写的多线程程序，通过定义宏_REENTRANT来告诉编译器我们需要可重入功能，这个宏的定义必须出现于程序中的任何#include语句之前。 _REENTRANT为我们做三件事情，并且做的非常优雅： （1）它会对部分函数重新定义它们的可安全重入的版本，这些函数名字一般不会发生改变，只是会在函数名后面添加_r字符串，如函数名gethostbyname 变成gethostbyname_r。 （2）stdio.h中原来以宏的形式实现的一些函数将变成可安全重入函数。 （3）在error.h中定义的变量error现在将成为一个函数调用，它能够以一种安全的多线程方式来获取真正的errno的值。

Linux多线程编程问题

Linux 多线程编程问题 1重入问题 传统的UNIX没有太多考虑线程问题，库函数里过多使用了全局和静态数据，导致严重的线程重入问题。 1.1–D_REENTRANT /-pthread和errno的重入问题。 所先UNIX的系统调用被设计为出错返回-1，把错误码放在errno中（更简单而直 接的方法应该是程序直接返回错误码，或者通过几个参数指针来返回）。由于线程 共享所有的数据区，而errno是一个全局的变量，这里产生了最糟糕的线程重入问 题。比如： do { bytes = recv(netfd, recvbuf, buflen, 0); } while (bytes != -1 && errno != EINTR); 在上面的处理recv被信号打断的程序里。如果这时连接被关闭，此时errno应该不 等于EINTR，如果别的线程正好设置errno为EINTR，这时程序就可能进入死循环。 其它的错误码处理也可能进入不可预测的分支。 在线程需求刚开始时，很多方面技术和标准（TLS）还不够成熟，所以在为了 解决这个重入问题引入了一个解决方案，把errno定义为一个宏： extern int *__errno_location (void); #define errno (*__errno_location()) 在上面的方案里，访问errno之前先调用__errno_location()函数，线程库提供这个 函数，不同线程返回各自errno的地址，从而解决这个重入问题。在编译时加 -D_REENTRANT就是启用上面的宏，避免errno重入。另外-D_REENTRANT 还影响一些stdio的函数。在较高版本的gcc里，有很多嵌入函数的优化，比如把printf(“Hello\n”); 优化为 puts(“hello\n”); 之类的，有些优化在多线程下有问题。所以gcc引入了–pthread 参数，这个 参数出了-D_REENTRANT外，还校正一些针对多线程的优化。 因为宏是编译时确定的，所以没有加-D_REENTRANT编译的程序和库都有errno 重入问题，原则上都不能在线程环境下使用。不过在一般实现上主线程是直接使用 全局errno变量的，也就是__errno_location()返回值为全局&errno，所以那些没加 -D_REENTRANT编译的库可以在主线程里使用。这里仅限于主线程，有其它且只 有一个固定子线程使用也不行，因为子线程使用的errno地址不是全局errno变量 地址。 对于一个纯算法的库，不涉及到errno和stdio等等，有时不加_REENTRANT也是 安全的，比如一个纯粹的加密/解谜函数库。比较简单的判断一个库是否有errno问 题是看看这个库是使用了errno还是__errno_location()：

linux进程线程管理实验报告

西安郵電學院 操作系统LINUX实验报告 题目1：进程______ 题目2：线程管理__ 题目3：互斥_____ 院系名称：电子工程学院 专业名称：电子信息工程 班级：0806 学号：04085048 学生姓名：杨旭东

实验一: 进程管理 一．实验目的 通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点， 掌握在POSIX 规范中fork和kill系统调用的功能和使用。 二．实验要求 2.1 实验环境要求 1. 硬件 (1) 主机：Pentium III 以上； (2) 内存：128MB 以上； (3) 显示器：VGA 或更高； (4) 硬盘空间：至少100MB 以上剩余空间。 2. 软件 Linux 操作系统，内核2.4.26 以上，预装有X-Window 、vi、gcc、gdb 和任意web 浏览器。 2.2 实验前的准备工作 学习man 命令的用法，通过它查看fork 和kill 系统调用的在线帮助，并阅读参 考资料，学会fork 与kill 的用法。 复习C 语言的相关内容。 三、实验内容 3.1 补充POSIX 下进程控制的残缺版实验程序 3.2回答下列问题： 1. 你最初认为运行结果会怎么样？ 2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。 3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？ 4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？ 5. 使用kill 命令可以在进程的外部杀死进程。进程怎样能主动退出？这两种退出方式哪种更好一些？ 四、实验结果 4.2回答上述实验内容中的问题 1．预期结果：

Linux多线程编程和Linux 2.6下的NPTL

Linux多线程编程和Linux 2.6下的NPTL 这几天由于工作需要，琢磨了一下Linux下的多线程的相关资料。Linux下最常用的多线程支持库为Pthread库，它是glibc库的组成部分。但是关于Pthread的说明文档非常缺乏，特别是对POSIX多线程规范的介绍以及pthread库中多线程实现方式的介绍实在是少之又少。而多线程编程对于系统程序员而言是必须掌握的技术，因此总是让学习中的程序员觉得头痛不以。我自己也没有太多多线程编程的经验，在这里只是把自己收集到的一些关于Linux上多线程还算新的资料进行汇总来抛砖引玉，以便相互学习交流。 这里顺便提一下市面上有的一本介绍多线程的书《Posix 多线程编程》，它是英文版《Programming with POSIX Muiltthread》中译本，这也是半年前我所能找到的唯一专题介绍多线程编程的书。我个人感觉这本书的前面1/3之一的内容写的还是不错的，但是后面的东西就非常晦涩并且有很多明显的文字错误。看看这本书的翻译者是好几个人，估计每个人的翻译能力不同造成了这本书的虎头蛇尾。因此我不建议大家去买这本书作为圣经收藏。这本书前半步的内容主要围绕Posix的多线程，介绍的比较精彩的就是几个多线程编程模型，把多线程的互斥和同步机制介绍的挺酣畅的，推荐一看。这些内容并非这本书首创，早在《UNIX网络编程》第二卷进程间通信就有了这些经典的介绍，但是能系统的把这些机制结合到多线程编程中来还是有可圈可点之处的。此外毕竟《UNIX网络编程》两卷内容太老，书也太厚了，并不是大多数程序员所能坐下来细细看的。这里我还想表达一下对微软在技术上的不足斥责。在msdn中platform sdk部分中的windows多线程编程的内容真是简陋的可笑，只有傻兮兮的建立和退出线程的函数，关于互斥，条件的介绍一概全无。只能在它的sample代码中自己去找，sample 代码里面的线程同步方式居然是做一个死循环来死等，也不知道它把windows卖这么多钱是干什么吃的。MFC中多线程的封装倒是看上去像那么一回事情了，但是我想象不出在如此简陋的系统api上微软到底是如何实现出MFC上线程功能的。拥护windows的人不要在这里砸鸡蛋，最好也能写一篇windows上的多线程介绍除了。这比砸鸡蛋来得有意义多了。好了，书归正传继续说Linux上的多线程。 在Linux上，从内核角度而言，基本没有什么线程和进程的区别－－大家都是进程。一个进程的多个线程只是多个特殊的进程他们虽然有各自的进程描述结构，却共享了同一个代码上下文。在Linux上，这样的进程称为轻量级进程Light weight process。致此，就是关于线程的总体概念了，我们往往就在了解这个概念的情况下开始我们的多线程编程之旅。这对于多线程编程入门已经足够了，然而事实上线程却要复杂的多。首先多线程间的优先级调度，内存资源（栈）分配和信号投递就不是简单的共享同一个进程代码上下文所能所能解决的。其次，效率的问题：如何有效的使用多cpu资源（2.4内核的多线程就无法使用多个cpu，一个进程的线程都被限制在同一个cpu上运行）。因此多线程库Pthread的实现并不是一件简单的事情，它建立在特有的线程模型之上。 在Linux 2.4内核中，Linux内核中使用了一个内核线程来处理用户态进程中的多个线程的上下文切换（线程切换）。由于内核中并没有什么线程组的概念，即一个进程的多个线程，因此必须依靠在pthread库中实现一个额外的线程来管理其他用户线程（即用户程序生成的线程）的建立，退出，资源分配和回收以及线程的切换。由于当时硬件并没有线程寄存器之类的冬冬来支持多线程，因此线程的切换性能和低下，并且需要引入复杂的机制在进程的栈中为各个线程划分出各自的栈数据所在位置，并且在切换时进行栈数据拷贝。而最大的问题是内核中缺乏对线程间的同步机制的支持，因此pthread库不得不在底层依靠信号方式来实现同步，因此线程互斥中