操作系统课堂笔记第二章进程管理

第二章进程管理

2.1 本章导学

基本内容：

（1）进程的基本概念。
（2）进程控制。
（3）进程间互斥与同步。
（4）进程通信。
（5）进程调度。
（6）进程死锁。
（7）线程。

学习重点：

（1）进程的概念、特点、状态和PCB。
（2）利用原语进行进程控制。
（3）进程间并发执行的同步。
（4）利用信号量和P/V操作保证进程的互斥和同步。
（5）经典的同步问题。
（6）进程间通信的基本方法。
（7）进程调度算法。
（8）死锁的基本概念和如何利用银行家算法避免死锁。
（9）线程的基本概念。

2.2 进程的基本概念

2.2.1 进程的并发执行

（1）多道程序同时在不同的CPU上执行，则称之为“并行”。
（2）多道程序分时地运行在同一个CPU上则称之为“并发”。
（3）逻辑上的并行称为“并发”。
（4）程序的并发执行是在多道程序环境下完成的，而在单道程序工作环境中，程序是顺序执行的。
（5）程序的这两种不同的执行方式，体现出不同的特征。

程序的顺序执行及其特征

一个具有独立功能的程序独占CPU运行，直至得到最终结果的过程称为程序的顺序执行。

程序的顺序执行具有如下特点：

（1）顺序性。
（2）独占资源。
（3）结果无关性。

上述特点概括起来就是程序的顺序性、封闭性和可再现性。

程序的并发执行及其特性

第一个程序运行print操作时，第二个程序同时运行input操作。

程序的并发执行还能保持顺序执行时的特性吗？

观察者和报告者问题：在一条单向行驶的公路上有卡车经过。观察者不断观察并对通过的卡车计数，报告者定时将观察者的计数值打印出来，然后将计数器清零。

观察者：
int n = 0;
void observer(void)
{while(1){n = n + 1;remainder of observer;}
}报告者：
void reporter(void)
{while(true){print(n);n = 0;remainder of reporter;}
}

并发执行：

void main()
{parbegin(observer(), reporter());
}

由于观察者和报告者各自独立地并行工作，就可能出现以下三种执行序列：

（1）n = n + 1; print(n); n = 0;
（2）print(n); n = 0; n = n + 1;
（3）print(n); n = n + 1; n = 0;

由于观察者和报告者的执行速度不同，导致了计算结果的不同，也就是说，程序并发执行已丧失了顺序执行所保持的封闭性和可再现性，而产生了如下新的特征：

（1）间断性。
（2）失去封闭性。
（3）不可再现性。

程序的并发执行所带来的制约关系：

（1）程序和计算机执行程序的活动不再一一对应。
（2）并发程序间存在相互制约关系。程序的制约关系有两种：直接制约和间接制约。

用程序这个静态概念来描述程序的动态执行过程是不合适的

2.2.2 进程的定义

进程的概念：

（1）20世纪60年代中期开始广泛使用“进程”Process这一新概念来描述系统和用户的程序活动。
（2）进程是现代操作系统中的一个最基本也是最重要的概念，掌握这个概念对于理解操作系统实质、分析、设计操作系统都有非常重要的意义。
（3）迄今为止，对这一概念尚无一个非常确切的、令人满意的、同一的定义，不同的人，站在不同的角度，对进程进行了不同的描述。

进程的定义：
进程是可并发执行的程序在一个数据集合上的运行过程，是系统进行资源分配和调度的一个独立单位。

进程的特性：

（1）动态性。
（2）并发性。
（3）结构特性。
（4）独立性。
（5）异步性（不确定性）。

进程和程序的区别
进程：

（1）动态概念；
（2）可并发执行；
（3）进程存在时暂时的，有创建有撤销；
（4）进程是竞争计算机资源的基本单位；
（5）一个进程可以执行一个或几个程序。

程序：

（1）静态概念；
（2）只能串行执行；
（3）程序是永存的；
（4）不是竞争计算机资源的基本单位；
（5）一个程序可对于多个进程即多个进程可执行同一程序。

程序就像是菜谱，进程就像是按照菜谱炒菜的过程。

进程的分类：

（1）系统进程。
（2）用户进程。

2.2.3 进程的状态及转换

进程的三态及其转换

进程的三种基本状态：

（1）就绪状态（ready）。
（2）运行状态（running）。
（3）阻塞状态（blocked）。

进程的各个状态转换

（1）就绪->运行；
（2）运行->阻塞；
（3）阻塞->就绪；
（4）运行->就绪。

具有挂起状态的进程状态转换：
在许多系统中，进程除了具有上述三个基本状态以外，又增加了一些新状态，其中最重要的就是挂起状态，引入挂起状态的主要原因是内存资源不足。另外有终端用户请求，父进程请求，负荷调节需要等情况时，也要用到挂起状态。

2.2.4 进程控制块

用来描述进程的专有数据结构——进程控制块PCB（Process Control Block）。
进程控制块是进程存在的唯一标志。
PCB中包含如下一些信息：

（1）进程标识信息。
（2）位置信息。
（3）状态信息。
（4）进程现场保护区。
（5）资源清单。
（6）队列指针或链接字。
（7）其他信息。

进程控制块的组织方式

目前常用的PCB的组织方式有以下三种：

（1）线性表方式：不论进程的状态如何，将所有的PCB连续地存放在内存的系统区。这种方式适用于系统中进程数目不多的情况。
（2）连接表方式：系统按照进程的状态将进程的PCB链接成队列，从而形成就绪队列、阻塞队列、运行队列等。
（3）索引表方式：系统按照进程的状态分别尽力就绪索引表、阻塞索引表等。通过索引表来管理系统中的进程。

2.3 进程控制

进程控制的概念

进程是由创建而产生、由调度而执行，由撤销而消亡的生命周期，因此操作系统要有对进程生命周期的各个环节进行控制的功能，这就是进程控制。

进程控制的职能是对系统中的全部进程实行有效的管理，其主要是对一个进程进行创建、撤销以及在某些进程状态间的转换控制。

通常允许一个进程创建和控制另一个进程，前者称为父进程，后者称为子进程，子进程又可创建其子进程，从而形成了一个树形结构的进程家族。

原语的概念

（1）进程的控制通常由原语完成；
（2）原语是指由若干条指令所组成，用来实现某个特定功能，在执行过程中不可被中断的程序段。
（3）原语是操作系统核心的一个组成部分，并且常驻内存，通常在管态下执行，一旦执行不可被中断（原子性）。

进程的创建

（1）首先，申请PCB空间。
（2）其次，为新进程分配资源。
（3）然后，把有关信息填入PCB中。
（4）最后，将PCB插入到就绪队列中。

进程撤销

（1）首先，根据要撤销进程的名字，查找对应的PCB。
（2）其次，从PCB链中撤销该进程及其所有的子孙进程。
（3）然后，检查此进程是否有等待读取的信息，有则释放所有的缓冲区。
（4）最后，释放该进程的工作空间和PCB空间，以及其他资源。

进程阻塞

（1）首先，中断CPU，停止进程运行，将CPU的现行状态存放在PCB中；
（2）然后，将该进程置阻塞状态，并将其插入到阻塞队列中。
（3）最后，系统执行调用程序，将CPU分配给另一个就绪的进程。

进程唤醒

（1）首先，找到被唤醒进程的内部标识。
（2）然后，让该进程脱离阻塞队列，改变为就绪状态。
（3）最后，插入就绪队列等待调度运行。

2.4.1进程间同步与互斥

进程间互斥与同步的概念

并发执行的多个进程之间很容易产生制约关系，因直接制约而需要相互等待、相互合作，以达到各进程按相互协调的速度执行的过程称为进程间的同步。

因间接制约而导致交替执行的过程称为进程间的互斥。

临界资源和临界区

把某段时间内只能允许一个进程使用的资源称为临界资源。
把访问临界资源的代码段称为临界区。

临界资源的使用过程

（1）进入区：判断临界资源是否可用，不可用等待，可用上锁。
（2）临界区：使用临界资源。
（3）退出区：释放临界资源，解锁临界区，以便其他进程进入。

同步机制应遵循的原则

（1）空闲让进：临界资源只要是空闲，就让申请资源的进程立即进入临界区，以便有效利用临界资源。——不浪费。
（2）忙则等待：当已有进程进入临界区时，其他试图进入临界区的进程必须等待，以保证互斥访问。——不争抢。
（3）有限等待：应保证要访问临界资源的进程在有限时间内进入临界区，以免陷入“死锁”状态。——不死等。
（4）让权等待：当进程不能进入自己的临界区时，应立即释放处理机，以免进程陷入“忙等”。——不忙等。

2.4.2 信号量与PV操作

信号量与P/V操作的含义

信号量：表示某类临界资源的可用数目，一般记作S（Semaphore）。

P/V操作：由P操作原语和V操作原语组成，其意义是在一个信号量的S上定义了两个操作，该变量的值只能由P操作和V操作进行修改。并且这两个操作均属于原子操作，不可被中断。

申请资源：
P(S)
{S--;if(S < 0)block();
}
释放资源
V(S)
{S++;
If(S<=0)
wakeup();
}

P/V操作的形式

信号量和P/V操作是实现进程互斥与同步的非常有效的方法。

用信号量和P/V操作实现进程互斥与同步的代码结构为：

P（S）;
临界区;
V（S）;

利用P/V操作实现进程间同步和互斥问题
同步：P1进程 -> 缓冲区B -> P2进程
P2取走数据P1才可输入新数据，P1未输入数据，P2应等待。
互斥：两个进程都进行P->V操作。

利用P/V操作解决同步问题代码

设S1和S2为信号量，S1表示是否可以向缓冲区输入数据，S2表示可从缓冲区中取数据，用1表示true，用0表示false，S1的初值为1，S2的初值为0，代码：

输入进程P1：
P（S1）；
读信息到缓冲区B；
V（S2）；
输出进程P2：
P（S2）；
把缓冲区B中的信息输出；
V（S1）；

信号量和P/V操作的属性

（1）用信号量可以实现进程之间的同步；
（2）用P原语申请资源时，可能引起调用进程的等待，而用V原语释放资源时，则可能启动某一等待进程。
（3）P/V操作在整个系统中是一一对应的，这种不可分性保证了信号量的完整性。
（4）在同一时刻只允许一个进程执行P或V操作。

2.4.3 生产者与消费者问题

问题描述

（1）荷兰计算机科学家Dijkstra把广义同步问题抽象成一种“生产者与消费者问题”的模型。
（2）生产者和消费者可以通过一个环形缓冲池联系起来，环形缓冲池由几个大小相等的缓冲区组成，每个缓冲区容纳一个产品。
（3）每个生产者可不断的每次往缓冲区种送入一个生产的产品，而每个消费者可不断地每次从缓冲池中取出一个产品。
（4）指针i和指针j分别指出当前的第一个空缓冲区的和第一个满缓冲区。

问题分析

同步关系——直接制约：
当生产者速度大于消费者时，一段时间i追上j，则生产者必须阻塞，等待消费者消费后才能继续生产产品。
当消费者速度大于生产者时，一段时间j追上i，则消费者必须阻塞，等待生产者生产产品放入缓冲区才能继续消费。

互斥关系——间接制约：
无论生产者或者消费者只要在缓冲池中操作，必须与其他人互斥，否则容易出错。

问题解决

（1）设公用信号量mutex初值为1，用于实现临界区互斥；
（2）生产者私用信号量empty：初值为n，指示空缓冲区的数目；
（3）消费者私用信号量full：初值为0，指示满缓冲区数目；
（4）整型量i和j：初值均为0，i指示空缓冲区序号头指针，j指示满缓冲区序号头指针。

代码实现

semaphore mutex = 1, empty = 1, full = 0;
int i = j = 0;
item buffer[n];//生产者进程
void producer()
{while(1){produce next product;P(empty);P(mutex);buffer[i] = product;i = (i + 1) % n;V(mutex);V(full);}
}
//消费者进程
void consumer()
{while(1){P(full);P(mutex);product = buffer[j];j = (j + 1) % n;V(mutex);V(empty);consumer the product;}
}
void main()
{parbedin(product(), consumer());
}

2.4.4 读者写者问题

问题描述
一个数据对象被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，把它们称为**“读者”；而另一些进程则要求修改它，称为“写者”**。

问题分析

（1）显然，多个读者可以同时访问共享数据对象。
（2）但是一个写者和任何一个其他的读者或其他写者则不能同时访问这个数据对象，否则就有可能导致不确定的访问结果。
（3）解决问题的基本思想是：任一写者必须与其他写者或读者互斥访问可共享的数据对象，而若干读者可同时访问共享的数据对象。

信号量的设置

（1）对于读者和写者来说，共享数据对象就是一个临界资源，因此，设定一个信号量wsem来保证他们之间的互斥。
（2）对于多个读者来说，必须设置一个计数器readcount来记录进入临界资源读者的个数。
（3）多个读者无论进入还是退出共享数据对象，都要对技术去进行操作，且不能同时进行。因此，需要设定另一个信号量mutex来保证对于计数器访问的互斥。

读者与写者问题的算法实现

//读者进程
int readcount = 0;
semaphore mutex = 1, wsem = 1;
void reader()
{while(1){P(mutex);readcount++;if(readcount == 1)P(wsem);V(mutex);READ;P(mutex);readcount--;if(readcount == 0)V(wsem);V(mutex);}
}
//写者进程
void writer()
{while(1){P(wsem);WRITE;V(wsem);}
}
void main()
{parbegin(reader(), writer());
}

2.4.5 哲学家就餐问题

问题描述
有五个哲学家坐在一圆桌旁，每人面前有一盘面条，每两人之间放一个叉子。每个哲学家的行为是思考，感到饥饿，然后吃面条。为了吃面条，每个哲学家必须拿到两只叉子，并且每个人只能直接从自己的左边和右边去取叉子。

问题分析
恰好5个哲学家均拿起了每个人左边的叉子，这样5个哲学家都争不到右边的叉子，都不能吃饭，发生僵死状态——死锁。

解法一：最多允许4个哲学家同时坐在桌子周围，仅当一个哲学家左右的叉子都可用时，才允许他拿叉子。
代码：

semaphore fork[5] = {1,1,1,1,1};
semaphore room = 4;
int i;
void philosopher(int i)
{while(1){think();P(room);P(fork[i]);P(fork[(i+1)%5]);eat;V(fork[(i+1)%5]);V(fork[i]);V(room);}
}
void main()
{for(int i=0;i<5;i++)parbegin(philosopher);
}

解法二：给所有哲学家编号，奇数号的哲学家必须首先拿左边的叉子，偶数号哲学家反之。

2.5.1 共享存储区的通信

进程通信的概念

（1）进程间的信息交换就是进程通信。
（2）同步与互斥也是进程通信，但交换信息量少，看作低级通信。
（3）并发执行的进程间有交换信息的各种需要，引入高级通信。

共享存储：是指进程间为了传送大量数据，在存储区中画出一块共享存储区，多个进程可通过对共享存储区进行读写数据实现通信。

实现过程：

（1）向系统申请共享存储区中的一个分区；
（2）指定该分区的关键字；
（3）如果已经给其他进程分配了这样的存储区，将该分区的描述符返回给申请者；
（4）申请者将申请到的共享分区挂到本进程上。

2.5.2 消息通信

消息传递：两个并发进程可用通过相互发送消息进行通信，消息是通过消息缓冲区在进程之间相互传递的。

所谓消息是指进程间以不连续的成组方式发送的信息，而消息缓冲区则包含指向发送进程的指针、指向消息接收进程的指针、指向下一个消息缓冲区的指针、消息长度、消息内容。

消息缓冲区构成了进程通信的一个基本单位。

发送消息原语send(B, a)

（1）调用“寻找目标进程的PCB”的程序，查找接受进程的PCB，如果接受进程存在，申请一个存放消息的缓冲区；
（2）把消息的内容、调用发送原语的进程名和消息等，复制到预先申请的存放消息的缓冲区。
（3）将存放消息的缓冲区连接到接收进程的消息队列上。
（4）如果接受进程不存在，则系统给出一个反馈信息，最后控制返回到发送消息的进程继续执行，或转入进程调度程序重新分配CPU。
（5）如果信息缓冲区已满，则返回到非同步错误处理重新入口，进行特殊处理。

代码实现：

void send(B, a)
{getbuf(a,size,i);i.sender = a.sender;i.size = a.size;i.text = a.text;i.next = 0;gettid(PCB.B, j);P(j.mutex);insert(j.mq, i);V(j.mutex);V(j.sm);
}

接收原语receive(b)

（1）接受进程读取消息之前，在自己的进程空间中确定一个接受区。
（2）当接受进程想要读取消息时，调用receive(b)原语，b时接受进程提供的接受区起始地址。
（3）receive(b)原语把消息缓冲区中的消息内容、消息长度以及发送进程的名字都读取到接受区。
（4）把消息缓冲区从链表中去掉，并释放消息缓冲区。（5）如果没有消息可以读取，则阻塞消息进程，直至有消息发来为之。

代码实现：

void receice(b)
{P(j.sm);P(j.mutex);remove(j.mq, i);V(j.mutex);b.sender=i.sender;b.size=i.size;b.text=i.text;putbuf(i);
}

2.5.3管道

共享文件（管道）

（1）共享文件通信机制，通常也叫管道通信机制。
（2）管道是连接读写进程的一个特殊文件，允许进程按先进先出方式传送数据，也能使进程同步执行操作。
（3）发送进程以字符流形式把大量数据送入管道，接受进程从管道中接受数据，所以叫管道通信。
（4）管道的实质是一个共享文件，基本上可借助于文件系统的机制实现，包括文件的创建、打开、关闭和读写。

管道通信示意图

写进程->共享文件->读进程

2.6.1 进程调度算法

进程调度的基本概念：

（1）多进程并发执行，它们必然竞争CPU。
（2）进程调度就是按一定策略、动态地把CPU分配给处于就绪队列中的某一进程，并使之执行；
（3）进程调度也称为处理器调度或低级调度，相应的进程调度程序可称为分配程序或调度程序；
（4）两种基本的进程调度方式，即抢占式和非抢占式。

引起进程调度的原因：

（1）正在运行的进程运行完毕；
（2）运行中的进程要求I/O操作；
（3）执行某种原语操作导致进程阻塞；
（4）一个比正在运行进程优先级更高的进程申请运行；
（5）分配给运行进程的时间片已经用完等等。

选择调度方式和调度算法的若干准则

面向对象的准则：

（1）周转时间短；（2）响应速度快；（3）截止时间的保证；（4）优先权准则。

面向系统的准则：

（1）系统吞吐量高；（2）处理机利用率好；（3）各类资源的均衡利用。

进程调度算法

（1）先来先服务FCFS（First Come First Service）。
（2）时间片轮转调度：时间片的长短很重要。
（3）短进程优先法：照顾短小进程。
（4）高响应比优先法：响应比=等待时间/要求服务时间；既照顾了短进程，也照顾了先来者。
（5）优先级法：静态/动态优先级；抢占/非抢占方式。

2.6.2 进程调度实例

解决进程调度的相关问题步骤：

（1）进程运行时序图。先来先服务，短进程优先，时间片轮转，不可抢占式优先级法，可抢占式优先级法的时序图都先画出来。
（2）计算每一个算法的周转时间和带权周转时间。

周转时间和带权周转时间

周转时间：结束时间-到达时间。等待时间+CPU执行时间。
带权周转时间：周转时间/CPU服务时间

多级反馈队列调度算法：

实现原理：

（1）设有N各队列，其中各个队列优先级不同，前面队列的优先级比后面队列的优先级高。
（2）每一个队列中采用时间片轮转法，各个队列的时间片不一样，随着优先级的减少而成倍增加。

多级反馈队列调度算法性能：

（1）对交互性进程，由于通常较短，这些在第一队列规定的时间片内完成，可使用户感到满意；
（2）对短进程，开始时在第一队列中执行一个时间片就可完成，便可与交互型进程一样获得快速响应，否则通常也仅需在第二、第三队列中各执行一个时间片即可完成，其周转时间仍较短。
（3）对长进程，它们依次在第一至第N各队列中执行，最后按轮转方式运行，不必担心其长时间得不到处理。
（4）多级反馈队列算法可以使高优先级的进程得到及时响应，又能把短进程迅速完成，并且长进程也有机会得到执行，性能较高，但系统资源开销较大。

2.7.1死锁的基本概念

死锁是多个进程竞争而产生的一种僵持局面，这种僵持必须通过外力才能解除。

造成死锁的原因：

（1）系统提供资源不足；（2）并发进程推进顺序不合法。

产生死锁的必要条件：

（1）互斥；（2）不剥夺；（3）请求且保持；（4）环路等待。

死锁的预防：只要使四个必要条件中至少有一个不能成立，就可以达到预防死锁。

死锁的避免：

（1）在动态分配资源的过程中采用某种方法防止系统进入不安全状态，称为死锁避免。
（2）避免死锁的著名算法使Dijkstra 1965年提出来的银行家算法，由于此算法类似于银行系统现金贷款的发放，故称银行家算法。

2.7.2 银行家算法

为保证资金的安全，银行家规定：

（1）当一个顾客对资金的最大需求量不超过银行家现有的资金时就可以接纳该顾客；
（2）顾客可以分期贷款，但贷款的总数不能超过最大需求量；
（3）当银行家现有的资金不能满足顾客尚需的贷款数额时，对顾客的贷款可推迟支付，但总能使顾客在有限的时间里得到贷款；
（4）当顾客得到所需的全部资金后，一定能在有限的时间里归还所有的资金。

银行家算法：

（1）当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。
（2）当进程在执行中继续申请资源时，先测试该进程本次申请的资源数使否超过了该资源所剩余的总量。若超过则拒绝分配资源，若能满足则按当前的申请量分配资源，否则也要推迟分配。
（3）假设分配给某个进程，并计算此次分配资源的安全性，若分配不会导致系统进入不安全状态，则分配，否则阻塞该进程。

安全性检测算法：将所有所剩下的资源全部分配给未完成的进程，看能否让所有的进程都能执行结束，如果可以就把进程执行的序列叫做一个安全序列，当前的系统的状态就是安全的。

银行家算法所需的数据结构：

（1）Available[m], m表示系统内的资源类别数，例如Available[j]=k, 说明可用于分配的j类资源有k个。
（2）Max[n, m], n表示进程个数，m表示系统内资源类别数。若Max[i, j] = k, 说明进程Pi最多可申请j类资源k个。
（3）Allocation[n, m]， n表示进程个数，m表示系统内资源类别数。如果Allocation[i, j]=k,
说明进程Pi已分配j类资源k个。
（4）Need[n, m], n表示进程个数，m表示系统内资源类别数。如果Need[i, j] = k，说明进程Pi尚缺j类资源k个。
（5）Need[i, j] = Max[i, j] - Allocation[i, j];

算法步骤：

(1)如果Requesti>Needi则出错（请求量超多申报的最大量）否则(2)。
(2)如果Requesti>Available则Pi等待，否则转(3)。
(3)系统对Pi所请求的资源实施试探分配，更改数据结构中的数值：Available-=Requesti,Allocationi+=Requesti,Needi-=Requesti.
(4)执行安全性算法，如果系统是安全的，则承认试分配，否则废除试分配，让进程Pi等待。

安全性检查算法：

令Work和Finish分别是长度为m和n的向量。
（1）初始化 Work=Available，Finish[i] = false。
（2）从进程集合中找满足下列条件的进程Pi（Finish[i]=false）and（Needi<=Work）如果找到转（3），否则转（4）。
（3）释放Pi的全部资源，即Work+=Allocationi，Finish[i]=true，转（2）。
（4）如果Finish[i] = true对所有的i都成立，则返回安全标记，否则返回不安全标记。

2.7.3 利用银行家算法避免死锁

列表，列出每个进程的Max，Allocation，Need，Available，通过安全性检查算法，如果可以找到安全序列（不唯一），就说明这个状态是安全的。

2.7.4 死锁的解除

当发现系统中存在死锁时，就必须设法消除它。解除死锁通常采用以下方法：

（1）资源剥夺法。（2）撤销进程法。（3）进程回退法。

Unix对死锁的处理：大智若愚——鸵鸟算法。

2.8 线程

线程的基本概念：

（1）20世纪60年代人们提出了进程概念后，在OS中一直都是以进程为能拥有资源和独立运行的基本单位的。
（2）直到20世纪80年代中期，人们又提出了比进程更小的能独立运行的基本单位——线程。试图用它来提高系统内程序并发执行的程度，从而进一步提高系统的吞吐量。
（3）进入20世纪90年代后，多处理机系统得到迅速发展，线程能比进程更高地提高程序的并发执行程度，充分地发挥了多处理机的优越性，因而近几年所推出的多处理机OS，都引入了线程，以改善OS 的性能。

线程的引入：

进程“太重”，系统在进程上所花的时空开销大致表现在：
（1）创建进程：系统在创建进程时必须为它分配除CPU以外的所有资源，如内存资源、I/O设备、以及建立相应的PCB。
（2）撤销进程：系统撤销进程时，必须先回收其所占的资源，然后再撤销PCB。
（3）进程切换：进程切换时，由于要保留当前进程的CPU环境和设置新进程的CPU环境，因而需花费不少处理机时间。
（4）OS引入线程，目的是减少程序在并发执行时所付出的时空开销。

总之，由于进程是一个资源拥有者，因而在创建、撤销、切换中，系统必须位置付出较大的时空开销，故系统中的进程数目不宜过多，进程切换的频率也不宜过高，这限制了并发程度的进一步提高。

进程及时资源分配的基本单位，又是调度和分配的基本单位。若能将进程的上述两个属性分开，又操作系统分开处理，即：

（1）对于作为调度和分派的基本单位，不同时作为拥有资源的基本单位，以做到“轻装上阵”；
（2）而对于拥有资源的基本单位，又不对之进行频繁的切换。

在这种思想的指导下，形成了线程的概念。线程只作为调度和分派的基本单位，而不作为资源分配的基本单位。一个进程通常包含多个线程。

进程和线程的比较：

（1）调度性：进程拥有资源，线程基本上不拥有资源，就能轻装前进，显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程切换，但从一个进程的线程切换到另一个进程中的线程时，将会引起进程的切换。
（2）并发性：一个进程中的多个线程之间也可并发执行，使得操作系统具有更好的并发性，从而能更加有效地提高系统资源的利用率和系统的吞吐量。
（3）拥有资源：进程系统中拥有资源的一个基本单位。线程自己不拥有系统资源（也有一点不可少的资源），但它可以访问隶属进程的资源。
（4）系统开销：操作系统创建撤销进程以及切换进程状态时付出的开销明显大于线程。

线程的属性：

（1）轻型实体：线程基本上不拥有系统资源，只是有一点必不可少的、能保证独立调度和分派的资源。
（2）独立调度和分派的基本单位：切换非常迅速和开销小。
（3）可并发执行：一个进程的多个线程甚至全部线程可以并发执行；不同进程的线程也能并发执行。
（4）共享进程资源：同一进程的所有线程，都可共享该进程所拥有的资源。

线程的状态及转换：

（1）线程既然是进程中的一个执行体，是系统进程调度的独立单位，它就是一个动态的过程，因此，也就有生命周期，即由创建产生，由调度而执行，由撤销而灭亡。
（2）在线程的生命周期中，也总是从一种状态变迁到另一种状态。

线程调度：
线程调度与进程调度类似，原则上讲，高优先级的线程比低优先级的线程有更多的运行机会，当低优先级的线程在运行时，被唤醒的或结束I/O等待的高优先级线程立即抢占CPU并开始运行，如果线程具有相同的优先级，则通过轮转来抢占CPU资源。

线程通信：
为使系统中的多线程能有条不紊的运行，在系统中必须提供用于实现线程间同步和通信的机制。为了支持不同频率的交互操作和不同程度的并行性，在多线程OS中通常提供多种同步机制：

（1）互斥锁mutex。（2）条件变量。（3）信号量机制：私有信号量，公有信号量。

线程的实现：

（1）内核级线程：线程管理的全部工作由OS内核来做，内核专门提供了一个KLT应用程序设计接口API供开发者使用，例如Windows 2000/XP。
（2）用户级线程：线程管理的全部工作由应用程序来做，在用户空间内实现，内核是不知道线程的存在的。线程库是线程运行的支撑环境。