在引入线程的操作系统中，资源分配和调度的基本单位是什么？进程还是线程？为什么？

操作系统中怎样编程实现银行家算法~

#include
#include
#include
#define False 0
#define True 1
int Max[100][100]={0};//各进程所需各类资源的最大需求
int Avaliable[100]={0};//系统可用资源
char name[100]={0};//资源的名称
int Allocation[100][100]={0};//系统已分配资源
int Need[100][100]={0};//还需要资源
int Request[100]={0};//请求资源向量
int temp[100]={0};//存放安全序列
int Work[100]={0};//存放系统可提供资源
int M=100;//作业的最大数为100
int N=100;//资源的最大数为100
void showdata()//显示资源矩阵
{
int i,j;
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<endl;
for (j=0;j<N;j++)
cout<<Avaliable[j]<<" ";//输出分配资源
cout<<endl;
cout<<" Max Allocation Need"<<endl;
cout<<"进程名 ";
for(j=0;j<3;j++){
for(i=0;i<N;i++)
cout<<name[i]<<" ";
cout<<" ";
}
cout<<endl;
for(i=0;i<M;i++){
cout<<" "<<i<<" ";
for(j=0;j<N;j++)
cout<<Max[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Allocation[i][j]<<" ";
cout<<" ";
for(j=0;j<N;j++)
cout<<Need[i][j]<<" ";
cout<<endl;
}
}

int changdata(int i)//进行资源分配
{
int j;
for (j=0;j<M;j++) {
Avaliable[j]=Avaliable[j]-Request[j];
Allocation[i][j]=Allocation[i][j]+Request[j];
Need[i][j]=Need[i][j]-Request[j];
}
return 1;
}
int safe()//安全性算法
{
int i,k=0,m,apply,Finish[100]={0};
int j;
int flag=0;
Work[0]=Avaliable[0];
Work[1]=Avaliable[1];
Work[2]=Avaliable[2];
for(i=0;i<M;i++){
apply=0;
for(j=0;j<N;j++){
if (Finish[i]==False&&Need[i][j]<=Work[j]){
apply++;
if(apply==N){
for(m=0;m<N;m++)
Work[m]=Work[m]+Allocation[i][m];//变分配数
Finish[i]=True;
temp[k]=i;
i=-1;
k++;
flag++;
}
}
}
}
for(i=0;i<M;i++){
if(Finish[i]==False){
cout<<"系统不安全"<<endl;//不成功系统不安全
return -1;
}
}
cout<<"系统是安全的!"<<endl;//如果安全，输出成功
cout<<"分配的序列:";
for(i=0;i<M;i++){//输出运行进程数组
cout<<temp[i];
if(i";
}
cout<<endl;
return 0;
}
void share()//利用银行家算法对申请资源对进行判定
{
char ch;
int i=0,j=0;
ch='y';
cout<<"请输入要求分配的资源进程号(0-"<<M-1<<"):";
cin>>i;//输入须申请的资源号
cout<<"请输入进程 "<<i<<" 申请的资源:"<<endl;
for(j=0;j<N;j++)
{
cout<<name[j]<<":";
cin>>Request[j];//输入需要申请的资源
}
for (j=0;j<N;j++){
if(Request[j]>Need[i][j])//判断申请是否大于需求，若大于则出错
{
cout<<"进程 "<<i<<"申请的资源大于它需要的资源";
cout<<" 分配不合理，不予分配！"<<endl;
ch='n';
break;
}
else {
if(Request[j]>Avaliable[j])//判断申请是否大于当前资源，若大于则
{ //出错
cout<<"进程"<<i<<"申请的资源大于系统现在可利用的资源";
cout<<" 分配出错，不予分配!"<<endl;
ch='n';
break;
}
}
}
if(ch=='y') {
changdata(i);//根据进程需求量变换资源
showdata();//根据进程需求量显示变换后的资源
safe();//根据进程需求量进行银行家算法判断
}
}
void addresources(){//添加资源
int n,flag;
cout<<"请输入需要添加资源种类的数量:";
cin>>n;
flag=N;
N=N+n;
for(int i=0;i<n;i++){
cout<<"名称:";
cin>>name[flag];
cout<<"数量:";
cin>>Avaliable[flag++];
}
showdata();
safe();
}
void delresources(){//删除资源
char ming;
int i,flag=1;
cout<<"请输入需要删除的资源名称：";
do{
cin>>ming;
for(i=0;i<N;i++)
if(ming==name[i]){
flag=0;
break;
}
if(i==N)
cout<<"该资源名称不存在，请重新输入：";
}
while(flag);
for(int j=i;j<N-1;j++)
{
name[j]=name[j+1];
Avaliable[j]=Avaliable[j+1];

}
N=N-1;
showdata();
safe();
}
void changeresources(){//修改资源函数
cout<<"系统目前可用的资源[Avaliable]:"<<endl;
for(int i=0;i<N;i++)
cout<<name[i]<<":"<<Avaliable[i]<<endl;
cout<<"输入系统可用资源[Avaliable]:"<<endl;
cin>>Avaliable[0]>>Avaliable[1]>>Avaliable[2];
cout<<"经修改后的系统可用资源为"<<endl;
for (int k=0;k<N;k++)
cout<<name[k]<<":"<<Avaliable[k]<<endl;
showdata();
safe();
}
void addprocess(){//添加作业
int flag=M;
M=M+1;
cout<<"请输入该作业的最打需求量[Max]"<<endl;
for(int i=0;i<N;i++){
cout<<name[i]<<":";
cin>>Max[flag][i];
Need[flag][i]=Max[flag][i]-Allocation[flag][i];
}
showdata();
safe();
}
int main()//主函数
{

int i,j,number,choice,m,n,flag;
char ming;
cout<<"*****************资源管理系统的设计与实现*****************"<<endl;
cout<<"请首先输入系统可供资源种类的数量:";
cin>>n;
N=n;
for(i=0;i<n;i++)
{
cout<<"资源"<<i+1<<"的名称:";
cin>>ming;
name[i]=ming;
cout<<"资源的数量:";
cin>>number;
Avaliable[i]=number;
}
cout<<endl;
cout<<"请输入作业的数量:";
cin>>m;
M=m;
cout<<"请输入各进程的最大需求量("<<m<<"*"<<n<<"矩阵)[Max]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++)
cin>>Max[i][j];
do{
flag=0;
cout<<"请输入各进程已经申请的资源量("<<m<<"*"<<n<<"矩阵)[Allocation]:"<<endl;
for(i=0;i<m;i++)
for(j=0;j<n;j++){
cin>>Allocation[i][j];
if(Allocation[i][j]>Max[i][j])
flag=1;
Need[i][j]=Max[i][j]-Allocation[i][j];
}
if(flag)
cout<<"申请的资源大于最大需求量，请重新输入!
";
}
while(flag);

showdata();//显示各种资源
safe();//用银行家算法判定系统是否安全
while(choice)
{
cout<<"**************银行家算法演示***************"<<endl;
cout<<" 1:增加资源 "<<endl;
cout<<" 2:删除资源 "<<endl;
cout<<" 3:修改资源 "<<endl;
cout<<" 4:分配资源 "<<endl;
cout<<" 5:增加作业 "<<endl;
cout<<" 0:离开 "<<endl;
cout<<"*******************************************"<<endl;
cout<<"请选择功能号：";
cin>>choice;
switch(choice)
{
case 1: addresources();break;
case 2: delresources();break;
case 3: changeresources();break;
case 4: share();break;
case 5: addprocess();break;
case 0: choice=0;break;
default: cout<<"请正确选择功能号(0-5)!"<<endl;break;
}
}
return 1;
}

#include
main()
{
int p1,p2,p3,a1,a2,a3,b1,b2,b3;
while((p1==fork())==-1);
if(p1==0)
{
a1=getpid();
b1=getppid();
printf("%d,%d",a1,b1);
}
else
{
while((p2=fork())==-1);
if(p2==0)
{
……
}
}

在引入线程的操作系统中，资源分配和调度的基本单位是进程。

进程表示单个运行活动集的计算机程序，是系统的资源分配和调度的基本单元，是操作系统结构的基础。

在早期面向进程的计算机结构中，过程是程序的基本执行实体，在面向线程设计的现代计算机结构中，进程是线程的容器。程序是对指令、数据及其组织形式的描述，流程是程序的实体。

操作系统引入进程的概念的原因：从理论角度看，是对正在运行的程序过程的抽象。从实现角度看，是一种数据结构，目的在于清晰地刻画动态系统的内在规律，有效管理和调度进入计算机系统主存储器运行的程序。

扩展资料：

线程的实体包括程序、数据和TCB。线程是动态概念，它的动态特性由线程控制块TCB（Thread Control Block）描述。TCB包括以下信息：

1、线程状态。

2、当线程不运行时，被保存的现场资源。

3、一组执行堆栈。

4、存放每个线程的局部变量主存区。

5、访问同一个进程中的主存和其它资源。

用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。

参考资料来源：百度百科-进程

进程（Process）是系统进行资源分配和调度的基本单位。

进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位。

在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

所处环境：在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）

扩展资料

一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。

线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

首先答案是：引入线程的操作系统中，资源分配和调度的基本单位是线程。

分析如下     

在20世纪60年代中期，人们设计多道程序OS时，引入了进程的概念，从而解决了单处理机环境下的程序并发执行问题。在在此后的二十年里，在多道程序OS中一直是以进程作为能拥有资源和独立调度（运行）的基本单位的。到了80年代中期，人们又提出了比进程更小的基本单位———线程的概念，试图用它来提高程序的并发执行的速度，以进一步改善系统的服务质量。在20世纪90年代后，多处理机系统得到了迅速发展，由于线程能更好地提高程序的并发执行速度，因而现在的多处理机系统无一例外的都引入了线程。

所以在传统的OS中，进程是独立调度和分配的基本单位，因而进程是能独立运行的基本单位。在每次调度时，都需要上下文切换开销较大。而在引入线程的OS中，已把线程作为调度和分派的基本单位，因而线程是能独立运行的基本单位。当线程切换时，仅需保存和设置少量寄存器内容，切换代价远低于进程。在同一进程中，线程的切换不会引起进程的切换。而在不同进程的线程之间切换时，必然会导致进程的切换。

线程具有进程的许多特征，所以线程又被称为轻型进程（Light-Weight Process)。传统的进程被称为重型进程（Heavy-Weight Process）。

以上为本人纯手打，如果您觉得有用的话，麻烦帮忙点个赞，让更多的人看到。

参考来自于《计算机操作系统》第四版，第二章进程的描述与控制。

高赞答案有误，引入线程以后，线程是调度和分配的基本单位，但不是拥有资源的基本单位（除了在运行过程中必不可少的资源，本身基本不拥有系统资源），进程才是拥有资源的基本单位。

进程。
为了帮助进程的运算与操作，引入了线程。但是资源的分配和调度基本单位仍旧是进程。

---

在引入线程的操作系统中,资源分配和调度的基本单位是什么?进程还是...（线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模...)

在引入线程的操作系统中,资源分配和调度的基本单位是什么（线程与资源仿卜伍分配无关,它属于某一个进程,并与进程内的其他线程一起共享进程的资源。线程只由相关堆栈(系统栈或用户栈)寄存器和线程控制表TCB组成。寄存器可被用来存储线程内的局部变量,但不能存储其他线程的相关变量。调度与操作系统的线程的实现有关,如果是管态线程...)

在引入线程的操作系统中,资源分配和调度的基本单位是什么?进程还是...（线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间,一个进程崩溃后,在保护模...)

在引入线程的操作系统中,资源分配和调度的基本单位是什么?进程还是...（在引入线程的操作系统中,资源分配和调度的基本单位是进程。进程表示单个运行活动集的计算机程序,是系统的资源分配和调度的基本单元,是操作系统结构的基础。在早期面向进程的计算机结构中,过程是程序的基本执行实体,在面向线程设计的现代计算机结构中,进程是线程的容器。程...)

在引入线程的操作系统中,资源分配和调度的基本单位是什么（线程与资源分配无关,它属于某=一=个进程,并与进程内的其他线程一起共享进程的资源。 线程只由相关堆栈( 系统栈 或 用户栈 )寄存器和线程控制表TCB组成。寄存器可被用来存储线程内的 局部变量 ,但不能存储其他线程的相关变量。 调度与操作系统的线程的实现有关,如果是 管态 线...)

在引入线程的操作系统中,资源分配和调度的基本单位是什么?进程还是...（进程(Process)是系统进行资源分配和调度的基本单位。进程是资源分配的基本单位。所有与该进程有关的资源,都被记录在进程控制块PCB中... 而同一进程内的不同线程共享同一地址空间。与进程相对应,线程与资源分配无关,它属于某=一=个进程,并与进程内的其他线程一起共享进程的...)

操作系统中引入线程后,资源分配的基本单位是()。（C)

操作系统 线程（线程是对于,机器硬件的称呼。相当于生产线,酷睿二代处理器一般可以达到2线程的处理能力,现在i3,i5处理器,可以达到处理线程数可以达到4线程,i7处理器可以达到8线程的处理能力。而进程怎是对软件,即程序运行的程序,程序运行的多少叫做进程数。现在我告诉你如何查看进程和线程...)

在操作系统中引入线程的主要目的是（减小程序在并发执行时所付出的时空开销,提高操作系统的并发性能;时空开销比较:进程之间的切换与线程之间的切换(切换进程需要同时切换进程的运行环境,而切换线程时,如若属于同一个进程,则无需切换进程的运行环境)并发性能:进程可以由很多的线程组成;未引入线程之前,并发只能在...)

操作系统 线程与进程（内核代表用户进程调度这些内核线程的执行。在内核中,多个执行的线程共享内核环境,主要是内核地址空间。进程也包含一个或多个线程,它们共享进程的虚拟内存环境以及其他的进程上下文组件。进程是包含用户程序执行环境的抽象。它由虚拟内存环境(地址空间)、程序资源例如打开...)