Linux进程与线程的比较
Linux下
进程与线程的比较
作者：唐延军
同济大学软件学院
目录
1．进程简介 (3)
2．线程简介 (3)
3．进程创建与消亡说明 (3)
4．线程创建与消亡说明 (4)
5．时间的测量 (5)
6．实验的思路简介 (5)
7．实验原码与分析 (8)
7.1各个程序段中都要用到的一个头文件 (8)
7.2进程切换的switchpro.c (9)
7.3线程切换switchthread.c (10)
7.4创建进程的createpto.c (11)
7.5创建线程的createthread.c (13)
7.6消亡进程的destroypto.c (14)
7.7消亡线程的destroythread.c (15)
8．测试结果及比较 (16)
8.1进程和线程切换的开销 (16)
8.2进程和线程创建的开销 (18)
8.2进程和线程消亡的开销 (19)
9．结论与分析 (20)
10．参考资料与作者信息 (21)
一．进程简介
“进程”是操作系统中最基本，最重要的概念之一。现代操作系统中一般将进程描述为：进程是一种活动，它由一系列的动作组成，每个动作是在某个数据集上执行一段程序，整个活动的结果是提供一种系统或用户功能。
从概念上说，每个进程都有它自己的虚拟CPU，当然，实际上真正的CPU在个进程之间来回切换。
相应的进程管理是操作系统最关键的部分，它的设计和实现直接影响到整个系统的性能。在一个多进程的操作系统中，一个时间段内可以有多个进程“并发”执行。这样就避免了较为快速的CPU等待较为低速的I/O设备的情况，提高了CPU利用率，从而提高系统的性能。另一个方面，同时运行多个进程，就可以同时提供多种服务或者同时为更多的客户服务，这也是现代操作系统的基本任务。
进程是通过系统调用fork创建的，新的进程是原来进程的子进程。
二．线程简介
线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。
为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？
使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。
使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。
三．进程创建与消亡说明
创建一个进程的系统调用很简单.我们只要调用fork函数就可以了.
#include
pid_t fork();
当一个进程调用了fork以后,系统会创建一个子进程.这个子进程和父进程不同的地方只有他的进程ID和父进程ID,其他的都是一样.就象符进程克隆(clone)自己一样. 当fork掉用失败的时候(内存不足或者是用户的最大进程数已到)fork返回-1,否则fork的返回值有重要的作用.对于父进程fork返回子进程的ID,而对于fork子进程返回0.我们就是根据这个返回值来区分父子进程的.
有时候我们希望子进程继续执行,而父进程阻塞直到子进程完成任务.这个时候我们可以调用wait
#include
#include
pid_t wait(int *stat_loc);
wait系统调用会使父进程阻塞直到一个子进程结束或者是父进程接受到了一个信号.如果没有父进程没有子进程或者他的子进程已经结束了wait回立即返回.成功时(因一个子进程结束)wait将返回子进程的ID,否则返回-1。
终止进程调用void exit(int status)；
调用进程被该系统调用终止.引起附加的处理在进程被终止前全部结束.
四．线程创建与消亡说明
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 __P ((pthread_t *__thread, __const pthread_attr_t *__attr,
void *(*__start_routine) (void *), void *__arg));
第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINV AL。
前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。
函数pthread_join用来等待一个线程的结束。函数原型为：
extern int pthread_join __P ((pthread_t __th, void **__thread_return));
第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。
函数pthread_exit来实现线程的结束.它的函数原型为：
extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。
五．时间的测量
`有时候我们要计算程序执行的时间.比如我们要对算法进行时间分析.这个时候可以使用下面这个函数.
#include
int gettimeofday(struct timeval *tv,struct timezone *tz);
strut timeval {
long tv_sec; /* 秒数*/
long tv_usec; /* 微秒数*/
};
gettimeofday将时间保存在结构tv之中.tz一般我们使用NULL来代替.
六．实验的思路简介
根据以上基础知识，我将设计两个实验来比较线程和进程。
实验一
目的：比较线程和进程切换的开销
思路：
1．关于进程的切换：创建MaxPro-1个进程，这些进程一创建就用execl函数去执行customer程序，因为这时没有生产者，所以这些进程全都睡眠。最后个本进程去执行producer程序。在producer中，我们指定一定的生产次数，因为信号量space的初始值为1，所以producer每生产一次都会下台，让众多customer中的一个上台。我们从producer 开始生产计时，生产完毕再计时，可以计算多个之间进程的切换的开销。最后用Kill杀死所有customer进程（保证下个实验时系统回到初始状态）。
2．关于线程的切换：同进程切换，我们创建MaxPro-1个分离线程，这些线程统统在
count_nonzero上睡眠，最后创建一个线程唤醒一个在count_nonzero睡眠的线程（具体唤醒那个线程是由系统决定的），然后自己在count_nonzero1上睡眠。被唤醒的线程再唤醒在count_nonzero1睡眠的线程，然后自己再在count_nonzero上睡眠。如此便可以计算多个线程之间切换的开销。
3．使用计时器来计算运行一定次数的进程和线程的切换所花的时间，并计算每次所带来的开销。
试验代码：详见switchpro.c 和switchthread.c
试验结果：详见图表1和图表2
试验结论：详见结论与分析
实验二
目的：比较线程和进程创建的开销
思路：
1．关于进程创建：fork函数创建子进程，让子进程睡眠100000秒，反复执行一定的次数最后可以统计每次创建的开销（当然最后会用Kill来杀死那些睡眠得子进程）。
2．关于线程的创建。跟创建进程相似。创建一个线程后，让此线程在count_nonzero睡眠。反复执行一定的次数可以统计每次线程创建的开销。（最后唤醒所有在count_nonzero睡眠得线程，让其结束）。
3．使用计时器来计算运行一定次数的进程和线程的创建所花的时间，并计算每次所带来的开销。
试验代码：详见createpro.c 和createthread.c
试验结果：详见图表3
试验结论：详见结论与分析
实验三
目的：比较线程和进程消亡的开销
思路：
1．关于进程消亡：fork函数创建子进程，让子进程睡眠100000秒。然后开始计时，用for 循环不断杀死这些进程，然后统计所用时间，就可以得出每个进程消亡的时间
2．关于线程的消亡。跟消亡进程相似。创建一些非分离线程后，开始计时，用for
循环不断杀死这些线程，然后统计所用时间。（注意：在Linux当创建256个非分离线程时，系统会崩溃，所以最多试验到255为止）
3．使用计时器来计算运行一定次数的进程和线程的消亡所花的时间，并计算每次所带来的开销。
试验代码：详见destroypro.c 和destroythread.c
试验结果：详见图表4
试验结论：详见结论与分析
七．实验原码与分析
1）首先说明在各个程序段中都要用到的一个头文件。#include
头文件countTime.h
实现countTime.h的countTime.c
Producer.c
3）创建进程的createpto.c
4）创建线程的createthread.c
5）消亡进程的Destroypro.c
6）消亡线程的Destroythread.c
八．测试结果及比较
1）进程和线程切换的开销。
下面是运行switchpro.c和switchthread.c后的结果。
我们不断地调整运行进程的数目。目的是比较进程和线程在各个情况下的开销。
当然我们也可以横向对比。即比较进程数逐渐增多时切换开销的走势。
从图中我们可以看出在同样条件（运行数目和切换次数一样的情况下），进程显然比线程的时间开销大。我们将进程数和线程数为200时的表画成柱状图观察。
微秒/切换
次数
进程数个线程数为200时切换开销
图表 1
同时我们也可以观察一下，随着进程数的增加，进程和线程的时间开销的情况。 我们以切换500,000为例
切换次数为500,000次时进程和线程开销比较
20406080100
50
100
150200
运行的个数
微秒/切换
图表 2
从上图我们可以看出随着进程数和线程数的增加，切换的开销都增加。但是进程增加的更快。这个情况与进程和线程自身的运行结构是有关的。
随着进程数的不断增加，可能有部分进程的图像已经到了盘交换区上去了，如果选中要运行的进程不再内存，就要将其调进内存，这样就会增加时间开销。而且，在本程序中一个producer 唤醒的是多个customer ，而从众多的customer 种选择一个上台，也会增加时间开销。故随着进程数的增加，进程切换的时间开销也不断上涨。
因为线程之间共享数据段，故它的切换并不需要进程的调入和调出。即内核不感知，所以它的切换开销相对小一些。
2） 进程和线程创建的开销
下面是运行createpto.c 和createthread.c 的结果
我们改变创建的个数从100-1000次（注意：这里创建的是分离线程，如果是非分离线程只能创建255个）
我们观察发现随着创建的个数越来越多，创建的开销越来越大。这与事实是相符的。当创建的数目越来越多的时候，内存中一没有空闲区，如果继续创建，则需要把一部分睡眠进程调到外存上，这样创建的速度自然就慢下来了。
我们从下图可以更仔细的观察
进程和线程创建的开销
50100150200250300100
200
5001000
创建个数
微秒/创建
图表 3
3） 进程和线程消亡的开销
下面是运行的destroypto.c 和destroythread.c 的结果
我们改变其要消亡的个数，因为我们要消亡的是非分离线程，故创建的个数不能多余255个。
我们可以看到进程的消亡也比线程的要多，大约是其的4倍左右。我们
画成图如下：
进程和线程消亡的开销
10020030040050060050
100
150200
个数
微秒/消亡
图表 4
我们同时也观察到随消亡个数的增加，进程的时间开销也越来越大。而线程的开销则超过一定限制之后，基本上平稳，缓慢的增加。这当然与进程数过多，要消亡的进程如果还在盘交换区上的话，要释放其在外存上的空间，当然比释放内存上的进程需要的时间多得多。在盘交换区的进程数越多消亡的开销也越大了。不过也应该像线程一样，超过一定的限额后，增长的幅度会越来越小，最后趋于平稳。实验证实也确实如此。比如消亡5000个进程，平均数字为6825.134 us ，而消亡6000个进程大约6860.460 us 。增长幅度已经很小了
九． 结论与分析
由图观察可知，进程的切换比线程的切换所耗的时间要大很多。进程切换的速度比线程的切换要慢。认真分析可以得到选择并运行一个进程所化的时间大约是线程选择并运行的5倍。这个结论适用的条件是：每个进程和线程都不做任何工作，只是得到CPU 控制权后马上放弃。
当然这里只是粗略的估计了一下进程和线程之间切换的开销，只能说明进程的开销比线程的大。它不能代表实际的情况。毕竟，如果不完成一些实际工作，进程的切换没有任何意义。
同样可看出进程的创建所花的时间开销也比线程大。
其实。我们应该知道：Linux下一个进程在内存里有三部份的数据，就是“数据段”，“堆栈段”和“代码段”，其实学过汇编语言的人一定知道，一般的CPU象I386，都有上述三种段寄存器，以方便操作系统的运行。“代码段”，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用同一个代码段。
堆栈段存放的就是子程序的返回地址、子程序的参数以及程序的局部变量。而数据段则存放程序的全局变量，常数以及动态数据分配的数据空间（比如用malloc之类的函数取得的空间）。
进程每次创建的过程中系统都要为一个新的进程准备了三个段，并且进行复制。当子进程创建完后，子父进程之间不再共享任何数据了，于是，如果两个进程要共享什么数据的话，就要使用另一套函数（shmget，shmat，shmdt等）来操作。这对系统来说都是极大的开销。
进程的切换的时候，系统也要为其恢复数据段和堆栈段，并为其恢复现场。这些的开销也是很大的。
从试验看出进程的确很耗资源和时间，而线程则无论从时间开销上还是空间开销上都比进程要小。
如果程序中使用多线程，将会给我们带来那些益处呢？以下是我总结的几点。
a) 提高应用程序响应
任何一个包含很多互不关联的操作（activity）的程序都可以被重新设计，使得每一个操作成为一个线程。例如，在一个GUI（图形用户界面）内执行一
个操作的同时启动另外一个，就可以用多线程改善性能。
b) 使多处理器效率更高
典型情况下，有同时性需求的多线程应用程序不需要考虑处理器的数量。
应用程序的性能在被多处理器改善的同时对用户是透明的。
数学计算和有高度并发性需求的应用程序，比如矩阵乘法，在多处理器平台上可以用多线程来提高速度。
c) 改善程序结构
许多应用程序可以从一个单一的、巨大的线程改造成一些独立或半独立的执行部分，从而得到更有效的运行。多线程程序比单线程程序更能适应用户需
求的变更。
d) 占用较少的系统资源
基于嵌入式Linux多线程聊天系统的设计与实现
基于嵌入式Linux多线程聊天系统的设计与实现 学生姓名王宣达 学号 S2******* 所在系（院）电子信息工程系 专业名称电路与系统年级 2009级 2011年8月3日
中文摘要
外文摘要
目录 1．引言 (1) 2．Linux多线程聊天系统的设计思想 (3) 2.1 聊天系统中服务器的设计思想 (3) 2.2 聊天系统中客户端的设计思想 (3) 3. Linux多线程聊天系统的实现过程 (5) 3.1 多线程聊天系统中服务器端的实现过程 (5) 3.2 多线程聊天系统中客户端的实现过程 (7) 4.Linux多线程系统设计中出现的问题和解决的方法 (12) 4.1 多线程中资源的释放问题 (12) 4.2 (12) 参考文献 (12)
1．引言 在80年代中期，线程技术就应用到了操作系统中，那时在一个进程中只允许有一个线程，这样多线程就意味着多进程，虽然实现了多任务，但是资源消耗还是非常可观的。而到现在，多线程技术已经被许多操作系统所支持，有Windows/NT，还有Linux。 多线程和进程相比有两点优势： 1.它是一种消耗资源非常少的多任务操作方式。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种消耗非常大的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，这样创建一个线程所占用的空间远远小于创建一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。当然，随着系统的不同，这个差距也不不同。 2.线程间比进程间的通信机制更为便利。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，这时就要用到互斥锁机制来保证线程间的同步。 所以在本文的多线程聊天程序的设计中，采用多线程的方式设计系统更为适宜。其中，系统中用到的操作主要是：线程操作，设置互斥锁。其中，线程操作包括：线程创建，退出，。设置互斥锁包括：创建互斥锁，加锁和解锁。 但是，要实现网络聊天，系统中还要用到linux下的网络编程。 Linux下的网络编程通过socket接口实现。socket 是一种特殊的I/O，可以实现网络上的通信机制。Socket也是一种文件描述符。它具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。常用的Socket
进程与线程的区别 进程的通信方式 线程的通信方式
进程与线程的区别进程的通信方式线 程的通信方式 进程与线程的区别进程的通信方式线程的通信方式2011-03-15 01：04 进程与线程的区别： 通俗的解释 一个系统运行着很多进程，可以比喻为一条马路上有很多马车 不同的进程可以理解为不同的马车 而同一辆马车可以有很多匹马来拉--这些马就是线程 假设道路的宽度恰好可以通过一辆马车 道路可以认为是临界资源 那么马车成为分配资源的最小单位(进程) 而同一个马车被很多匹马驱动(线程)--即最小的运行单位 每辆马车马匹数=1 所以马匹数=1的时候进程和线程没有严格界限，只存在一个概念上的区分度 马匹数1的时候才可以严格区分进程和线程 专业的解释： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执 行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序 的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行 的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在 应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可 以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程 的调度和管理以及资源分配。这就是进程和线程的重要区别。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的 能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中 必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的 其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以 并发执行 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有 独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线 程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程 的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者 《操作系统的设计与实现》。对就个问题说得比较清楚。 +++ 进程概念
基于linux的socket多线程通信
1、网络中进程之间如何通信？ 本地的进程间通信（IPC）有很多种方式，但可以总结为下面4类： ?消息传递（管道、FIFO、消息队列） ?同步（互斥量、条件变量、读写锁、文件和写记录 锁、信号量） ?共享内存（匿名的和具名的） ?远程过程调用（Solaris门和Sun RPC） 但这些都不是本文的主题！我们要讨论的是网络中进程之间如何通信？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的―ip地址‖可以唯一标识网络中的主机，而传输层的―协议+端口‖可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。 使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说―一切皆socket‖。 2、什么是Socket？ 上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是―一切皆文件‖，都可以用―打开open –> 读写write/read –> 关闭close‖模式来操作。我的理解就是Socket就是该模式的一个实现，socket 即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。 socket一词的起源 在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的，撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载，Croker写道：―命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端，而一个连接可完全由一对套接字接口规定。‖计算机历史博物馆补充道：―这比BSD的套接字接口定义早了大约12年。‖ 3、socket的基本操作 既然socket是―open—write/read—close‖模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。 3.1、socket()函数 int socket(int domain, int type, int protocol); socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。 正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket 函数的三个参数分别为：
实验二-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
linux进程线程管理实验报告
linux进程线程管理实验报告
————————————————————————————————作者：————————————————————————————————日期：
西安郵電學院 操作系统LINUX实验报告 题目1：进程______ 题目2：线程管理__ 题目3：互斥_____系部名称：计算机学院 专业名称：软件工程 班级：0802 学号：04085048 学生姓名：郭爽乐 时间：2010-10-31
实验一: 进程管理 一．实验目的 通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点， 掌握在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.1 补充完全的源程序 #include
操作系统实验报告(包括线程,进程,文件系统管理,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);
VC++之线程和进程之用剪贴板实现进程间通信
一、创建对话框应用程序工程 二、编辑对话框资源 控件ID及标题 IDD_THREAD_DIALOG 用剪贴板实现进程间通信 IDC_STATIC 进程1发送数据：IDC_EDIT_SEND IDC_STATIC 进程2接收数据：IDC_EDIT_REC IDC_SEND 发送 IDC_REC 接收 三、添加消息响应函数
四、于“ThreadDlg.cpp”文件内添加消息响应函数代码 void CThreadDlg::OnRec() { // TODO: Add your control notification handler code here if(OpenClipboard()) { if(IsClipboardFormatAvailable(CF_TEXT)) { HANDLE clipboard; char* buf; clipboard=GetClipboardData(CF_TEXT); buf=(char*)GlobalLock(clipboard); GlobalUnlock(clipboard); SetDlgItemText(IDC_EDIT_REC,buf); CloseClipboard(); } } } void CThreadDlg::OnSend() { // TODO: Add your control notification handler code here if(OpenClipboard()) //打开剪贴板 {
CString str; HANDLE clipboard; char * buf; EmptyClipboard(); //清空剪贴板 GetDlgItemText(IDC_EDIT_SEND,str); clipboard=GlobalAlloc(GMEM_MOVEABLE,str.GetLength()+1); buf=(char*)GlobalLock(clipboard); //空字符作文本数据结尾，多分配一个字节 strcpy(buf,str); GlobalUnlock(clipboard); SetClipboardData(CF_TEXT,clipboard); CloseClipboard(); } } 五、编译 六、运行 七、函数说明 1、SetClipboardData()函数声明 HANDLE SetClipboardData( UINT nFormat, //剪贴板格式 HANDLE hMen //特定格式之数据句柄 ) 功能：以特定剪贴板格式复制数据到剪贴板。函数调用成功，返回数据句柄；失败，返回NULL，可用GetLastError()函数获取详细错误信息。 2、GetClipboardData()函数声明 HANDLE GetClipboardData( UINT uFormat //剪贴板模式 ) 功能：以特定模式获取剪贴板信息。函数调用成功，返回非零值；失败，返回零。 3、GlobalLock()函数声明 LPVOID GlobalLock(
进程线程通信及同步方法总结
Linux系统中的进程间通信方式主要以下几种: 同一主机上的进程通信方式 * UNIX进程间通信方式: 包括管道(PIPE), 有名管道(FIFO), 和信号(Signal) * System V进程通信方式：包括信号量(Semaphore), 消息队列(Message Queue), 和共享内存(Shared Memory) 网络主机间的进程通信方式 * RPC: Remote Procedure Call 远程过程调用 * Socket: 当前最流行的网络通信方式, 基于TCP/IP协议的通信方式. 各自的特点如下: ?管道(PIPE)：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系(父子进程)的进程间使用。另外管道传送的是无格式的字节流，并且管道缓冲区的大小是有限的（管道缓冲区存在于内存中，在管道创建时，为缓冲区分配一个页面大小）。 ?有名管道(FIFO)：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。 ?信号(Signal)：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。 ?信号量(Semaphore)：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。 ?消息队列(Message Queue)：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。 ?共享内存(Shared Memory )：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。 ?套接字(Socket)：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同主机间的进程通信。 Linux系统中的线程间通信方式主要以下几种: * 锁机制：包括互斥锁、条件变量、读写锁 互斥锁提供了以排他方式防止数据结构被并发修改的方法。 读写锁允许多个线程同时读共享数据，而对写操作是互斥的。 条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。 * 信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量 * 信号机制(Signal)：类似进程间的信号处理 线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。
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进程间通讯 管道（FIFO）： 管道可分为命名管道和非命名管道（匿名管道），匿名管道只能用于父、子进程间通讯，命名管道可用于非父子进程。命名管道就是FIFO，管道是先进先出的通讯方式。 消息队列： 消息队列用于2个进程间通讯，首先在1个进程中创建1个消息队列，然后可向消息队列中写数据，而另一进程可从该消息队列中读取数据。 注意，消息队列是以创建文件的方式建立的，若1个进程向某消息队列中写入数据后，另一进程并未读取这些数据，则即使向消息队列中写数据的进程已退出，但保存在消息队列中的数据并未消失，也就是说下次再从这个消息队列中读数据时，还是会读出已退出进程所写入的数据。 信号量： linux中的信号量类似于windows中的信号量。 共享内存： 共享内存，类似于windows中dll的共享变量，但linux下的共享内存区不需要象DLL这样的东西，只要先创建1个共享内存区，其它进程按照一定步骤就能访问到这个共享内存区中的数据（可读可写）。 信号——signal 套接字——socket 各种ipc机制比较： 1.匿名管道：速度较慢，容量有限，且只有父、子进程间能通讯； 2.命名管道（FIFO）：任何进程间都能通讯，但速度较慢； 3.消息队列：容量受系统限制，且要对读出的消息进行测试（读出的是新写入的消息，还是以前写入的， 尚未被读取的消息）； 4.信号量：不能传递复杂信息，只能用来同步； 5.共享内存：容量大小可控，速度快，但共享内存区不包含同步保护，对共享内存区的访问需由用户实 现同步保护。 另外，共享内存同样可用于线程间通讯，不过没必要，线程间本来就已共享了同一进程内的一块内存。 线程间同步方法： 1.临界区：使多线程间串行访问公共资源或1段代码，速度较快，适合控制数据访问； 2.互斥量：为同步对共享资源的单独访问而设计的； 3.信号量：为控制1个具有有限数量用户资源而设计； 4.事件对象：用来通知线程有一些事件已发生，从而启动后继任务。
操作系统实验报告理解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
Linux进程同步
Linux进程同步 1.概述 Linux系统同一时间可能有多个进程在执行，因此需要一些同步机制来同步各个进程对于共享资源的访问。在Linux内核中有相应的同步技术实现，包括原子操作、信号量、读写信号量、自旋锁和等待队列等等。本文从同步的机制出发，重点研究讨论了Linux系统非阻塞的同步机制、Linux系统内核同步机制、Linux系统多线程的同步机制。 我们在实际生活中经常碰到这样的一类问题：有时候我们在使用打印机实现某种功能的时候，有可能使多个任务的打印结果交织在一起，造成混乱。这时多任务之间的同步操作便显得非常重要。比如在工业控制中的多个相互合作的任务，可以将数据采集、数据处理和数据输出划分为不同的任务。在它们之间建立一种必要的通信机制，使得采集任务可以通知数据处理任务。在新采集的数据已经处理完毕的时候，数据处理任务可以及时的通知输出任务，告诉输出任务需要实现的结果已经经过计算完成，需要通过输出设备输出。多任务的引入主要有以下有点：多任务的引入改善了系统的资源利用率，并且提高了系统的吞吐量，尤其是在嵌入式多任务操作系统中，但是与此同时多任务的引入也带来了另外的问题，那就是多个任务间如何协调、合作共同完成一个大的系统功能。特别是当我们在竞争使用临界资源，或是需要相互通知某些事件发生时。 另外在Linux操作系统里，在某一个时间段里，有些资源可能被很多内核同时来调用，这时我们便需要一套同步机制来同步各内核执行单元对共享数据的访问。尤其是在多核通信的机制上更需要同步机制来协调进程之间的通信。在Linux内核中有相应的技术实现，主要包括原子操作、信号量、读写信号量、自旋锁和等待队列。利用常用的同步机制可以有效地实现多任务、多内核之间的优化，实现其之间的合理调度。 2.同步机制 2.1临界资源与临界区 我们把在一段时间内只允许一个任务访问的资源叫做临界资源。这里与vxworks中的信号量的使用比较的类似。任务在占有CPU之后，还需要相应的资源才可以正常的执行。如果此时任务需要的资源被其它任务所占有，那么当前任务必须等待前一个任务完成并释放该资源后，才可以执行。把程序中使用临界资源的代码称为临界区。如果此刻临界资源未能访问，该任务便可以进入临界区，并将其设置为被访问状态。然后，即可以对临界资源进行操作。待任务完成后释放其占用的资源。
VC++之线程和进程之用共享内存实现进程间通信
一、创建对话框应用程序 二、编辑对话框资源 控件ID及标题 IDC_STATIC 发送数据IDC_EDIT_SEND IDC_BUTTON_SEND 发送 IDC_STATIC 接收数据IDC_EDIT_RECEIVE IDC_BUTTON_RECEIVE 接收 IDOK 退出 三、添加变量、函数、对象/库模块 1、添加变量 public: CEdit m_send; CEdit m_receive;
public: HANDLE SharedMemory; void* address; 2、添加消息响应函数
四、添加代码 1、添加初始化代码 BOOL CThreadDlg::OnInitDialog() { CDialog::OnInitDialog(); ...... SharedMemory = CreateFileMapping((HANDLE)0xffffffff,NULL,PAGE_READWRITE,0,10000,"Mem File"); address = MapViewOfFile(SharedMemory,FILE_MAP_WRITE,0,0,0); return TRUE; } 2、添加函数代码 void CThreadDlg::OnButtonReceive() { // TODO: Add your control notification handler code here CString str; strcpy((char*)(LPCTSTR)str,(char*)address); m_receive.SetWindowText(str); }
Linux中进程与线程的概念以及区别
Linux中进程与线程的概念以及区别 linux进程与线程的区别，早已成为IT界经常讨论但热度不减的话题。无论你是初级程序员，还是资深专家，都应该考虑过这个问题，只是层次角度不同罢了。对于一般的程序员，搞清楚二者的概念并在工作中学会运用是其思考的主要问题；对于资深工程师，如何在系统层面实现两种技术及其各自的性能和实现代价是其思考的主要问题。由此可见进程和线程在IT界的重要地位。 进程和线程是操作系统的基本概念，它们之间既有区别又有联系。从定义来看，它们比较抽象，很难理解。今天给大家打个比方，教大家用类比的方法去理解它，掌握它。其实，进程和线程的关系就好比是工厂车间和车间工人的关系，进程就像是一个工厂车间，线程就像是车间里的工人，每个工厂车间有一个入口和出口，这就好比执行进程程序的主函数；每个工厂车间都有自己的地址空间，这个空间里边可以包含不同工种的工人，这就好比一个进程的地址空间，包含文本区域，数字区域，堆栈；一个工厂车间可以容纳1 个或n车间工人，进程和线程是一对一或一对多的关系，一个进程至少包含一个线程；车 间里的工人共享车间里的空间，这象征着一个进程的内存空间是共享的，每个线程都可以使用共享内存；每个车间可以供不同的工人使用，但每个车间的大小不一，容纳人数都有上限，比如说每个厕所可以容纳1人，每个厨房可以容纳n人，但车间里的每个工人都有上厕所和吃饭的需求，那怎么解决这个问题呢？分批次进行！这就好比线程里的锁机制，当n个线程争夺同一资源时，就在这个资源上加把锁，当线程使用完毕，资源释放后才会供给后边的资源使用。有人可能会问，怎么确定使用该资源的先后顺序呢？按照优先级的高低来确定，优先级高的先使用，优先级低的后使用，同一级别按照先来后到的顺序使用。 通过这个故事我么可以看出，操作系统的设计可以归纳为3点： （1）以多进程形式，允许多个任务同时运行，也就是允许工厂里的多个车间同时工作；
VC多线程实现线程间通信
当前流行的Windows操作系统能同时运行几个程序(独立运行的程序又称之为进程)，对于同一个程序，它又可以分成若干个独立的执行流，我们称之为线程，线程提供了多任务处理的能力。用进程和线程的观点来研究软件是当今普遍采用的方法，进程和线程的概念的出现，对提高软件的并行性有着重要的意义。现在的大型应用软件无一不是多线程多任务处理，单线程的软件是不可想象的。因此掌握多线程多任务设计方法对每个程序员都是必需要掌握的。本实例针对多线程技术在应用中经常遇到的问题，如线程间的通信、同步等，分别进行探讨，并利用多线程技术进行线程之间的通信，实现了数字的简单排序。一、实现方法 1、理解线程 要讲解线程，不得不说一下进程，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。线程的基本思想很简单，它是一个独立的执行流，是进程内部的一个独立的执行单元，相当于一个子程序，它对应于Visual C++中的CwinThread类对象。单独一个执行程序运行时，缺省地包含的一个主线程，主线程以函数地址的形式出现，提供程序的启动点，如main （）或WinMain（）函数等。当主线程终止时，进程也随之终止。根据实际需要，应用程序可以分解成许多独立执行的线程，每个线程并行的运行在同一进程中。 一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。操作系统给每个线程分配不同的CPU时间片，在某一个时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行，由于每个时间片时间很短，所以对用户来说，仿佛各个线程在计算机中是并行处理的。操作系统是根据线程的优先级来安排CPU的时间，优先级高的线程优先运行，优先级低的线程则继续等待。 线程被分为两种：用户界面线程和工作线程（又称为后台线程）。用户界面线程通常用来处理用户的输入并响应各种事件和消息，其实，应用程序的主执行线程CWinAPP对象就是一个用户界面线程，当应用程序启动时自动创建和启动，同样它的终止也意味着该程序的结束，进程终止。工作线程用来执行程序的后台处理任务，比如计算、调度、对串口的读写操作等，它和用户界面线程的区别是它不用从CWinThread类派生来创建，对它来说最重要的是如何实现工作线程任务的运行控制函数。工作线程和用户界面线程启动时要调用同一个函数的不同版本；最后需要读者明白的是，一个进程中的所有线程共享它们父进程的变量，但同时每个线程可以拥有自己的变量。 2、线程的管理和操作 （一）线程的启动 创建一个用户界面线程，首先要从类CwinThread产生一个派生类，同时必须使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE来声明和实现这个CwinThread派生类。第二步是根据需要重载该派生类的一些成员函数如：ExitInstance（）、InitInstance（）、OnIdle（）、PreTranslateMessage（）等函数。最后调用AfxBeginThread()函数的一个版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 启动该用户界面线程，其中第一个参
操作系统课程设计：Linux系统管理实践与进程通信实现
操作系统课程设计：Linux系统管理实践与进程通信实现
操作系统课程设计——Linux系统管理实践与进程通信实现 班级网络10 学号 31006100 姓名 YHD 指导老师詹永照
二零一三年一月八号 一、设计内容 1、Linux系统的熟悉与常用操作命令的掌握。 2、Linux环境下进程通信的实现。（实现父母子女放水果吃水果的同步互斥问题，爸爸放苹果，女儿专等吃苹果，妈妈放橘子，儿子专等吃橘子，盘子即为缓冲区，大小为5。） 二、Linux环境介绍 1、Linux的由来与发展 Linux是一种可以在PC机上执行的类似UNIX的操作系统，是一个完全免费的操作系统。1991年，芬兰学生Linux Torvalds开发了这个操作系统的核心部分，因为是Linux改良的minix系统，故称之为Linux。 2、Linux的优点 （1）Linux具备UNIX系统的全部优点 Linux是一套PC版的UNIX系统，相对于Windows是一个十分稳定的系统，安全性好。 （2）良好的网络环境 Linux与UNIX一样，是以网络环境为基础的操作系统，具备完整的网络功能，提供在Internet或Intranet的邮件，FTP，www等各种服务。 （3）免费的资源 Linux免费的资源和公开的源代码方便了对操作系统的深入了解，给编程爱好者提供更大的发挥空间。 3、Linux的特点 1）全面的多任务，多用户和真正的32位操作系统 2）支持多种硬件，多种硬件平台
3）对应用程序使用的内存进行保护 4）按需取盘 5）共享内存页面 6）使用分页技术的虚拟内存 7）优秀的磁盘缓冲调度功能 8）动态链接共享库 9）支持伪终端设备 10）支持多个虚拟控制台 11）支持多种CPU 12）支持数字协处理器387的软件模拟 13）支持多种文件系统 14）支持POSIX的任务控制 15）软件移植性好 16）与其它UNIX系统的兼容性 17）强大的网络功能 三、常用命令介绍 1、目录操作 和DOS相似，Linux采用树型目录管理结构，由根目录（/）开始一层层将 子目录建下去，各子目录以 / 隔开。用户login后，工作目录的位置称为 home directory，由系统管理员设定。‘~’符号代表自己的home directory，例 如 ~/myfile 是指自己home目录下myfile这个文件。 Linux的通配符有三种：’*’和’?’用法与DOS相同，‘-‘代表区间内 的任一字符，如test[0-5]即代表test0，test1，……，test5的集合。 （1）显示目录文件 ls 执行格式： ls [-atFlgR] [name] (name可为文件或目录名称) 例： ls 显示出当前目录下的文件 ls -a 显示出包含隐藏文件的所有文件 ls -t 按照文件最后修改时间显示文件 ls -F 显示出当前目录下的文件及其类型
线程、进程、多线程、多进程和多任务之间的区别与联系
线程、进程、多线程、多进程和多任务之间的区别与联系
可能学习操作系统开发的读者都听说过这些专业名词，但又多少人理解了？ 首先，从定义开始，先看一下教科书上进程和线程定义：进程：资源分配的最小单位。线程：程序执行的最小单位。 1 进程进程是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。 举例说明进程：想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕，他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(CPU)，而做蛋糕的各种原料就是输入数据。 进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机制是从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学
家又回来做蛋糕，从他离开时的那一步继续做下去。 2 线程线程是CPU调度的最小单位(程序执行流的最小单元)，它被包含在进程之中，是进程中的实际运作单元。一条线程是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 一个标准的线程有线程ID、当前指令指针(PC),寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单元，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现处间断性。 线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。举例说明线程：假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。这种机制就是线程。 总的来说：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。