进程线程的概念

提起程序这个概念，大家再也熟悉不过了，程序与进程概念是不可分的。程序是为了完成某项任务编排的语句序列，它告诉计算机如何执行，因此程序是需要运行的。程序运行过程中需要占有计算机的各种资源才能运行下去。如果任一时刻，系统中只有一道程序，即单道程序系统，程序则在整个运行过程中独占计算机全部资源，整个程序运行的过程就非常简单了，管理起来也非常容易。就象整个一套房子住了一个人，他想看电视就看电视，想去卫生间就去卫生间，没人和他抢占资源。但为了提高资源利用率和系统处理能力，现代计算机系统都是多道程序系统，即多道程序并发执行。程序的并发执行带来了一些新的问题，如资源的共享与竞争，它会改变程序的执行速度。就象多个人同时住一套房子，当你想去卫生间的时候，如果此时卫生间里有人，你就得等待，影响了你的生活节奏。如果程序执行速度不当，就会导致程序的执行结果失去封闭性和可再现性，这是我们不希望看到的。因此应该采取措施来制约、控制各并发程序段的执行速度。由于程序是静态的，我们看到的程序是存储在存储介质上的，它无法反映出程序执行过程中的动态特性，而且程序在执行过程中是不断申请资源，程序作为共享资源的基本单位是不合适的，所以需要引入一个概念，它能描述程序的执行过程而且可以作为共享资源的基本单位，这个概念就是进程。

进程的生命周期

进程和人一样是有生命的，从诞生到死亡要经历若干个阶段。一般说来进程有三种状态：就绪、执行、等待。由多种原因可以导致创建一个进程，例如一个程序从外存调入内存开始执行，操作系统就要为其创建进程，当然还可以有其它原因，如一个应用进程为完成一个特殊的任务，可以自己创建一个子进程。进程被创建后就是在内存中，处于就绪状态，所谓就绪状态就是具备除了CPU之外的所有资源，万事具备，只欠东风，一旦占有

了CPU，就变成了执行状态，执行中如果需要等待外围设备输入数据，则进程就沦落为

等待状态，操作系统又会从就绪状态队列中调度一个进程占有CPU。等到数据到来后，

等待状态的进程又被唤醒成为就绪状态。这些状态的转换是通过进程控制原语实现的。程序的运行是通过进程体现的，操作系统对进程进行管理和控制，那么操作系统怎么了解到进程的状态呢，怎么把资源分配给进程呢，而且进程做状态转换时CPU现场保存在那呢？这要说到PCB（进程控制快）。PCB是进程的唯一标志，在其中记录了进程的全部信息，它是一种记录型的数据结构，相当于进程的档案。操作系统就通过PCB感知进程的存在，通过PCB了解进程和控制进程的运行。PCB也是放在内存中的，如果PCB太大，有些系

统把PCB中一些不重要的信息放在外存中。

进程执行速度的制约

并发进程由于共享系统内部资源，因此导致进程执行速度上的制约，这种制约分为：间接制约与直接制约。间接制约引起进程之间的互斥执行，直接制约引起进程间的同步执行。例如一个家里如果只有一个卫生间，卫生间这个公有资源使得每个人只能互斥使用它，这就是间接制约。而直接制约是指并发进程各自执行的结果互为对方的执行条件，例如司机与售票员的关系，当司机到站停车后，售票员才能开门，而只有售票员关门后，司机才

能开车，他们之间是同步的。进程的互斥与同步可以很好的通过信号量和PV原语来实现。通过读一些同步与互斥的例子，你会体会到PV原语的精妙，也会感到一种乐趣。并发进

程的资源竞争不当还会导致死锁现象。

从单进程单线程到多进程多线程是操作系统发展的一种必然趋势，当年的DOS系统

属于单任务操作系统，最优秀的程序员也只能通过驻留内存的方式实现所谓的"多任务"，

而如今的Win32操作系统却可以一边听音乐，一边编程，一边打印文档。

理解多线程及其同步、互斥等通信方式是理解现代操作系统的关键一环，当我们精通了Win32多线程程序设计后，理解和学习其它操作系统的多任务控制也非常容易。许多

程序员从来没有学习过嵌入式系统领域著名的操作系统VxWorks，但是立马就能在上面

做开发，大概要归功于平时在Win32多线程上下的功夫。

因此，学习Win32多线程不仅对理解Win32本身有重要意义，而且对学习和领会其

它操作系统也有触类旁通的作用。

进程与线程

先阐述一下进程和线程的概念和区别，这是一个许多大学老师也讲不清楚的问题。

进程（Process）是具有一定独立功能的程序关于某个数据集合上的一次运行活动，

是系统进行资源分配和调度的一个独立单位。程序只是一组指令的有序集合，它本身没有任何运行的含义，只是一个静态实体。而进程则不同，它是程序在某个数据集上的执行，是一个动态实体。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消，反映了一个程序在一定的数据集上运行的全部动态过程。

线程（Thread）是进程的一个实体，是CPU调度和分派的基本单位。线程不能够独

立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

线程和进程的关系是：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

根据进程与线程的设置，操作系统大致分为如下类型：

（1）单进程、单线程，MS-DOS大致是这种操作系统；

（2）多进程、单线程，多数UNIX（及类UNIX的LINUX）是这种操作系统；

（3）多进程、多线程，Win32（Windows NT/2000/XP等）、Solaris 2.x和OS/2都是

这种操作系统；

（4）单进程、多线程，VxWorks是这种操作系统。

在操作系统中引入线程带来的主要好处是：

（1）在进程内创建、终止线程比创建、终止进程要快；

（2）同一进程内的线程间切换比进程间的切换要快，尤其是用户级线程间的切换。另外，线程的出现还因为以下几个原因：

（1）并发程序的并发执行，在多处理环境下更为有效。一个并发程序可以建立一个进程,而这个并发程序中的若干并发程序段就可以分别建立若干线程,使这些线程在不同的处理机上执行。

（2）每个进程具有独立的地址空间，而该进程内的所有线程共享该地址空间。这样可以解决父子进程模型中，子进程必须复制父进程地址空间的问题。

（3）线程对解决客户/服务器模型非常有效。

进程是计算机进行资源分配和独立运行的基本单位。

3.1 进程的引入

引入进程是为了使多道程序并发执行。

1.程序的顺序执行

一个程序通常由若干个程序段所组成，它们必须按照某种先后次序来执行，仅当前一个操作执行完后才能执行后继操作，这类计算过程就是程序的顺序执行过程。

例如：先输入→再计算→最后输出，即：I→C →P。

程序顺序执行时的特征

顺序性：处理机的操作严格按照程序所规定的顺序执行，即每一个操作必须在下一个操作开始之前结束。

封闭性：程序一旦开始运行，其执行结果不受外界因素影响。

可再现性：只要程序执行时的初始条件和执行环境相同，当程序重复执行时，都将获得相同的结果。

2.程序的并发执行

程序的并发执行是指若干个程序(或程序段)同时在系统中运行，这些程序(或程序段)的执行在时间上是重叠的，一个程序(或程序段)的执行尚未结束，另一个程序(或程序段)的执行已经开始。

前驱图

前驱图是一个有向无循环图，图中的每个结点可以表示一条语句、一个程序段或进程，结点间的有向边表示语句或程序段的执行次序。

程序并发执行例

进程1、2、3并发执行。对每个进程而言，其输入、计算和输出这三个操作必须顺序执行。它们之间存在如下先后关系：

I1先于C1和I2 ， C1先于P1和C2 ， P1先于P2

I2和C1 ， I3、 C2和P1可以并发。

与时间有关的错误例

程序并发执行时可能出现与时间有关的错误。

例

进程1：r1=x; 进程2：r2=x;

r1++; r2++;

x=r1; x=r2;

设在两进程运行之前，x的值为0。则两进程运行结束后，x值可为：

Bernstein条件

读集：语句执行期间要引用的变量集合，记为R(Si)={a1，…，am}

写集：语句执行期间要改变的变量集合，记为W(Si)={b1，…，bn}

Bernstein条件能保证两条相继的语句并发执行而不会产生与时间有关的错误：

R(Si)∩ W(Sj)={ }

R(Sj)∩ W(Si)={ }

W(Si)∩ W(Sj)={ }

例

考虑下面是条语句：

S1：a=x+y S2：b=z+1

S3：c=a-b S4：d=c+1

R(S1)={x,y} R(S2)={z} R(S3)={a,b}

W(S1)={a} W(S2)={b} W(S3)={c}

因R(S1)∩ W(S2)∪R(S2)∩ W(S1)∪W(S1)∩W(S2)={ }，故S1和S2可以并发执行。

因R(S2)∩ W(S3)∪R(S3)∩ W(S2)∪W(S3)∩W(S2)={b}，故S2和S3不能并发执行。

并发语句的描述方式

cobegin

S1;S2;…Sn;

coend

对应的前驱图如右，其中S0和Sn+1分别是cobegin和coend语句前后的两条语句。

程序并发执行时的特征

间断性：并发程序具有“执行---暂停----执行”这种间断性的活动规律。

失去封闭性：多个程序共享系统中的资源，这些资源的状态将由多个程序来改变，致使程序之间相互影响。

不可再现性：在初始条件相同的情况下，程序的执行结果依赖于执行的次序。

并发程序的其他特征

资源分配动态性：多道程序在运行过程中可根据需要随时提出分配资源的请求。

程序并发执行的相互制约：并发程序执行时相互影响，相互制约。其相互制约关系分为：

直接制约：合作进程之间的相互制约。

间接制约：因资源共享产生的相互制约。

相互通信的可能：多个进程之间可能需要相互传递信息。

同步与互斥的必要：并发进程之间需要调整相对执行速度，许多资源需要互斥使用。

3.2 进程的概念

为了描述并发执行程序的动态特性，人们引入了一个新的概念——进程。

1. 进程的定义

进程有多种定义，下面列举一些有代表性的定义：

进程是可以并发执行的计算部分。

进程是一个程序与其数据一道通过处理机的执行所发生的活动。

进程是一个数据结构及在其上进行加工处理的过程。

进程是一个可以高度独立的活动。

进程是一个具有一定独立功能的程序在一个数据集合上的运行过程，它是系统进行资源分配和调

度的一个独立单位。

进程的特征

动态性：进程是程序的一次执行过程。动态性还表现为它因创建而产生，因调度而执行，因无资

源而暂停，因撤消而消亡。而程序是静态实体。

并发性：多个进程实体同时存在于内存中，能在一段时间内同时运行。

独立性：在传统OS中，进程是独立运行的基本单位，也是系统分配资源和调度的基本单位。

异步性：也叫制约性，进程之间相互制约，进程以各自独立的不可预知的速度向前推进。

结构性：进程实体由程序段、数据段及进程控制块组成，又称为进程映像。

进程与程序的联系与区别

进程是动态概念，程序是静态概念;进程是程序在处理机上的一次执行过程，而程序是指令的集合。

进程具有并发性，但程序没有。

进程是竞争处理机和资源的基本单位。

不同进程可以包含同一个程序。

进程可以创建新进程，而程序不能形成新程序。

2. 进程的基本状态

运行状态：又称执行状态。当一个进程获得必要的资源并正在处理机上执行，此时进程所处的状

态为运行状态。

等待状态：又称阻塞状态、睡眠状态。正在执行的进程，由于发生某事件而暂时无法执行下去(如

等待输入/输出完成)，此时进程所处的状态为的等待状态。这时即使把处理机分配给该进程，它也无

法运行。

就绪状态：进程已获得除处理机以外的所有资源，一旦分配了处理机就可以立即执行，此时进程所处的状态为就绪状态。

新建状态和终止状态

在许多系统中又增加了两种状态：

新建状态：进程刚刚建立，但还未进入就绪队列。

终止状态：当一个进程正常或异常结束，操作系统已释放它所占用的资源，但尚未将它撤消时的状态，又称退出状态。

进程状态转换图

状态转换的有关说明

大多数状态不可逆转，如等待不能转换为运行。

状态转换大多为被动进行，但运行→等待是主动的。

一个进程在一个时刻只能处于上述状态之一。

3. 进程控制块

进程控制块是用于描述和管理进程的数据结构。它是进程实体的一部分，操作系统通过PCB感知进程的存在，PCB是进程存在的唯一标志。

进程控制块主要包括如下内容：

进程标识信息

处理机状态信息

进程调度和状态信息

进程控制信息

进程标识信息

进程标识信息用于标识一个进程。包括：

进程名：通常为可执行文件名。

进程标识符：唯一标识进程的整数.

用户标识符：指示进程所属的用户。

父进程标识符和子进程标识符：描述进程家族关系。

处理机状态信息

处理机状态信息用于保存现场，由处理机各寄存器组成。包括：

通用寄存器：处理机执行时可以访问的寄存器。

指令计数器：存放将要访问的下一条指令地址。

程序状态字：含执行结果状态、中断屏蔽码等。

栈指针：每进程有多个与之相关的栈，用于保存调用参数。

进程调度和状态信息

进程调度和状态信息用于存放与进程调度及对换有关的信息。包括：

进程状态：指明进程当前状态。

进程优先级：描述进程使用处理机的优先级别。

进程调度的其他信息：取决于进程调度算法，如等待时间。

等待事件：进程处于等待状态的原因。

进程控制信息

进程控制信息：包括：

程序和数据地址：指出进程的程序及数据在内存的地址。

进程同步及通讯机制：如信号量、消息队列等。

资源清单：记录进程所需的资源和已分配资源。

链接指针：处于同一状态的进程组成一个队列，链接指针指向队首。

进程特权：确定进程可以访问的内存空间及可以执行的指令类型。

3.3 进程控制

进程控制的职能是对系统中的所有进程实施有效的管理。

常见的进程控制功能有进程创建、撤消、阻塞与唤醒等。这些功能一般由操作系统内核来实现。

1.进程控制的有关概念

为了保护操作系统，将处理机的状态分为：

用户态：是用户程序执行时机器所处的状态。

核心态：是操作系统内核运行时机器所处的状态。

原语是由若干条机器指令构成的，用以完成特定功能的一段程序，这段程序在执行期间不可分割。

进程图

进程图又称进程树或进程家族树，是描述进程家族关系的一棵有向树。图中的结点表示进程，若

进程A创建了进程B，则从结点A有一条边指向结点B，说明进程A是进程B的父进程，进程B是进

程A的子进程。

进程图例

2. 进程创建

导致进程创建的原因有：

用户登录：用户登录后，若合法则为用户创建一个进程。

作业调度：为调度到的作业分配资源并创建进程。

OS服务：创建服务进程。

应用需要：应用程序根据需要创建子进程。

进程创建的方法

引导程序以特殊方式创建系统进程。如UNIX系统中的0进程。

由作业调度程序创建进程。

由父进程创建子进程。

创建原语的主要功能

进程创建原语的主要功能是为被创建进程建立一个PCB。其算法思想如下：

在PCB总链中查找同名进程，若有则出错返回;

向系统申请一个空闲PCB结构，若没有则出错返回;

初始化新进程的PCB：填写进程名、标识符、状态、程序地址等;

将进程PCB插入相应队列：插入就绪队列及PCB总链。

3. 进程终止

引起进程终止的原因有：

正常结束

异常结束：超时、内存不足、地址越界、算术错、I/O故障、非法指令等。

操作员或系统干预：因某种原因需要操作员或系统终止进程。

父进程请求：请求终止子进程。

终止原语的主要功能

进程终止原语的主要功能是撤消一个进程。其算法思想如下：

从PCB总链中查找到被终止进程的PCB，若无则出错返回;

若被终止进程正处于运行状态，则立即停止该进程的执行，设置重新调度标志;

若被终止进程有子孙进程，还应将该进程的子孙进程予以撤消;

对于被终止进程所占有的资源，或者归还给父进程，或者归还给系统;

最后撤消它的进程控制块。若需要转调度程序。

4. 进程阻塞

引起进程阻塞的原因有：

请求系统服务：如请求分配资源但尚无资源分配。

新数据尚未到达：如合作进程之间。

无新工作可做：进程已完成了给定任务，新任务未到。

阻塞原语的主要功能

阻塞原语的主要功能是将进程由执行状态转为阻塞状态。其算法思想如下：停止当前执行进程，将进程状态改为阻塞;

保存该进程的现场信息;

将该进程PCB插入到等待队列;

转进程调度程序。

5. 进程唤醒

当进程等待的事件发生时，由发现者进程将其唤醒。

唤醒原语的主要功能是将进程唤醒，其算法思想如下：

从等待队列中移出相应进程;

将该进程状态改为就绪，并将进程插入就绪队列;

转进程调度或返回。

阻塞与唤醒的关系

一个进程由执行状态转变为阻塞状态，是这个进程自己调用阻塞原语去完成的。进程由阻塞状态转变为就绪状态，是另一个发现者进程调用唤醒原语实现的。一般发现者进程与被唤醒进程是合作的并发进程。

6. 进程的挂起

在某些系统中，希望人为将进程挂起使之处于静止状态。

进程挂起的原因有：

内存不足：在外存挂起。

用户要求：可以挂起进程以腾出资源。

进程特性：周期性执行，等待下一次执行时可能挂起。

父进程请求：父进程希望挂起子进程检查。

操作系统要求：挂起一个问题进程。

挂起状态

基于上述原因，需引入一个新的状态：挂起状态。

挂起原语的主要功能

挂起原语的主要功能是将指定进程挂起。其算法思想如下：

若进程执行则停止其执行;

设置进程状态为挂起状态;

若进程当前为执行则转进程调度。

进程激活

激活原语的主要功能是将指定进程激活。其算法思想如下：

将进程状态由挂起改为激活后的状态;

若需要则转进程调度。

3.4 线程

在操作系统中引入进程的目的是使多道程序能并发执行，以改善资源利用率及提高系统吞吐量;

在操作系统中再引入线程，则是为了减少程序并发执行所付出的时空开销，使操作系统具有更好

的并发性。

1. 线程的引入

进程具有两个属性：

拥有资源的独立单位

调度和分派的基本单位

为使进程并发执行，则必须进行诸如创建、撤消、切换等一系列操作，这些操作涉及到资源管理，所花费的时空开销较大，为此引入了线程。

线程概念

线程是进程内的一个执行单元，是系统独立调度和分派的基本单位;

线程自己基本上不拥有资源，只拥有一点在运行时必不可少的资源(如程序计数器、一组寄存器和栈);

线程可以与同属一个进程的其他线程共享进程拥有的全部资源。

2.线程的控制

和进程类似，线程也有运行、就绪、阻塞等状态。

创建：当创建一个新进程时，也为该进程创建了一个线程。线程还可以创建新线程。

就绪：线程已获得除处理机外的所有资源。

运行：线程正在处理机上执行。

阻塞：线程因等待某事件而暂停运行。

终止：一个线程已完成。

线程的同步与通信与进程类似。进程的挂起及终止将影响到其中的所有线程。

2.线程的控制(续)

进程中的线程具有

执行状态

线程上下文

执行栈

线程静态存储局部变量

寄存器及对所属进程资源的访问

3.线程与进程的比较

一个进程中的所有线程共享该进程的状态和资源，它们驻留在同一地址空间，并且可以访问到相

同的数据。

线程与进程的区别

调度分派：在传统OS中，进程是调度和分配资源的基本单位;引入线程后，线程是调度和分派的

基本单位，进程是拥有资源的基本单位。

资源拥有：进程是拥有资源的基本单位，由一个或多个线程及相关资源构成。

地址空间：不同进程地址空间独立，同一进程中的各线程共享同一地址空间。

一个进程可以包含一个或多个线程。

进程间通信必须使用OS提供的进程间通信机制，而同一进程的线程间可以通过直接读写来通信。

线程的优点

创建时间：在已有进程中创建一个新线程比创建一个新进程快。

终止时间：终止一个线程比终止一个进程快。

切换时间：同一进程中线程的切换比进程间切换快。

通信效率：同一进程中线程的通信快。

4.用户级线程和内核级线程

线程的类型：

内核级线程：是指依赖于内核，由操作系统内核完成创建、撤消和切换的线程。

用户级线程：是指不依赖于操作系统核心，由应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制的线程。

线程的调度与切换速度：内核级线程的调度与切换与进程类似，但开销小些;用户级线程切换无需进入内核，因而切换快。

4.用户级线程和内核级线程(续)

系统调用：内核级线程调用系统调用时，OS将其看成是该线程的行为，因而阻塞该线程;而用户级线程调用系统调用时，OS将其看成整个进程的行为，若阻塞则阻塞整个进程。

线程执行时间：在只有用户级线程的系统中，调度以进程为单位，若进程内线程多则执行时间相对少;内核级线程系统中，调度以线程为单位。

适应性：用户级线程可以在任何操作系统中运行，但内核级线程只能在支持它的OS中运行。

UNIX的进程描述(P245)

在UNIX系统中，采用了段页式存储管理方式(在UNIX中将段称为区)，因此一个进程实体由若干个区组成，包括程序区、数据区、栈区等。每个区又可分为若干页。

进程描述的数据结构

为了实施对进程的有效管理，操作系统为每个进程设置了一个PCB。在UNIX System Ⅴ中，将PCB 分成进程表项和U区(又称proc结构和user结构)两部分。除进程表项和U区外，管理进程的数据结构还有本进程区表和系统区表。

进程表项

状态字段用于标识进程的状态。

若干用户标识号，简称UID或用户ID。

若干进程标识号，简称PID或进程ID。

存储区位置和长度。

调度参数，包括优先数等。

软中断信号域。

各种计时域，给出进程执行时间和系统资源的利用情况。

指向U区的指针，指向与进程表项对应的U区。

事件描述域，记录使进程进入睡眠状态的事件。

U区

指向进程表项的指针，指出对应于该U区的进程表项。

真正用户标识符及有效用户标识符。

用户文件描述符表，记录进程已打开的文件。

当前目录和当前根，描述进程的文件系统环境。

计时器域，记录进程及其后代运行所用的时间。

一些输入/输出参数。描述要传输的数据量，源或目的数据地址等。

限制域，指出进程的大小及它能“写”的文件大小限制。

出错域，记录系统调用执行期间所发生的错误。

返回值域，指出系统调用的返回结果。

信号处理数组，指出进程接收到软中断信号时的处理方式。

系统区表

UNIX System Ⅴ把一个进程的虚地址空间划分为正文区、数据区、栈区等。系统设置区表对区进行管理，区表主要包含以下信息：

区的类型和大小。指明区的类型为正文、数据或栈。

区的状态。一个区具有状态：锁住、在请求中、在装入过程中、有效(区已装入内存)。

区在物理存储器中的位置。

引用计数。共享该区的进程数。

指向文件索引节点的指针。

本进程区表

系统为每个进程配置了一张本进程区表，表中每一项记录一个区的起始虚地址及指向系统区表中对应区表项的指针。核心通过查找本进程区表和系统区表，将区的逻辑地址变换为物理地址。

进程的数据结构

进程状态及其转换

在UNIX System Ⅴ中，为进程设置了9种状态。

用户态执行

核心态执行

内存中就绪

内存中睡眠

就绪且换出

睡眠且换出

被剥夺状态

创建状态

僵死状态

UNIX系统的状态转换图

进程上下文

进程上下文又称进程映像，它由三部分组成：用户级上下文、寄存器上下文和系统级上下文。

用户级上下文

用户级上下文由进程虚地址空间中的正文、数据、用户栈和共享存储区组成。

寄存器上下文

寄存器上下文主要由CPU中的一些寄存器内容构成。主要的寄存器有：

程序计数器。其中存放的是CPU要执行的下条指令的虚地址。

处理机状态寄存器。其中包括运行方式(用户态、核心态)，处理机当前的运行级，以及记录处理机与该进程有关的硬件状态信息。

栈指针。指向栈的下一个可用单元或栈中最后使用的单元(因机器而异)。

通用寄存器。用于存放进程在运行过程中所产生的数据，通用寄存器的数目因机器而异。

系统级上下文

系统级上下文可分为静态和动态两部分：

静态部分：系统级上下文的静态部分由进程表项、U区、本进程区表项、系统区表项和页表组成。

动态部分：系统级上下文动态部分的数目是可变的。它包括：核心栈、若干层寄存器上下文。

进程控制

在UNIX系统中，用于对进程实施控制的主要系统调用有：fork，创建进程;exec，执行文件;exit，

进程终止;wait，等待子进程终止。

系统调用fork

系统调用fork用于创建一个新进程。

fork系统调用的语法格式如下：

int fork( )

fork系统调用没有参数，如果执行成功，则创建一个子进程，子进程继承父进程的许多特性，并

具有与父进程完全相同的用户级上下文。

fork的算法描述

算法 fork，无输入参数，父进程返回子进程PID，子进程返回0

{ 检查可用的内核资源;

取一个空闲的进程表项和惟一的PID号;

检查用户没有过多运行进程;

将子进程的状态设置为“创建”状态;

将父进程进程表项的数据拷贝到子进程进程表项中;

当前目录和根目录的索引节点引用计数加1;

文件表中打开文件的引用计数加1;

在内存中作父进程上下文的拷贝;

fork的算法描述(续)

在子进程的系统级上下文中压入虚设系统级上下文层;

if (正在执行的进程是父进程)

{ 将子进程的状态设置为“就绪”状态;

return(子进程的PID);

}

else {

初始化U区的计时域;

return(0);

}}

系统调用exec

exec系列中的系统调用都完成同样的功能，它们把一个新的程序装入调用进程的内存空间，以改变调用进程的执行代码，从而使调用进程执行新引入的程序功能。

这一组系统调用的主要差别在于给出参数的数目和形式不同。下面给出两种基本的exec调用格式说明：

int execl(path , arg0 [，arg1，…，argn]，0);

char *path，*arg0，*arg1, …，*argn ;

int execv(path，argv);

char *path，*argv[ ];

exec算法描述

算法 exec，输入参数有文件名、参数表、环境变量，无输出。{ 取文件的索引节点(算法namei);

验证文件可被执行，用户有执行许可权;

读文件头，检查它是否为装入模块;

将exec参数从老地址空间拷贝到系统空间;

for (与该进程附接的每个区)

使区与进程断接(算法detachreg);

for (装入模块中指定的每个区);

{ 分配新区(算法alloreg);

exec算法描述(续)

将新区附接到进程(算法attachreg);

进程与线程的区别 进程的通信方式 线程的通信方式

进程与线程的区别进程的通信方式线 程的通信方式 进程与线程的区别进程的通信方式线程的通信方式2011-03-15 01：04 进程与线程的区别： 通俗的解释 一个系统运行着很多进程，可以比喻为一条马路上有很多马车 不同的进程可以理解为不同的马车 而同一辆马车可以有很多匹马来拉--这些马就是线程 假设道路的宽度恰好可以通过一辆马车 道路可以认为是临界资源 那么马车成为分配资源的最小单位(进程) 而同一个马车被很多匹马驱动(线程)--即最小的运行单位 每辆马车马匹数=1 所以马匹数=1的时候进程和线程没有严格界限，只存在一个概念上的区分度 马匹数1的时候才可以严格区分进程和线程 专业的解释： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执 行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序 的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行 的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在 应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可 以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程 的调度和管理以及资源分配。这就是进程和线程的重要区别。 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的 能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中 必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的 其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以 并发执行 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有 独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线 程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程 的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者 《操作系统的设计与实现》。对就个问题说得比较清楚。 +++ 进程概念

操作系统第二章进程和线程复习题

第二章练习题 一、单项选择题 1．某进程在运行过程中需要等待从磁盘上读入数据，此时该进程的状态将（ C ）。 A. 从就绪变为运行； B．从运行变为就绪； C．从运行变为阻塞； D．从阻塞变为就绪 2．进程控制块是描述进程状态和特性的数据结构，一个进程（ D ）。 A.可以有多个进程控制块； B.可以和其他进程共用一个进程控制块； C.可以没有进程控制块； D.只能有惟一的进程控制块。 3．临界区是指并发进程中访问共享变量的（D）段。 A、管理信息 B、信息存储 C、数 据 D、程序 4. 当__ B__时，进程从执行状态转变为就绪状态。 A. 进程被调度程序选中 B. 时间片到 C. 等待某一事件 D. 等待的事件发生 5. 信箱通信是一种（ B ）通信方式。 A. 直接通信 B. 高级通信 C. 低级通信 D. 信号量 6. 原语是（B）。

A、一条机器指令 B、若干条机器指令组成 C、一条特定指令 D、中途能打断的指令 7. 进程和程序的一个本质区别是（A）。 A．前者为动态的，后者为静态的； B．前者存储在内存，后者存储在外存； C．前者在一个文件中，后者在多个文件中； D．前者分时使用CPU,后者独占CPU。 8. 任何两个并发进程之间存在着（D）的关系。 A．各自完全独立B．拥有共享变量 C．必须互斥D．可能相互制约 9. 进程从运行态变为等待态可能由于（B ）。 A．执行了V操作 B．执行了P操作 C．时间片用完 D．有高优先级进程就绪 10. 用PV操作管理互斥使用的资源时，信号量的初值应定义为（B）。 A．任意整数 B．1 C．0 D．-1 11. 现有n个具有相关临界区的并发进程，如果某进程调用P操作后变为等待状态，则调用P操作时信号量的值必定为（A）。 A．≤0 B．1 C．n-1 D．n

查看程序的进程和线程实验报告

查看程序的进程和线程实验报告 篇一：程序实验2：11-多线程编程---实验报告 程序实验二：11-多线程编程实验 专业班级实验日期 5.21 姓名学号实验一（p284：11-thread.c） 1、软件功能描述 创建3个线程，让3个线程重用同一个执行函数，每个线程都有5次循环，可以看成5个小任务，每次循环之间会有随即等待时间（1-10s）意义在于模拟每个任务到达的时间是随机的没有任何的特定规律。 2、程序流程设计 3．部分程序代码注释(关键函数或代码) #include #include #include #define T_NUMBER 3 #define P_NUMBER 5 #define TIME 10.0

void *thrd_func(void *arg ) { (本文来自：https://www.sodocs.net/doc/6c13726599.html, 小草范文网:查看程序的进程和线程实验报告) int thrd_num=(int)arg; int delay_time =0; int count =0; printf("Thread %d is staraing\n",thrd_num); for(count=0;count { delay_time =(int)(rand()*TIME/(RAND_MAX))+1; sleep(delay_time); printf("\tTH%d:job%d delay =%d\n",thrd_num,count,delay_time); } printf("%d finished\n",thrd_num); pthread_exit(NULL); } int main()

CPU的核心数、线程数的关系和区别

我们在选购电脑的时候，CPU是一个需要考虑到核心因素，因为它决定了电脑的性能等级。CPU从早期的单核，发展到现在的双核，多核。CPU除了核心数之外，还有线程数之说，下面笔者就来解释一下CPU的核心数与线程数的关系和区别。 简单地说，CPU的核心数是指物理上，也就是硬件上存在着几个核心。比如，双核就是包括2个相对独立的CPU核心单元组，四核就包含4个相对独立的CPU核心单元组，等等，依次类推。 线程数是一种逻辑的概念，简单地说，就是模拟出的CPU核心数。比如，可以通过一个CPU核心数模拟出2线程的CPU，也就是说，这个单核心的CPU被模拟成了一个类似双核心CPU的功能。我们从任务管理器的性能标签页中看到的是两个CPU。 比如Intel 赛扬G460是单核心，双线程的CPU，Intel 酷睿i3 3220是双核心四线程，Intel 酷睿i7 4770K是四核心八线程，Intel 酷睿i5 4570是四核心四线程等等。 对于一个CPU，线程数总是大于或等于核心数的。一个核心最少对应一个线程，但通过超线程技术，一个核心可以对应两个线程，也就是说它可以同时运行两个线程。 CPU的线程数概念仅仅只针对Intel的CPU才有用，因为它是通过Intel超线程技术来实现的，最早应用在Pentium4上。如果没有超线程技术，一个CPU核心对应一个线程。所以，对于AMD的CPU来说，只有核心数的概念，没有线程数的概念。 CPU之所以要增加线程数，是源于多任务处理的需要。线程数越多，越有利于同时运行多个程序，因为线程数等同于在某个瞬间CPU能同时并行处理的任务数。 在Windows中，在cmd命令中输入“wmic”，然后在出现的新窗口中输入“cpu get *”即可查看物理CPU数、CPU核心数、线程数。其中， Name:表示物理CPU数 NumberOfCores：表示CPU核心数 NumberOfLogicalProcessors：表示CPU线程数

操作系统--进程和线程实验报告

一.进程的创建 1．编辑源程序。 2. 编辑结果如下。 3.编译和运行程序。 4.运行解释结果 在语句p1=fork()之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了.这两个进程的几乎完全相同，将要执行的下一条语句都是if(p1==0). 而fork函数有三种返回值。（1）在父进程中，fork返回新创建子进程的进程ID； （2）在子进程中，fork返回0； （3）如果出现错误，fork返回一个负值； 所以，子进程中p1==0，输出I am child。父进程p1>0,输出I am parent。

1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 在语句p1=fork()之前，只有父进程执行，putchar(‘x’)语句将x放入父进程的缓冲区。当成功创建子进程后，子进程复制父进程的缓冲区。接着子进程运行输出xby，父进程输出xay。

1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 在语句p1=fork()之前，只有父进程执行，putchar(‘x’)语句将x放入父进程的缓冲区。当成功创建子进程后，子进程复制父进程的缓冲区。接着子进程输出b后，执行exit(0)系统调用终止执行。父进程输出a 后继续输出y。所以父进程输出xay而子进程输出xb。

1.编辑源程序。 2.编辑结果如下。 3.编译和运行程序。 4. 运行解释结果 语句while(p1=fork()==-1)创建了子进程和父进程。父进程执行到wait()时，等待子进程的终止信号，当子进程执行完exit(0)后，父进程才继续执行。实现了父进程等待子进程。

任务、进程和线程的区别

任务、进程和线程的区别 推荐 摘： 任务（task）是最抽象的,是一个一般性的术语,指由软件完成的一个活动。一个任务既可以是一个进程,也可以是一个线程。简而言之,它指的是一系列共同达到某一目的的操作。例如,读取数据并将数据放入内存中。这个任务可以作为一个进程来实现,也可以作为一个线程（或作为一个中断任务）来实现。 进程（process）常常被定义为程序的执行。可以把一个进程看成是一个独立的程序,在内存中有其完备的数据空间和代码空间。一个进程所拥有的数据和变量只属于它自己。 线程（thread）则是某一进程中一路单独运行的程序。也就是说,线程存在于进程之中。一个进程由一个或多个线程构成,各线程共享相同的代码和全局数据,但各有其自己的堆栈。由于堆栈是每个线程一个,所以局部变量对每一线程来说是私有的。由于所有线程共享同样的代码和全局数据,它们比进程更紧密,比单独的进程间更趋向于相互作用,线程间的相互作用更容易些,因为它们本身就有某些供通信用的共享内存：进程的全局数据。 一个进程和一个线程最显著的区别是：线程有自己的全局数据。线程存在于进程中,因此一个进程的全局变量由所有的线程共享。由于线程共享同样的系统区域,操作系统分配给一个进程的资源对该进程的所有线程都是可用的,正如全局数据可供所有线程使用一样。 简而言之,一个程序至少有一个进程,一个进程至少有一个线程。线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。从逻辑角度来看，多线程的意义在于一个应用程序中，由多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配，这就是进程和线程的重要区别。 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。 进程概念

进程和线程的CPU亲和性

进程和线程的亲缘性（affinity）是指可以将进程或者是线程强制限制在可用的CPU子集上运行的特性，它一定程度上把进程/线程在多处理器系统上的调度策略暴露给系统程序员。 CPU的数量和表示在有n个CPU的Linux上，CPU是用0...n-1来进行一一标识的。CPU的数量可以通过proc文件系统下的CPU相关文件得到，如cpuinfo和stat： $ cat /proc/stat | grep "^cpu[0-9]\+" | wc -l 8 $ cat /proc/cpuinfo | grep "^processor" | wc -l 8 在系统编程中，可以直接调用库调用sysconf获得： sysconf(_SC_NPROCESSORS_ONLN); 进程的亲缘性Linux操作系统在2.5.8引入了调度亲缘性相关的系统调用： int sched_setaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask); int sched_getaffinity(pid_t pid, unsigned int cpusetsize, cpu_set_t *mask); 其中sched_setaffinity是设定进程号为pid的进程调度亲缘性为mask，也就是说它只能在mask中指定的CPU 之间进行调度执行;sched_getaffinity当然就是得到进程号为pid的进程调度亲缘性了。如果pid为0，则操纵当前进程。 第二个参数指定mask所指空间的大小，通常为sizeof(cpu_set_t)。 第三个参数mask的类型为cpu_set_t，即CPU集合，GNU的c库（需要在include头文件之前定义 __USE_GNU）还提供了操作它们的宏： void CPU_CLR(int cpu, cpu_set_t *set); int CPU_ISSET(int cpu, cpu_set_t *set); void CPU_SET(int cpu, cpu_set_t *set); void CPU_ZERO(cpu_set_t *set); 如果我们所关心的只是CPU#0和CPU#1，想确保我们的进程只会运作在CPU#0之上，而不会运作在CPU#1之上。下面程序代码可以完成此事： cpu_set_t set; int ret, i; CPU_ZERO(&set); CPU_SET(0, &set); CPU_CLR(1, &set); ret = sched_setaffinity(0, sizeof(cpu_set_t), &set); if( ret == -1) { perror("sched_se"); } for( i=0; i < 3; i++) { int cpu; cpu = CPU_ISSET(i, &set); printf("cpu = %i is %s/n", i, cpu? "set" : "unset"); } Linux只提供了面向线程的调度亲缘性一种接口，这也是上面只提调度亲缘性而不直言进程亲缘性的原因。当前Linux系统下广泛采用的线程库NPTL（Native Posix Thread Library）是基于线程组来实现的，同一个线程组中的线程对应于一组共享存储空间的轻量级进程，它们各自作为单独调度单位被内核的调度器在系统范围内调度，这种模型也就是我们通常所说的1-1线程模型。正因如此，目前线程的调度范围

Linux操作系统基本概念知识

Linux操作系统基本概念知识 linux的操作系统是相对于window的一个操作系统，目前很多人在使用并且开始学习，那么入门级我们需要先了解什么呢。下面由小编为大家整理了linux操作系统常见的相关知识，希望对大家有帮助! linux操作系统概念 Linux是一套免费使用和自由传播的类Unix操作系统，是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU 的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统。 Linux操作系统诞生于1991 年10 月5 日(这是第一次正式向外公布时间)。Linux存在着许多不同的Linux版本，但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中，比如手机、平板电脑、路由器、视频游戏控制台、台式计算机、大型机和超级计算机。严格来讲，Linux这个词本身只表示Linux内核，但实际上人们已经习惯了用Linux来形容整个基于Linux内核，并且使用GNU

工程各种工具和数据库的操作系统。 linux操作系统下载 经常有新接触Linux的同学问，“Linux操作系统从哪里下载啊?”这种问题，对于熟手来说要么不屑一提，要么就引来了各种Linux 发行版之争，让初学者无所适从。其实，对于新接触Linux 操作系统的人来说，很多人都不知道“Linux”原来不是一个!而是有林林总总上千种发行版，甚至你乐意的话，都可以制作发行自己的发行版。而各种不同的发行版也各有特色，还层出不穷的推出新版本。这简直让初学者如置身森林，茫然不知所措~ 所以，这里我整理了一份最新、最热的Linux 发行版的下载链接，可以让初学者能够快速领略到Linux 的风采。言归正传，您可以从下面挑个顺眼的下载安装试试了，建议你各种都体验下，最后你会选定一个适合你的! 相关阅读：操作系统常见故障核心知识 1、进程与线程 1 进程与线程的概念

进程和线程的选择

鱼还是熊掌：浅谈多进程多线程的选择 关于多进程和多线程，教科书上最经典的一句话是“进程是资源分配的最小单位，线程是CPU调度的最小单位”，这句话应付考试基本上够了，但如果在工作中遇到类似的选择问题，那就没有这么简单了，选的不好，会让你深受其害。 经常在网络上看到有的XDJM问“多进程好还是多线程好？”、“Linux下用多进程还是多线程？”等等期望一劳永逸的问题，我只能说：没有最好，只有更好。根据实际情况来判断，哪个更加合适就是哪个好。 我们按照多个不同的维度，来看看多线程和多进程的对比（注：因为是感性的比较，因此都是相对的，不是说一个好得不得了，另外一个差的无法忍受） 看起来比较简单，优势对比上是“线程 3.5 v 2.5 进程”，我们只管选线程就是了？ 呵呵，有这么简单我就不用在这里浪费口舌了，还是那句话，没有绝对的好与坏，只有哪个更加合适的问题。我们来看实际应用中究竟如何判断更加合适。 1）需要频繁创建销毁的优先用线程 原因请看上面的对比。 这种原则最常见的应用就是Web服务器了，来一个连接建立一个线程，断了就销毁线程，要是用进程，创建和销毁的代价是很难承受的

2）需要进行大量计算的优先使用线程 所谓大量计算，当然就是要耗费很多CPU，切换频繁了，这种情况下线程是最合适的。 这种原则最常见的是图像处理、算法处理。 3）强相关的处理用线程，弱相关的处理用进程 什么叫强相关、弱相关？理论上很难定义，给个简单的例子就明白了。 一般的Server需要完成如下任务：消息收发、消息处理。“消息收发”和“消息处理”就是弱相关的任务，而“消息处理”里面可能又分为“消息解码”、“业务处理”，这两个任务相对来说相关性就要强多了。因此“消息收发”和“消息处理”可以分进程设计，“消息解码”、“业务处理”可以分线程设计。 当然这种划分方式不是一成不变的，也可以根据实际情况进行调整。 4）可能要扩展到多机分布的用进程，多核分布的用线程 原因请看上面对比。 5）都满足需求的情况下，用你最熟悉、最拿手的方式 至于“数据共享、同步”、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，我只能说：没有明确的选择方法。但我可以告诉你一个选择原则：如果多进程和多线程都能够满足要求，那么选择你最熟悉、最拿手的那个。 需要提醒的是：虽然我给了这么多的选择原则，但实际应用中基本上都是“进程+线程”的结合方式，千万不要真的陷入一种非此即彼的误区。

一分钟看懂CPU多发射超标量、多线程、多核之概念和区别

【闲来无事、做做科普、反正也算是marketing job；教你一分钟看懂CPU多发射超标量/多线程/多核之概念和区别】最近在多个场合大肆宣扬多核多线程，收到对多线程表示不解的问题n多，苦思多日，终得一形象生动的模型，你肯定懂的。 因为是比喻和科普、过于严谨的技术控请勿吐槽。 处理器性能提高之公开秘笈：超标量、多线程、多核。 用于说明的生活模型：高速公路及收费站。 简单CPU的原型：单车道马路 + 单收费闸口，车辆只能一辆辆排队通过，并行度为1。 为了提高通行能力同时积极创收，相关部门运用世界顶尖CPU设计理念，对高速公路系统进行了如下拓宽改造： （1）增加车道（图示为3条车道）； （2）增加收费通道（图示为2个通道）；

（3）每个收费通道放置多个收费员（图示每条通道有a和b两个收费窗口）。 其中（1）+（3）组合手段就是所谓的超标量结构，该图示为双发射超标量。超标量指有多个车道，双发射是指有a和b两位收费员可以同时发卡，把两辆车送到不同车道上去。 手段（2）就是多线程的模型了，原有车道不变、只增加收费通道，这样多个车流来的时候可以同时发卡放行。 从这个比喻来看多线程显然是个非常直观和有用的办法，但为什么在CPU世界中似乎有点模糊难懂的感觉呢？那是因为CPU的指令流喜欢一个挨一个、一列纵队龟速前进，这样的话单通道多收费员还起点作用、多通道就形同虚设了。收费员1.a和1.b会累死，而2.a和2.b则能够睡觉。因此把车流进行整队就很重要——这就是并行编程，即要设法把一列纵队排列成多列纵队。 至于多核的概念，那就简单粗暴很多了，直接在这条马路边上进行征地拆迁、新修一条一模一样的高速公路便是，牛吧。现在大家手机里面的多核，就是并排几条“单收费通道+多车道”的马路，车流稀少、路况不错，不过相关部门表示因为道路利用率底下、经济效益欠佳、回收投资压力巨大。 无论多核还是多线程，都有一个同样的问题需要解决，就是要把车流整成多列纵队，这样多条马路和多个收费通道的并行度才能发挥作用。

JAVA多线程(一)基本概念和上下文切换性能损耗

JAVA多线程（一）基本概念和上下文切换性能损耗 1 多线程概念 在理解多线程之前，我们先搞清楚什么是线程。根据维基百科的描述，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是行程中的实际运行单位。一条线程指的是进程中一个单一顺序的控制流，一個进程中可以并行多个线程，每条线程并行执行不同的任务。每个线程共享堆空间，拥有自己独立的栈空间。 这里反复出现的概念是线程和进程，我们在这里列出它们的区别： 线程划分尺度小于进程，线程隶属于某个进程； 进程是CPU、内存等资源占用的基本单位，线程是不能独立占有这些资源的； 进程之间相互独立，通信比较困难，而线程之间共享一块内存区域，通信方便； 进程在执行过程中，包含比较固定的入口、执行顺序和出口，而进程的这些过程会被应用程序控制。 多线程是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时

间执行多个线程，进而提升整体处理效能。 2 为什么要使用多线程 随着计算机硬件的发展，多核CPU已经屡见不鲜了，甚至手机处理器都早已是多核的天下。这就给我们使用多线程提供了硬件基础，但是，只是因为硬件让我们可以实现多线程，就要这样做吗？一起来看看多线程的优点： 更高的运行效率。在多核CPU上，线程之间是互相独立的，不用互相等待，也就是所谓的“并行“。举个例子，一个使用多线程的文件系统可以实现高吞吐量和低延迟。这是因为我们可以用一个线程来检索存储在高速介质（例如高速缓冲存储器）中的数据，另一个线程检索低速介质（例如外部存储）中的数据，二者互不干扰，也不用等到另一个线程结束才执行； 多线程是模块化的编程模型。在单线程中，如果主执行线程在一个耗时较长的任务上卡住，或者因为网络响应问题陷入长时间等待，此时程序不会响应鼠标和键盘等操作。多线程通过将程序分成几个功能相对独立的模块，单独分配一个线程去执行这个长耗时任务，不影响其它线程的执行，就可以避免这个问题； 与进程相比，线程的创建和切换开销更小。使用多线程为多个客户端服务，比使用多进程消耗的资源少得多。由于启动

进程线程的概念

提起程序这个概念，大家再也熟悉不过了，程序与进程概念是不可分的。程序是为了完成某项任务编排的语句序列，它告诉计算机如何执行，因此程序是需要运行的。程序运行过程中需要占有计算机的各种资源才能运行下去。如果任一时刻，系统中只有一道程序，即单道程序系统，程序则在整个运行过程中独占计算机全部资源，整个程序运行的过程就非常简单了，管理起来也非常容易。就象整个一套房子住了一个人，他想看电视就看电视，想去卫生间就去卫生间，没人和他抢占资源。但为了提高资源利用率和系统处理能力，现代计算机系统都是多道程序系统，即多道程序并发执行。程序的并发执行带来了一些新的问题，如资源的共享与竞争，它会改变程序的执行速度。就象多个人同时住一套房子，当你想去卫生间的时候，如果此时卫生间里有人，你就得等待，影响了你的生活节奏。如果程序执行速度不当，就会导致程序的执行结果失去封闭性和可再现性，这是我们不希望看到的。因此应该采取措施来制约、控制各并发程序段的执行速度。由于程序是静态的，我们看到的程序是存储在存储介质上的，它无法反映出程序执行过程中的动态特性，而且程序在执行过程中是不断申请资源，程序作为共享资源的基本单位是不合适的，所以需要引入一个概念，它能描述程序的执行过程而且可以作为共享资源的基本单位，这个概念就是进程。 进程的生命周期 进程和人一样是有生命的，从诞生到死亡要经历若干个阶段。一般说来进程有三种状态：就绪、执行、等待。由多种原因可以导致创建一个进程，例如一个程序从外存调入内存开始执行，操作系统就要为其创建进程，当然还可以有其它原因，如一个应用进程为完成一个特殊的任务，可以自己创建一个子进程。进程被创建后就是在内存中，处于就绪状态，所谓就绪状态就是具备除了CPU之外的所有资源，万事具备，只欠东风，一旦占有 了CPU，就变成了执行状态，执行中如果需要等待外围设备输入数据，则进程就沦落为 等待状态，操作系统又会从就绪状态队列中调度一个进程占有CPU。等到数据到来后， 等待状态的进程又被唤醒成为就绪状态。这些状态的转换是通过进程控制原语实现的。程序的运行是通过进程体现的，操作系统对进程进行管理和控制，那么操作系统怎么了解到进程的状态呢，怎么把资源分配给进程呢，而且进程做状态转换时CPU现场保存在那呢？这要说到PCB（进程控制快）。PCB是进程的唯一标志，在其中记录了进程的全部信息，它是一种记录型的数据结构，相当于进程的档案。操作系统就通过PCB感知进程的存在，通过PCB了解进程和控制进程的运行。PCB也是放在内存中的，如果PCB太大，有些系 统把PCB中一些不重要的信息放在外存中。 进程执行速度的制约 并发进程由于共享系统内部资源，因此导致进程执行速度上的制约，这种制约分为：间接制约与直接制约。间接制约引起进程之间的互斥执行，直接制约引起进程间的同步执行。例如一个家里如果只有一个卫生间，卫生间这个公有资源使得每个人只能互斥使用它，这就是间接制约。而直接制约是指并发进程各自执行的结果互为对方的执行条件，例如司机与售票员的关系，当司机到站停车后，售票员才能开门，而只有售票员关门后，司机才

线程、进程、多线程、多进程和多任务之间的区别与联系

线程、进程、多线程、多进程和多任务之间的区别与联系

可能学习操作系统开发的读者都听说过这些专业名词，但又多少人理解了？ 首先，从定义开始，先看一下教科书上进程和线程定义：进程：资源分配的最小单位。线程：程序执行的最小单位。 1 进程进程是程序执行时的一个实例，即它是程序已经执行到课中程度的数据结构的汇集。从内核的观点看，进程的目的就是担当分配系统资源（CPU时间、内存等）的基本单位。 举例说明进程：想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕，他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(CPU)，而做蛋糕的各种原料就是输入数据。 进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机制是从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学

家又回来做蛋糕，从他离开时的那一步继续做下去。 2 线程线程是CPU调度的最小单位(程序执行流的最小单元)，它被包含在进程之中，是进程中的实际运作单元。一条线程是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 一个标准的线程有线程ID、当前指令指针(PC),寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单元，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现处间断性。 线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件(如某个信号量)，逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。举例说明线程：假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。这种机制就是线程。 总的来说：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

进程和线程的区别

进程和线程的区别 进程和线程的概念 先了解一下操作系统的一些相关概念，大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制暂停去执行下一个任务，被暂停的任务就处于就绪状态等待下一个属于它的时间片的到来。这样每个任务都能得到执行，由于CPU的执行效率非常高，时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，这也就是我们所说的并发(并发简单来说多个任务同时执行)。 进程 计算机的核心是CPU，它承担了所有的计算任务；而操作系统是计算机的管理者，它负责任务的调度、资源的分配和管理，统领整个计算机硬件；应用程序侧是具有某种功能的程序，程序是运行于操作系统之上的。 进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。 进程具有的特征： 动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的； 并发性：任何进程都可以同其他进程一起并发执行； 独立性：进程是系统进行资源分配和调度的一个独立单位； 结构性：进程由程序、数据和进程控制块三部分组成。 进程的生命周期 ? 在早期只有进程的操作系统中，进程有五种状态，创建、就绪、运行、阻塞(等待)、退出。

进程与线程的区别[试题]

进程与线程的区别[试题] 进程与线程的区别: 通俗的解释 一个系统运行着很多进程，可以比喻为一条马路上有很多马车 不同的进程可以理解为不同的马车而同一辆马车可以有很多匹马来拉----这些马就是线程 假设道路的宽度恰好可以通过一辆马车道路可以认为是临界资源 那么马车成为分配资源的最小单位(进程) 而同一个马车被很多匹马驱动(线程)----即最小的运行单位 每辆马车马匹数>=1 所以马匹数=1的时候进程和线程没有严格界限，只存在一个概念上的区分度马匹数>1的时候才可以严格区分进程和线程 专业的解释: 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者《操作系统的设计与实现》。对就个问题说得比较清楚。 +++++++++++++++++++++++++++++++++++++++++++++++ 进程概念 进程是表示资源分配的基本单位，又是调度运行的基本单位。例如，用户运行自己的程序，系统就创建一个进程，并为它分配资源，包括各种表格、内存空间、磁盘空间、I,O设备等。然后，把该进程放人进程的就绪队列。进程调度程序选中它，为它分配CPU以及其它有关资源，该进程才真正运行。所以，进程是系统中的并发执行的单位。

进程和线程的管理

2. 进程和线程的管理 例题解析 例2.2.1 试说明进程和程序之间的区别和联系。 解进程和程序是既有区别又有联系的两个概念。 (1)进程是动态的，程序是静态的。程序是一组有序的指令集合，是一个静态的概念；进程则是程序及其数据在计算机上的一次执行，是一个动态的集合。离开了程序，进程就失去了存在的意义，但同一程序在计算机上的每次运行将构成不同的进程。程序可看作是电影的胶片，进程可以看作电影院放电影的过程。 (2)一个进程可以执行多个程序，如同一个电影院的一场电影可放映多部影片。 (3)一个程序可被多个进程执行，如同多个影院同时利用一个电影的胶片放映同一部电影。 (4)程序可以长期保存，进程只能存在于一段时间。程序是永久存在的，而进程有从被创建到消亡的生命周期。 例2.2.2 举例说明多道程序系统失去了封闭性和再现性。 解例如，有两个循环程序A和B，共享一个变量N。程序A每执行一次时，都要做N：=N+1操作；程序B则每执行一次时，都要执行print(N)操作，然后再将N的值置成“0”。程序A和B在多道程序系统中同时运行。假定某时刻变量N的值为n，可能出现下述三种情况： (1)N：=N+1 在print(N)和N：=0之前，此时得到N值变化过程为n+1、n+1、0； (2)N：=N+1 在print(N)和N：=0之后，此时得到N值变化过程为n 、0 、1； (3)N：=N+1 在print(N)之后和N：=0之前，此时得到N值变化过程为n、n+1、0。 所以，在A、B程序多次执行过程中，虽然其每次执行时的环境和初始条件都相同，但每次得到的结果却不一定相同。 例2.2.3 为什么将进程划分成执行、就绪和阻塞三个基本状态？ 解根据多道程序执行的特点，进程的运行是走走停停的。因此进程的初级状态应该是执行和等待状态。处于执行状态的进程占用处理机执行程序，处于等待状态的进程正在等待处理机或者等待其它某种事件的发生。但

Java线程总结

Java线程总结 在论坛上面常常看到初学者对线程的无可奈何，所以总结出了下面一篇文章，希望对一些正在学习使用java线程的初学者有所帮助。 首先要理解线程首先需要了解一些基本的东西，我们现在所使用的大多数操作系统都属于多任务，分时操作系统。正是由于这种操作系统的出现才有了多线程这个概念。我们使用的w indows，linux就属于此列。什么是分时操作系统呢，通俗一点与就是可以同一时间执行多个程序的操作系统，在自己的电脑上面，你是不是一边听歌，一边聊天还一边看网页呢？但实际上，并不上c pu在同时执行这些程序，c pu只是将时间切割为时间片，然后将时间片分配给这些程序，获得时间片的程序开始执行，不等执行完毕，下个程序又获得时间片开始执行，这样多个程序轮流执行一段时间，由于现在c pu 的高速计算能力，给人的感觉就像是多个程序在同时执行一样。 一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间，一组系统资源。在进程概念中，每一个进程的内部数据和状态都是完全独立的。因此可以想像创建并执行一个进程的系统开像是比较大的，所以线程出现了。在java中，程序通过流控制来执行程序流，程序中单个顺序的流控制称为线程，多线程则指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。（你可以将前面一句话的程序换成进程，进程是程序的一次执行过程，是系统运行程序的基本单位） 线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程。或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程也被称为轻负荷进程(light-w eight proc ess)。一个进程中可以包含多个线程。 多任务是指在一个系统中可以同时运行多个程序,即有多个独立运行的任务，每个任务对应一个进程，同进程一样，一个线程也有从创建,运行到消亡的过程，称为线程的生命周期。用线程的状态(state)表明线程处在生命周期的哪个阶段。线程有创建，可运行，运行中，阻塞,死亡五中状态.通过线程的控制与调度可使线程在这几种状态间转化每个程序至少自动拥有一个线程，称为主线程。当程序加载到内存时，启动主线程。 [线程的运行机制以及调度模型] java中多线程就是一个类或一个程序执行或管理多个线程执行任务的能力，每个线程可以独立于其他线程而独立运行，当然也可以和其他线程协同运行，一个类控制着它的所有线程，可以决定哪个线程得到优先级，哪个线程可以访问其他类的资源，哪个线程开始执行，哪个保持休眠状态。 下面是线程的机制图： 线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务.线程有创建，可运行，运行中，阻塞，死亡五中状态。一个具有生命的线程，总是处于这五种状态之一： 1.创建状态 使用new运算符创建一个线程后，该线程仅仅是一个空对象，系统没有分配资源，称该线程处于创建状态(new thread) 2.可运行状态

线程与进程

1.进程与线程区别 从概念上： 进程：一个程序对一个数据集的动态执行过程，是分配资源的基本单位。 线程：一个进程内的基本调度单位。 线程的划分尺度小于进程，一个进程包含一个或者更多的线程。 从执行过程中来看： 进程：拥有独立的内存单元，而多个线程共享内存，从而提高了应用程序的运行效率。 线程：每一个独立的线程，都有一个程序运行的入口、顺序执行序列、和程序的出口。但是线程不能够独立的执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 从逻辑角度来看：（重要区别） 多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但是，操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理及资源分配。 2.我们写的程序，不论是C、C++、java还是其他的，其实都是一种文本，真正 运行、跑动的是进程。 程序可以分为两部分：源代码和可执行的二进制代码（经过汇编或编译）。操作系统加载这个可执行的二进制代码后，还要分配相应的内核数据结构——进程控制块（PCB：process control block），并进行一系列的初始化等过程（如：创建PID、分配时间片等）后才创建了真正可以“跑动”的进程。所以程序相当于是一个项目的计划书（或行动方案），而进程才是对该方案的实施过程。 进程对CPU来说其实就是一串可执行的指令序列，这个执行序列也叫执行线程，它是进程的控制流程。传统的用户进程只有一个执行流程，所以传统的进程都是单线程的。有了线程就是执行流程的概念后，进程模型得到了扩展，因为一个进程中完全可以设置多个执行流程，即多个执行线程。所以一个进程中可以创建多个线程，当然不创建的话，进程本身也可以看成是线程。 创建多个进程的话，每个进程都是独立的（都有自己独立的PCB数据结构，该数据结构比较大，将近1K的信息量，包括唯一的PID、上下文环境、持有的内存地址等等），内核要管理进程间的切换、内存管理等，开销相对比较大。 如果一个进程里创建多个线程的话，开销比进程要小，各线程共享进程的状态和资源，内核为线程创建的数据结构相对比进程的PCB就要小的多，当然额外的开销是CPU需要跟踪线程，同时线程间存在争用资源的问题。如果程序要完成一组相关任务，则用线程比较好。 下面再细讲下进程：