面试题二（谈谈进程与线程）
& &进程就是一个应用程在处理机上的一次执行过程，
它是一个动态的概念。而线程是进程的一部分，一个进程可以包含多个线程.
& &进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。它不只是程序的代码，还包括当前的活动，通过程序计数器的值和处理寄存器的内容来表示。
&&进程是一个“执行中的程序”。程序是一个没有生命的实体，只有处理器赋予程序生命时，它才能成为一个活动的实体，我们称其为进程。
&&通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位。由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统内多个程序间并发执行的程度。
&线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。多线程主要是为了节约CPU时间，发挥利用，根据具体情况而定。线程的运行中需要使用计算机的内存资源和CPU。
&&线程与进程的区别归纳：
a.地址空间和其它资源：进程间相互独立，同一进程的各线程间共享。某进程内的线程在其它进程不可见。
b.通信：进程间通信IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步和互斥手段的辅助，以保证数据的一致性。
c.调度和切换：线程上下文切换比进程上下文切换要快得多。
d.在多线程OS中，进程不是一个可执行的实体。
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。进程和线程的区别线程是指进程内的一个执行单元,也是进程内的可调度实体. 与进程的区别: (1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址 空间;而进程有自己独立的地址空间; (2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资 源 (3)线程是处理器调度的基本单位,但进程不是. 4)二者均可并发执行. 进程和线程都是由操作系统所体会的程序运行的基本单元， 系统利用该基本单元 实现系统对应用的并发性。进程和线程的区别在于： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大 地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。 每个独立的线程有一个程序运行的入口、 顺序执行序列和程序的出口。 但是线程不能够独立执行， 必须依存在应用程序中， 由应用程序提供多个线程执行控制。 从逻辑角度来看， 多线程的意义在于一个应用程序中，有多个执行部分可以同时 执行。 但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和 管理以及资源分配。这就是进程和线程的重要区别。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系 统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是 CPU 调度和分派的基本单位,它是比进程更小的能独 立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可 少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线 程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执 行.&stdio.h&和&stdio.h &区别 #include &stdio.h & 当要调用某个函数时 先在用户自已编写的文件中查找，如果找不到再到库文件里去找， 而#include &stdio.h& 是直接到库文件里去找 所以如果是调用自己写的函数的话就用#include &stdio.h &,这种形式 而调用标准库函数的话就用#include &stdio.h& 这种形式，可以提高速度
赞助商链接您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
浅谈进程与线程的区别.pdf 3页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
浅谈进程与线程的区别.pdf
你可能关注的文档：
··········
··········
2009年12月第12期
况，共同研究正确教育学生的方法。摸索不同类型家长教育孩子
斗和艰苦朴素的好作风。有的家长善于指导孩子的学习，这样的
的规律，不同的家长在教育孩子问题上的方法和态度是各式各样
家长不但为孩子创造了良好的学习环境，还能从学习方法上对孩
的。有的家长溺爱孩子，看不到孩子身上的缺点和错误，在老师
子进行指导，使孩子的学习成绩一直保持优异。还有的家长不仅
面前喜欢夸奖自已的孩子。如果老师向其反映孩子的问题，他们
仅关心孩子的学习习惯，还能很好地培养孩子按时睡觉、起床的
会不高兴，甚至还会为孩子辩解。对于这样的家长不能一味顺着
良好生活习惯。有的家长很关心孩子的健康状况，很主重培养孩
他们，而要向他们宣传怎么样才是真正爱孩子的道理。有的家长
子积极参加体育活动等良好习惯养成。通过多年的班主任工作，
相信“棍棒下面出孝子，棍棒下面出人才”，对这样的家长，老师
也使我从学生家长身上学到了许多知识。
若向他们反映了学生的问题，学生就要倒霉，不是受骂就是挨打。
总之，班主任老师要做好班主任工作，就必须把工作做到学
所以，对这样的家长，老师在家访时即要反映学生存在问题的一
生家里去。&家访：》是班主任老师工作的一项重要内容；是学校
面，又要反映学生进步的一面，并帮助家长以正确的方法来教育
教育工作在校外的继续。班主任老师在每一学期都应有计划、有
孩子。三是老师在家访中要虚心向家长学习，认真总结和交流有
步骤地做好这一项工作，以便把学校教育、家庭教育和社会各方
些家长教育孩子的经验。老师既是教育者，又是受教育者，要虚
面的教育力量结合起来，以发挥对学生更为有效的教育作用。
心学习有些家长在教育孩子时的一些好思想和好经验。比如，有
(作者单位：陕西省成阳市渭城区塔尔坡学校)
的学生家庭经济条件比较好，但是，家长很注重培养孩子艰苦奋
浅谈进程与线程的区别
王群蔡朝晖
【摘要】根据操作系统的定义，进程是系统资源管理的最小单位，线程是程序执行的最小单位。线程和进程十分相似，本文从不用
角度介绍进程与线程的区别。
【关键词】进程；线程；操作系统
关于进程和线程，有时真的挺迷糊，说不清道不明。这里讲
为拥有资源的基本单位。
的进程和线程是指windows下的，Unix下的定义有些不同。进程
1．2并发性：不仅进程之间可以并发执行，同一个进程的多
和线程都是操作系统程序运行的基本单元，系统利用该基本单元
个线程之间也可并发执行。
实现系统对应用的并发性。—个程序至少有—个进程，一个进程
1．3拥有资源：进程是拥有资源的一个独立单位，线程不拥
至少有一个线程。线程是进程内的一个执行单元，也是进程内
有系统资源，但可以访问隶属于进程的资源。
的可调度实体。
1．4系统开销：在创建或撤消进程时，由于系统都要为之分
进程含有内存和资源。进程拥有的内存，在32位下理论上 配和回收资源，导致系统的开销明显大于创建或撤消线程时的开
可以有4G!进程拥有的资源则包括核心对象(如file
销。这个比较只是对现代以为线程epu调度单位的系统的描述。
线程)、USER资源(如对话框和字符串)、GDI资源(如Device
1．5线程的引入：例如，有一个web服务器要进程的方式
Context和Brushes)。进程本身并不能够执行，它只是提供一个安
并发地处理来自不同用户的网页访问请求的话，可以创建父进
正在加载中，请稍后...博主最新文章
博主热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)下次自动登录
现在的位置:
& 综合 & 正文
《现代操作系统》精读与思考笔记 第二章 进程和线程
　　本系列博文是《现代操作系统（英文第三版）》（Modern Operating Systems，简称MOS）的阅读笔记，定位是正文精要部分的摘录和课后习题精解，因此不会事无巨细的全面摘抄，仅仅根据个人情况进行记录和推荐。由于是英文版，部分内容会使用英文原文。
　课后习题的选择标准：尽量避免单纯的概念考察（如：What is spooling?）或者简单的数值计算，而是能够引起思考加深理解的题目。为了保证解答的正确性，每道题都会附上原书解答，而中文部分会适当加入自己的见解。原书答案（需注册）
　　从本节开始，新增“概念名称回顾”，不会展开来写，仅供按图索骥、查漏补缺，方便回顾。上一节也会补上。
概念名称回顾
　　进程：相关API、状态、实现；
　　线程：和进程的区别与联系、内核级线程和用户级线程区别和实现及优劣；
　　进程通信：竞争条件、临界区、互斥与忙等、信号量、互斥锁、管程、消息传递、屏障
　　调度：不同系统的不同调度算法、机制与策略分离；
　　典型IPC问题：哲学家进餐问题、读者—写者问题
1.关于进程数目、进程平均I/O频率与CPU利用率的推导
　　原书P94假设进程用于等待I/O结束的时间为它运行的总时间中的p（比如，p=80%代表这个进程I/O花费的时间是总运行时间的80%），同一时间内内存中一共有n个进程在运行，那么这n个进程都在等待I/O的概率为pn——这意味着所有的进程都没用使用CPU，也即CPU处在空闲状态——那么，根据对立事件的概率，CPU利用率就可以表示为：
　　　　CPU 利用率
　　利用这个公式做图表，会得到很多有价值的结论。
　　可以看出，(1)在进程数相同时，I/O频率越高，CPU的利用率越低；(2)为了提高CPU的利用率，可以采取的方法是增加同时运行的进程数。
　　虽然这个公式是把I/O频率平均化所得的近似公式，并且假定这n个进程之间的运行互不干扰；更准确的模型需要用排队论的知识进行构建，但是，“增加进程数以使得CPU更不常处于空闲状态”的结论，依然正确，并与上图仅仅有着轻微的不同。
　　这个简单模型甚至还能得到另一个推断：如果计算机拥有512MB内存，操作系统占用了128MB，其余进程I/O频率都是80%，并且每个占用128MB，那么此时的CPU利用率是1-0.83，也即49%；而当增加512MB内存时，意味着可以运行更多的4个进程，这时CPU的利用率会提升到79%，也即这额外的<span style="color:#2MB内存带来了<span style="color:#%的CPU利用率提升。
　　更神奇的是，这个简单模型还可以用来计算多个进程并行时所需使用的总时间，例子请参考习题5。
2.Peterson解法
　　原书P123，为了能够保证进程互斥地进入临界区（critical_region），并要求只使用软件编码实现（不提供额外的硬件机制），最初可以想到的解决方法如下，它被称为严格轮换法（Strict Alternation）：
//process 0
while(TURE) {
while(turn != <span style="color:#)
critical_region();
turn = <span style="color:#;
noncritical_region();
//process 1
while(TURE) {
while(turn != <span style="color:#)
critical_region();
turn = <span style="color:#;
noncritical_region();
　　虽然可以保证互斥这一要求，但是这两个进程只能轮流进入临界区，这意味着较快的一个进程会被较慢的另一个所拖慢。也即，当process0刚退出临界区而使得turn=1、process1在非临界区时，process0不能马上再次进入临界区，这违反了（原文中的前文“一个好的临界区访问方式”的）条件3，这4个条件如下：
1.任何两个进程不能同时进入同一个临界区；
2.不应做出有关CPU速度或个数的任何假设；
3.任何不在它的临界区的进程不应阻塞其他进程；
4.不应有任何进程无限地等待进入临界区。
　　看来这个根据直觉写出的解法并不令人满意。为了从软件角度解决这个问题，不同人提出了不同的算法。Peterson于1981年发现了一个相当简单的解法：
#define FALSE 0
#define TRUE 1
#define N 2
　　　　　　　　　　　　 /* number of processes */
　　　　　　　　　　　　 /* whose turn is it? */
int interested[N];
　　 　　　　 /* all values initially 0 (FALSE) */
void enter_region(int process)
/* process is 0 or 1 */
int 　　　　　　　　　　
/* number of the other process*/
other = <span style="color:# - 　　　　　　 /* the opposite of process */
interested[process] = TRUE;
/* show that you are interested */
turn = 　　　　　　　
/* set flag */
while(turn == process && interested[other] == TRUE)
　　　　　　　　　　　　　　 /* null statement */
void leave_region(int process)
/* process: who is leaving */
interested[[process] = FALSE; /* indicate departure from critical region */
　　稍作分析可以看出，如果只有一个进程，可以无限运行下去；如果有两个进程，它们都标记了自己对临界区感兴趣（interested[process] = TRUE），但此时turn由后设置者决定。而先设置者p0正好可以退出while循环，执行临界区代码，并于退出临界区时声明自己对临界区无兴趣（interested[[process] = FALSE）。这时，如果另一个进程p1在忙等，则可以进入临界区；如果不在忙等，它的interseted要么非真（未执行到这个语句），要么为真但尚未开始进行忙等：对于前者，如果p0足够快，可以再次进入临界区；对于后者，p0就只能开始忙等，等待p1先进入临界区了。
　　读者可能对上面我的转述看的一头雾水，没关系，自行根据代码和情形假设推导下各个情况才能理解这个解法的妙处。我个人认为这段代码妙处在于，它用了两个变量（一个整型和一个2个元素的数组）而非单一变量来提供更好的解法，这个思路非常值得学习。
<span style="color:#.实时系统中周期任务可调度的条件的推导
　　原书P161，假设一个实时系统中所有任务都是周期性的，一共有m个任务，第i个任务周期为Pi，需要时间Ci的CPU才能处理完，那么这些任务可调度的条件是
\[\sum_{i=1}^{m}\frac{C_{i}}{P_{i}}\leq 1\]
　　原书没有解释这个式子怎么推导的，我这里做一个简单的解释：首先，对所有分式进行通分，其分母就表示了一个“大周期”，在这个“大周期”里，任务i被执行的次数就是它在分子中的系数。只要分子小于等于分母，也即分数值小于等于1，这些任务便可以在这个“大周期”中执行所需执行的次数，并且不会逾期。同时，对于某个任务，其C/P大于1，那么无论如何这些任务都是不可调度的。
4.哲学家进餐问题
　　这部分完整描述在原书P164~167。当初学习汤子瀛版《计算机操作系统》时，这个问题的解决一种是加了限制条件的普通信号量（《现代操作系统》图2-45的解法与之类似），另一种是同时对两个数据操作的AND型信号量。下面看看图2-46给出的既能保证不死锁，又能最大化同时进餐的哲学家数目的解法：
　　　　　　　　　　/* number of philosophers */
#define LEFT
/* number of i's left neighbor */
#define RIGHT
/* number of i's right neighbor */
#define THINKING
　　　　　　/* philosopher is thinking */
#define HUNGRY
　　　　　　 /* philosopher is trying to get forks */
#define EATING
　　　　　　
/* philosopher is eating */
typedef int　　　　　 /* semaphores are a special kind of int */
int state[N]; 　　　　　　　　　　/* array to keep track of everyone's state */
semaphore mutex = <span style="color:# ; 　　　　　 /* mutual exclusion for critical regions */
semaphore s[N]; 　　　　　　　　　/* one semaphore per philosopher */
void philosopher(int i) 　　　　/* i: philosopher number, from 0 to N-1 */
while (TRUE) { 　　　　　　
/* repeat forever */
think(); 　　　　　　　　 /* philosopher is thinking */
take_ forks(i); 　　　　 /* acquire two forks or block */
eat(); 　　　　　　　　　　/* yum-yum, spaghetti */
put_ forks(i); 　　　　　 /* put both forks back on table */
void take_forks(int i) 　　　　　 /* i: philosopher number, from 0 to N-1 */
down(&mutex); 　　　　　　　　 /* enter critical region */
state[i] = HUNGRY; 　　　　　 /* record fact that philosopher i is
test(i); 　　　　　　　　　　　 /* try to acquire 2 forks */
up(&mutex); 　　　　　　　　　 /* exit critical region */
down(&s[i]);　　　　　　　　　 /* block if
forks were not acquired */
void put_forks(i) 　　　　　　　　/* i: philosopher number, from 0 to N-1 */
down(&mutex); 　　　　　　　　/* enter critical region */
state[i] =THINKING; 　　　　 /* philosopher has finished eating */
test(LEFT); 　　　　　　　　　 /* see if left neighbor can now eat */
test( RIGHT); 　　　　　　　　/* see if
right neighbor can now eat */
up(&mutex); 　　　　　　　　
/* exit critical region */
void test(i) 　　　　　　　　　　/* i: philosopher number, from 0 to N-1 */
if (state[i] ==HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {
state[i] = EATING;
up(&s[i]);
　　这种对自身状态的标记，与上面提到的Perterson解法思路很类似。这里的临界区，是所有哲学家的状态state[]数组，只有合法的状态转换才允许继续，如果两边的哲学家至少有一边在吃，就会被阻塞，而这个阻塞会在两边发生状态转化时被测试是否可以被唤醒，非常巧妙的解法。课后45、46题是对这个解法的进一步讨论，直接列在下面，由于不难理解，没有翻译。
45. In the solution to the dining philosophers problem (Fig. 2-46), why is the state variable set to HUNGRY in the procedure take_forks?
　　The change would mean that after a philosopher stopped eating, neither of his neighbors could be chosen next. In fact, they would never be chosen. Suppose that philosopher 2 finished eating. He would runtest for philosophers 1 and 3, and neither would
be started, even though both were hungry and both forks were available. Similarly, if philosopher 4 finished eating, philosopher 3 would not be started. Nothing would start him.
46. Consider the procedure put_forks in Fig. 2-46. Suppose that the variable state[i] was set to THINKING after the two calls to test, rather than before. How would this change affect the solution?
　　If a philosopher blocks, neighbors can later see that she is hungry by checking his state, in test , so he can be awakened when the forks are available.
课后习题选
4.When an interrupt or a system call transfers control to the operating system, a kernel stack area separate from the stack of the interrupted process is generally used. Why?
　　当中断或系统调用使得系统的控制权交给操作系统时，所用的内核栈通常与用户栈是分开的，为什么这么设计？
　　There are several reasons for using a separate stack for the kernel. Two of them are as follows. First, you do not want the operating system to crash because a poorly written user program does not allow for enough stack space. Second,
if the kernel leaves stack data in a user program’s memory space
upon return from a system call, a malicious user might be able to use this data to find out information about other processes.
答案译文：
　　这有原因，其中两个是：第一，用户栈可能很小，如果内核栈不是独立的而是使用用户栈的一部分，那么系统会因空间不足崩溃；第二，当返回用户空间时，恶意用户可以通过自己的栈（由中断或系统调用时产生的）残留的内容获取别的进程的信息。
5.Multiple jobs can run in parallel and finish faster than if they had run sequentially. Suppose that two jobs, each of which needs 10 minutes of CPU time, start simultan-eously. How long will the last one take to complete if
they run sequentially? How long if they run in parallel? Assume 50% I/0 wait.
译：两个I/O频率都为50%、都需要10分钟CPU时间的任务，顺序运行需要多少时间？并行运行需要多少时间？
　　If each job has 50% I/O wait, then it will take 20 minutes to complete in the absence of competition. If run sequentially, the second one will finish 40 minutes after the first one starts.
Withtwo jobs, the approximate CPU utilization is 1 - 0.52. Thus each one gets 0.375 CPU minute per minute of real time. To accumulate 10 minutes of CPU time, a job must run for 10/0.375 minutes, or about 26.67
minutes. Thus running sequentially the jobs finish after 40 minutes, but running in parallel they finish after 26.67 minutes.
　　顺序执行的时候，根据I/O频率为50%、CPU时间10分钟，那么分别需要20分钟，一共就是40分钟。
　　并行时，根据正文文第2条介绍，CPU利用率为1 - 0.52，这意味着每分钟每个进程并行时实际获得用于处理的CPU时间是0.75/2 = 0.375分钟，那么执行完需要10分钟的CPU时间的工作实际使用了10/0.375 = 26.67分钟。又由于是并行的，相当于二者同时完成，因此是26.67分钟。
　　我一开始简单地认为并行时只需要20分钟，但是明显是没有依据的，即使是并行，单个单核心单线程CPU（这是本章的假设之一）在某个时刻而非某一个时期内仍然只能执行一个任务。
26.Show how counting semaphores (i.e., semaphores that can hold an arbitrary value) can be implemented using only binary semaphores and ordinary machine instructions.
　　如何用二值信号量和一些机器指令实现计数信号量。
　　Associated with each counting semaphore are two binary semaphores, M ,used for mutual exclusion, and B , used for blocking. Also associated with each counting semaphore is a counter that holds the number of ups minus the number
of downs, and a list of processes blocked on that semaphore. To implement down, a process first gains exclusive access to the semaphores, counter, and list by doing a down on M . It then decrements the counter. If it is zero or more, it just does an uponM
and exits. If M is negative, the process is put on the list of blocked processes. Then an upis done on M and a down is done on B to block the process. To implement up, first M is downed to get mutual exclusion, and then the counter is incremented. Ifit is
more than zero, no one was blocked, so all that needs to be done is to up M. If, however, the counter is now negative or zero, some process must be removed from the list. Finally, an upis done on B and M in that order.
答案译文：
　　用两个二值信号量和一个计数器counter实现一个计数信号量：M用于互斥，B用于阻塞，counter用于记录up减去down的次数，再用一个链表来记录阻塞在这个计数信号量上的进程。
　　down的实现：进程先对M进行down来获得counter、链表的独占访问权，并把counter减1。如果counter大于等于0，直接对M进行up即可；否则，记录在链表再up，然后对B进行down从而阻塞这个进程。
　　up的实现：进程同样先对M进行down，count加1，若其大于0，直接对M进行up即可；否则count小于等于0，把链表中一个进程移出，然后对B、M依次up。
1.P163的2.5标题下方，"... we will examine three of the ..."，而本节实际上一共只介绍了两种
2.P166的图2-46，put_forks(i)的函数定义缺少i的类型int
3.P173.习题46应为Fig.2-46而非2-20
【上篇】【下篇】