计算机操作系统 订阅
《计算机操作系统》是2003年8月武汉大学出版社出版的图书,作者是黄水松、黄干平、曾平、李蓉蓉。 [1] 展开全文
《计算机操作系统》是2003年8月武汉大学出版社出版的图书,作者是黄水松、黄干平、曾平、李蓉蓉。 [1]
信息
作    者
黄水松、黄干平、曾平、李蓉蓉
定    价
35元
类    别
计算机与互联网
书    名
计算机操作系统
出版时间
2003年8月
开    本
16
出版社
武汉大学出版社
ISBN
9787307040076
计算机操作系统内容简介
本教材全面系统地介绍了现代计算机操作系统的基本概念、原理和实现方法。全书共分十二章,第一章讲述了现代操作系统的发展概况;第二章至第十章分别阐述了操作系统的基本原理 、概念和实现方法,包括中断技术,进程和线程的管理、进程的同步和通信,存储器管理,虚似存储器,处理机调度,死锁问题,设备管理和文件系统;第十一章介绍了UNIX操作系统,第十三章介绍Windows2000/XP操作系统,并较详细地分析了这两个系统的基本结构、主要的功能模块及其相互之间的关系。本书吸收了国内外近几 年出版的同类教材的优点,内容丰富,既可以作为计算机和相关专业的教材,也可作为从事计算机工作人员的参考书。 [1] 
收起全文
精华内容
下载资源
问答
  • 计算机操作系统

    千次阅读 2018-06-17 06:28:42
    计算机操作系统  作者:任尚益    ...

                                                  计算机操作系统

                                                                                                 作者:任尚益

     

                                                                                (邮箱:2534294648@qq.com)

     

                                                                                           请勿转载,支持原创

    一、类别

    1.实时操作系统:
    实时操作系统(Real-time Operating System)是指能及时响应外部事件的请求,并以足够快的速度予以处理,其处理结果能在规定的时间内控制、监控生产过程或对处理系统做出快速响应,并控制所有任务协调、一致地运行的一种操作系统。实时系统满足了实时控制和实时信息处理领域的需要,其应用十分广泛。
    2.网络操作系统:
    网络操作系统(Network Operating System)是对计算机网络进行有效管理的操作系统,它能有效地管理计算机网络的资源,并为网络用户提供相互通信、资源共享、系统安全等方便、灵活的网络使用环境。
    3.分布式操作系统:
    分布式操作系统(Distributed Operating System)就是用于管理分布式计算机系统资源的操作系统。它具有任务分配功能,可将多个任务分配到多个处理单元上,使这些任务并行执行,从而加速任务的执行。分布式操作系统通常能很好地隐藏系统内部的实现细节,包括对象的物理位置、并发控制和系统故障等对用户都是透明的。例如,当用户要访问某个文件时,只需提供文件名而无须知道它是驻留在哪个站点上。分布式操作系统支持系统中所有用户对分布在各个站点上的软硬件资源的共享和透明方式访问。
    4.嵌入式操作系统:
    嵌入式操作系统(Embedded Operating System)是指运行在嵌入式系统环境中,对整个嵌入式系统以及它所操作、控制的各种部件装置等资源进行统一协调、调度和控制的操作系统。嵌入式操作系统在系统实时高效性、硬件的相关性、软件固态化以及应用的专用性等方面具有较为突出的特点。在通信、工业控制、家用电器等方面,嵌入式系统有广泛的应用。
    5.分时操作系统:

    在分时操作系统(Time Sharing Operating System)中,一台计算机与多台终端设备相连接,多终端上的用户通过各自的终端以交互方式共用一台计算机,计算机以“分时”的方法轮流为每个用户服务。由于CPU速度比人在终端上输入控制命令的速度快得多,使得每个用户就好像独占计算机一样。在协调用户分享CPU时,操作系统通常采用“时间片轮转法”分配CPU,即系统规定一个被称为“时间片”的时间单位,所有终端用户轮流享用一个时间片的CPU时间。

    二、相关名词

    1.安装程序: 提供安装程序帮助用户自动化地安装全部文件的程序。
    2.病毒:一种计算机程序,可以附属在可执行文件或隐藏在系统数据区中,在执行某些程序后悄悄地进驻内存,然后对其它的文件              进行传染,使之传播出去,然后在特定的条件下破坏系统。新病毒层出不穷,成为一大危害。
    3.集成开发环境:早期程序设计的各个阶段都要用不同的软件来进行处理,如先用字处理软件编辑源程序,然后用链接程序进行函数、              模块连接,再用编译程序进行编译,开发者必须在几种软件间来回切换操作。现在的编程开发软件将编辑、编译、调试等功能集成在一个桌面环境中,这样就大大方便了用户。
    4.拷贝: 指将文件从一处复制一份完全一样的到另一处,而原来的一份依然保留。
    5.删除: 指将文件从系统的目录清单中删掉,但许多情况下,用工具软件或Windows下自带的“回收站”均能恢复被删掉的文件,为                了保险起见,用户最好养成对自己输入的文本或其它文件进行软盘备份,以防万一。
    6.移动: 就是将拷贝操作和删除操作合二为一,原来的一份在拷贝完成后即被自动删掉。
    7.共享: 这是在网络环境下文件使用时的一种设置属性,一般指多个用户可以同时打开或使用同一个文件(或数据)。
    8.独占:系指文件(或数据)同一时刻只能被一个用户打开,其它用户只能等待此用户放弃后,才能打开和使用它,正好与共享相反。
    9.压包: 用工具软件将文件进行压缩存储的过程,常用的压包工具有WinZip 、Arj等。
    10.解包: 压包的反过程,即将压包文件还原成原来的文件。
    11.加密: 在网络通讯中,为了保证传输数据的保密性,用密码对文件进行加密变换。
    12.解密: 加密的反过程,使之变成可使用的正常数据。
    13.上传:本地计算机与其它计算机通过网络连接成功后,将本机文件拷贝到其它计算机中的过程。
    14.下载:在网络中,将对方计算机中的文件拷贝至本地计算机中的过程。
    15.通配符: 在DOS操作系统下,为了提高对文件处理的效率,用*或?表示任意多个或一个字符,这样就可以一次性处理一批文件,如*.*                  即代表当前目录下的全部可见文件。
    16.内部命令: 启动了DOS操作系统后,任何时候都能使用的命令,如DIR、COPY等,因为这样命令已编在COMMAND.COM文件中。
    17.外部命令: 虽然也是DOS命令,但它们是经过同名的程序文件提供的功能,若程序文件被删除,则此命令将不可使用,如                                  DISKCOPY、FORMAT等。

    18.格式化: 指对磁盘进行使用前的预处理以便存入数据。一般而言,新盘是必须格式化的,而使用过的旧盘也可以格式化,格式化后                  磁盘上全部数据将被删除。

    三、常用种类

     

    1.Windows,当前世界最火热的系统,占有量位居世界第一,达到了92%。可以说现在操作系统就是Windows的天下。

    2.Mac OS X,当前市面上的所有操作系统中占有比5%,位居操作系统占比的第二。主要是苹果公司旗下的电脑操作系统。

    3.Linux,在所有操作系统中占比1%,排在第三位,与其他小品种操作系统相比占比就算比较大了。

    4.UNIX和DOS就介于以上三种系统和小品种操作系统之间了。

     

                                                           

                                                  

    展开全文
  • 计算机操作系统是计算机专业必修的专业基础课程,是考研的必考科目。它的特点是概念多、较抽象和涉及面广,所以无论是大学学习还是考研,很多同学都把它当做一块硬骨头,其实只要我们掌握正确的学习方法,操作系统...
  • 计算机操作系统_银行家算法

    万次阅读 多人点赞 2018-12-05 23:21:02
    银行家算法

    银行家算法

    什么是银行家算法?
      银行家算法(Banker’s Algorithm)是一个避免死锁(Deadlock)的著名算法,是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础,判断并保证系统的安全运行。
      在银行中,客户申请贷款的数量是有限的,每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量,在满足所有贷款要求时,客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时,都应尽量满足客户的需要。在这样的描述中,银行家就好比操作系统,资金就是资源,客户就相当于要申请资源的进程。
      银行家算法是一种最有代表性的避免死锁的算法。在避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。为实现银行家算法,系统必须设置若干数据结构。
      
    银行家算法中的数据结构
      为了实现银行家算法,在系统中必须设置这样四个数据结构,分别用来描述系统中可利用的资源、所有进程对资源的最大需求、系统中的资源分配,以及所有进程还需要多少资源的情况。
      (1) 可利用资源向量 Available。这是一个含有 m 个元素的数组,其中的每一个元素代表一类可利用的资源数目,其初始值是系统中所配置的该类全部可用资源的数目,其数值随该类资源的分配和回收而动态地改变。如果 Available[j] = K,则表示系统中现Rj类资源K个。
      (2) 最大需求矩阵Max。这是一个n x m的矩阵,它定义了系统中n个进程中的每个进程对m类资源的最大需求。如果Max[i,j] = K,则表示进程i需要Rj 类资源的最大数目为K。
      (3) 分配矩阵 Allocation。这也是一个n x m的矩阵,它定义了系统中每一类资源当前已分配给每一进程的资源数。如果 Allocation[i,jl = K,则表示进程i当前己分得Rj类资源的数目为K。
      (4) 需求矩阵Need.这也是一个n×m的矩阵,用以表示每一个进程尚需的各类资源数。如果Need[i,j] = K,则表示进程i还需要Rj类资源K个方能完成其任务。
    上述三个矩阵间存在下述关系:
                  Need[i,j] = Max[i,j] - allocation[i, j]
                  
    银行家算法详述:
      设 Request;是进程Pi的请求向量,如果 Requesti[j] = K,表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后,系统按下述步骤进行检査:
      (1) 如果 Requesti[j] ≤ Need[i,j]便转向步骤(2);否则认为出错,因为它所需要的资源数已超过它所宣布的最大值。
      (2) 如果 Requesti[j] ≤ Available[j],便转向步骤(3);否则,表示尚无足够资源,Pi须等待。
      (3) 系统试探着把资源分配给进程Pi,并修改下面数据结构中的数值
        Available[j] = Available[j] - Requesti[j];
        Allocation[i,j] = Allocation[i,j] + Requesti[j];
        Need[i,j] = Need[i,j] - Requesti[j];
      (4) 系统执行安全性算法,检查此次资源分配后系统是否处于安全状态。若安全,才正式将资源分配给进程Pi,以完成本次分配;否则,将本次的试探分配作废,恢复原来的资源分配状态,让进程Pi等待。
      
    安全性算法:
    系统所执行的安全性算法可描述如下:
      (1) 设置两个向量:①工作向量Work,它表示系统可提供给进程继续运行所需的各类资源数目,它含有m个元素,在执行安全算法开始时,Work = Available;② Finish:它表示系统是否有足够的资源分配给进程,使之运行完成。开始时先做 Finish[i] = false;当有足够资源分配给进程时,再令Finish[i] = true。
      (2) 从进程集合中找到一个能满足下述条件的进程
        ① Finish[i] = false;
        ② Need[i,j] ≤ Work[j];
    若找到,执行步骤(3),否则,执行步骤(4)。
      (3)当进程Pi获得资源后,可顺利执行,直至完成,并释放出分配给它的资源,故应执行:
        Work[j] = Work[j] + Allocation[i,j];
        Finish[i] = true;
        go to step 2;(goto语句不推荐使用 _ )
      (4)如果所有进程的 Finish[i] =true都满足,则表示系统处于安全状态;否则,系统处于不安全状态。
      
    难点透析:
      本程序的难点在于安全性算法,对于一个安全的系统来说,此步骤较为容易,难在于判断不安全的系统。为什么这么说呢?由于本程序再设计寻找安全序列的部分使用while循环,就需要找到分别处理安全系统与不安全系统的终止循环条件,对于安全的系统,满足条件 Finish[i] = false 和 Need[i,j] ≤ Work[j] 的,必定也会按照预期的将 Finish[i] 向量全部置为true,那是不是就可以设置一个变量来累加计数,当该变量与进程数量相等的时候,就说明已经全部置为true了,终止循环,也就是说系统安全。
      对于不安全的系统,上述方法肯定是不行的,因为不可能将向量 Finish[i] 都置为 true ,必定存在 false。就得寻求一个跳出循环的条件,但是由于需要不断循环查找并尝试分配,寻求一个安全序列,到底该怎么算是已经找不到安全路径了呢?下面说本程序的解决办法,首先需要想到的是,当我们寻找一轮都没有找到一个可以安全执行的进程,是不是就说明往后也找不到了呢?没错,就是这样的!所以我们每次在记录 Finish[i] = true 的次数的时候,不妨把这个次数再使用另一个变量存放起来,然后在判断语句当中判断当寻找一轮下来,该值未发生改变,说明已经找不到安全的进程了,即可跳出循环,该系统不安全!
    图示:
    在这里插入图片描述

    部分效果图:
    在这里插入图片描述
    在这里插入图片描述
    完整代码:

    #include<stdio.h>
    #define resourceNum 3
    #define processNum  5
    
    //系统可用(剩余)资源
    int available[resourceNum]={3,3,2};
    //进程的最大需求
    int maxRequest[processNum][resourceNum]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}};
    //进程已经占有(分配)资源
    int allocation[processNum][resourceNum]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}};
    //进程还需要资源
    int need[processNum][resourceNum]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}};
    //是否安全
    bool Finish[processNum];
    //安全序列号
    int safeSeries[processNum]={0,0,0,0,0};
    //进程请求资源量
    int request[resourceNum];
    //资源数量计数
    int num;
    
    //打印输出系统信息
    void showInfo()
    {
    	printf("\n------------------------------------------------------------------------------------\n");  
    	printf("当前系统各类资源剩余:");
        for(int j = 0; j < resourceNum; j++)
    	{
            printf("%d ",available[j]);
        }
        printf("\n\n当前系统资源情况:\n");
        printf(" PID\t Max\t\tAllocation\t Need\n");
        for(int i = 0; i < processNum; i++)
    	{
            printf(" P%d\t",i);
            for(int j = 0; j < resourceNum; j++)
    		{
                printf("%2d",maxRequest[i][j]);
            }
            printf("\t\t");
            for(j = 0; j < resourceNum; j++)
    		{
                printf("%2d",allocation[i][j]);
            }
            printf("\t\t");
            for(j = 0; j < resourceNum; j++)
    		{
                printf("%2d",need[i][j]);
            }
            printf("\n");
        }
    }
    
    //打印安全检查信息
    void SafeInfo(int *work, int i)
    {
        int j;
        printf(" P%d\t",i);
        for(j = 0; j < resourceNum; j++)
    	{
            printf("%2d",work[j]);
        }   
        printf("\t\t");
        for(j = 0; j < resourceNum; j++)
    	{
            printf("%2d",allocation[i][j]);
        }
    	printf("\t\t");
        for(j = 0; j < resourceNum; j++)
    	{
            printf("%2d",need[i][j]);
        }
        printf("\t\t");
        for(j = 0; j < resourceNum; j++)
    	{
            printf("%2d",allocation[i][j]+work[j]);
        }
        printf("\n");
    }
    
    //判断一个进程的资源是否全为零
    bool isAllZero(int kang)
    {
    	num = 0;
    	for(int i = 0; i < resourceNum; i++ )
    	{
    		if(need[kang][i] == 0)
    		{
    			num ++;
    		}
    	}
    	if(num == resourceNum)
    	{
    		return true;
    	}
    	else
    	{
    		return false;
    	}   
    }
    
    //安全检查
    bool isSafe()
    {
    	//int resourceNumFinish = 0;
    	int safeIndex = 0;
    	int allFinish = 0;
        int work[resourceNum] = {0};
    	int r = 0;
    	int temp = 0;
    	int pNum = 0;
    	//预分配为了保护available[]
        for(int i = 0; i < resourceNum; i++)
    	{		
            work[i] = available[i];	
        }
    	//把未完成进程置为false
        for(i = 0; i < processNum; i++)
    	{
    		bool result = isAllZero(i);
    		if(result == true)
    		{
    			Finish[i] = true;
    			allFinish++;
    		}
    		else
    		{
    			Finish[i] = false;
    		}
    
        }
    	//预分配开始
        while(allFinish != processNum)
    	{
    		num = 0;	
            for(i = 0; i < resourceNum; i++)
    		{
    			if(need[r][i] <= work[i] && Finish[r] == false)
    			{
    				num ++;
    			}			
    		}
    		if(num == resourceNum)
    		{		
    			for(i = 0; i < resourceNum; i++ )
    			{
    				work[i] = work[i] + allocation[r][i];
    			}
    			allFinish ++;
    			SafeInfo(work,r);
    			safeSeries[safeIndex] = r;
    			safeIndex ++;
    			Finish[r] = true;
    		}
    		r ++;//该式必须在此处	
    		if(r >= processNum)
    		{
    			r = r % processNum;
    			if(temp == allFinish)
    			{
    				break;	
    			}
    			temp = allFinish;
    		}		
    		pNum = allFinish;
        }	
    	//判断系统是否安全
    	for(i = 0; i < processNum; i++)
    	{
    		if(Finish[i] == false)
    		{
    			printf("\n当前系统不安全!\n\n");
    			return false;	
    		}
    	}
    	//打印安全序列
    	printf("\n当前系统安全!\n\n安全序列为:");
    	for(i = 0; i < processNum; i++)
    	{	
    		bool result = isAllZero(i);
    		if(result == true)
    		{		
    			pNum --;
    		}	
        }
    	for(i = 0; i < pNum; i++)
    	{
    		printf("%d ",safeSeries[i]);
    	}
        return true;
    }
    
    //主函数
    void main()
    {
        int curProcess = 0;
    	int a = -1;
           showInfo(); 
    	printf("\n系统安全情况分析\n");
    	printf(" PID\t Work\t\tAllocation\t Need\t\tWork+Allocation\n");
    	bool isStart = isSafe();
    	//用户输入或者预设系统资源分配合理才能继续进行进程分配工作
        while(isStart)
    	{
    		//限制用户输入,以防用户输入大于进程数量的数字,以及输入其他字符(乱输是不允许的)
          	do
    		{ 
    			if(curProcess >= processNum || a == 0)
    			{
    				printf("\n请不要输入超出进程数量的值或者其他字符:\n");
    				while(getchar() != '\n'){};//清空缓冲区	
    				a = -1;
    			}
    			printf("\n------------------------------------------------------------------------------------\n");
    			printf("\n输入要分配的进程:");
    			a = scanf("%d",&curProcess);
    			printf("\n");
    
    		}while(curProcess >= processNum || a == 0);
    		
    		//限制用户输入,此处只接受数字,以防用户输入其他字符(乱输是不允许的)
    		for(int i = 0; i < resourceNum; i++)
    		{
    			do
    			{
    				if(a == 0)
    				{
    					printf("\n请不要输入除数字以外的其他字符,请重新输入:\n");
    					while(getchar() != '\n'){};//清空缓冲区	
    					a = -1;
    				}
    				printf("请输入要分配给进程 P%d 的第 %d 类资源:",curProcess,i+1);
    				a = scanf("%d", &request[i]);
    			}while( a == 0);
    		}
    
    		//判断用户输入的分配是否合理,如果合理,开始进行预分配
    		num  = 0;
            for(i = 0; i < resourceNum; i++)
    		{
                if(request[i] <= need[curProcess][i] && request[i] <= available[i])
    			{
    				num ++;
    			}
                else
    			{
    				printf("\n发生错误!可能原因如下:\n(1)您请求分配的资源可能大于该进程的某些资源的最大需要!\n(2)系统所剩的资源已经不足了!\n");
    				break;
    			}
            }
            if(num == resourceNum)
    		{	
    			num = 0;	
                for(int j = 0; j < resourceNum; j++)
    			{
    				//分配资源
                    available[j] = available[j] - request[j];
                    allocation[curProcess][j] = allocation[curProcess][j] + request[j];
                    need[curProcess][j] = need[curProcess][j] - request[j];
    				//记录分配以后,是否该进程需要值为0了
    				if(need[curProcess][j] == 0)
    				{
    					num ++;
    				}
                }
    			//如果分配以后出现该进程对所有资源的需求为0了,即刻释放该进程占用资源(视为完成)
    			if(num == resourceNum)
    			{
    				//释放已完成资源
    				for(int i = 0; i < resourceNum; i++ )
    				{
    					available[i] = available[i] + allocation[curProcess][i];
    				}
    				printf("\n\n本次分配进程 P%d 完成,该进程占用资源全部释放完毕!\n",curProcess);
    			}
    			else
    			{
    				//资源分配可以不用一次性满足进程需求
    				printf("\n\n本次分配进程 P%d 未完成!\n",curProcess);
    			}
    
    			showInfo();
               	printf("\n系统安全情况分析\n");
    			printf(" PID\t Work\t\tAllocation\t Need\t\tWork+Allocation\n");
    
    			//预分配完成以后,判断该系统是否安全,若安全,则可继续进行分配,若不安全,将已经分配的资源换回来
                if(!isSafe())
    			{ 	        
    				for(int j = 0; j < resourceNum; j++)
    				{
    					available[j] = available[j] + request[j];
    					allocation[curProcess][j] = allocation[curProcess][j] - request[j];
    					need[curProcess][j] = need[curProcess][j] +request[j];
    				}
    				printf("资源不足,等待中...\n\n分配失败!\n");				
                }
            }
        }
    }
    

    参考文献:计算机操作系统/汤小丹等编著.-4版.-西安:西安电子科技大学出版社,2014.5(2016.4重印)

    如有错误,欢迎指正!

    展开全文
  • 计算机操作系统核心知识点总结&面试笔试要点

    万次阅读 多人点赞 2019-08-14 22:00:41
    操作系统之基础篇 一、 操作系统概述  1. 操作系统的演进   无操作系统:人工操作,用户独占,CPU等待人工操作,资源利用率很低。   批处理系统:批量输入任务,无需等待人工操作,资源利用率提升,提出多道...

    操作系统之基础篇

    一、 操作系统概述

    1. 操作系统的演进
      无操作系统:人工操作,用户独占,CPU等待人工操作,资源利用率很低。
      批处理系统:批量输入任务,无需等待人工操作,资源利用率提升,提出多道程序设计。
      分时系统:人-机交互,多用户共享,资源利用率提升,及时调试程序。
      关于多道程序设计:是指在计算机内存中同时存放多个程序,多道程序在计算机的管理程序之下相互穿插运行。
    2. 操作系统的定义与目标
      定义:管理硬件,提供用户交互的软件系统。
      目标:方便性,有效性(提高系统资源的利用率、提高系统的吞吐量),可扩充性,开放性。
    3. 操作系统的基本功能
       统一管理计算机资源:处理器资源,IO设备资源,存储器资源,文件资源…
      实现了对计算机资源的抽象:IO设备管理软件提供读写接口,文件管理软件提供操作文件接口…
      提供了用户与计算机之间的接口:图像窗口形式,命令形式,系统调用形式…
    (6-2-1154)
     4. 操作系统的基本特性
      a.并发性
       并行:指两个或多个事件可以在
    同一个时刻
    发生;
       并发:指两个或多个事件可以在同一个时间间隔发生。
    (6-2-1619)
      b.共享性:操作系统的中资源可供多个并发的程序共同使用,这种形式称之为资源共享
       互斥共享:当资源被程序占用时,其它想使用的程序只能等待。
       同时访问:某种资源并发的被多个程序访问。
       c.虚拟性:表现为把一个物理实体转变为若干个逻辑实体
       时分复用技术:资源在时间上进行复用,不同程序并发使用,多道程序分时使用计算机的硬件资源,提高资源的利用率。
       空分复用技术:用来实现虚拟磁盘(物理磁盘虚拟为逻辑磁盘,电脑上的C盘、D盘等)、虚拟内存(在逻辑上扩大程序的存储容量)等,提高资源的利用率,提高编程效率。
      d.异步性:在多道程序环境下,允许多个进程并发执行,但由于资源等因素的限制,使进程的执行以“停停走走”的方式运行,而且每个进程执行的情况(运行、暂停、速度、完成)也是未知的。
    二、进程管理
    1. 进程实体
      a.为什么需要进程
       ·进程是系统进行资源分配和调度的基本单位;
       ·进程作为程序独立运行的载体保障程序正常执行;
       ·进程的存在使得操作系统资源的利用率大幅提升。
      b.进程控制块(PCB):用于描述和控制进程运行的通用数据结构,记录进程当前状态和控制进程运行的全部信息。
      c.进程(Process)与线程(Thread):
       线程:操作系统进行运行调度的最小单位。
       进程:系统进行资源分配和调度的基本单位。
       区别与联系:一个进程可以有一个或多个线程;线程包含在进程之中,是进程中实际运行工作的单位;进程的线程共享进程资源;一个进程可以并发多个线程,每个线程执行不同的任务。
    (6-3-1300)
    2. 进程的五状态模型
      就绪状态:其它资源(进程控制块、内存、栈空间、堆空间等)都准备好、只差CPU的状态。
      执行状态:进程获得CPU,其程序正在执行。
      阻塞状态:进程因某种原因放弃CPU的状态。
      创建状态:创建进程时拥有PCB但其它资源尚未就绪。
      终止状态:进程结束由系统清理或者归还PCB的状态。
    (6-4-0839)
    3.进程同步
      a.生产者-消费者问题:有一群生产者进程在生产产品,并将这些产品提供给消费者进程进行消费,生产者进程和消费者进程可以并发执行,在两者之间设置了一个具有n个缓冲区的缓冲池,生产者进程需要将所生产的产品放到缓冲区中(+1操作),消费者进程可以从缓冲区取走产品消费(-1操作)。
    (6-5-0207)
       产生问题:当两者并发执行时可能出差错,如下图:
    (6-5-0627)
       当执行生产者+1和消费者-1操作之后,缓冲区的值从10变为了11
       程序实例–>https://blog.csdn.net/huanglei305/article/details/99621301
      b.哲学家进餐问题:有5个哲学家,他们的生活方式是交替的思考和进餐,哲学家们共同使用一张圆桌,分别坐在5张椅子上,圆桌上有5只碗和5只筷子。平时哲学家们只进行思考,饥饿时则试图取靠近他们的左右两只筷子,只有两只筷子都被拿到的时候才能进餐,否则等待,进餐完毕后,放下左右筷子进行思考。
    (6-5-1110)
       产生问题:(6-5-1238)
      c.进程同步的作用对竞争资源在多进程间进行使用次序的协调,使得并发执行的多个进程之间可以有效使用资源和相互合作。
      d.进程间同步的四原则
       空闲让进:资源无占用,允许使用;
       忙则等待:资源被占用,请求进程等待;
       有限等待:保证有限等待时间能够使用资源;
       让权等待:等待时,进程需要让出CPU。
      e.进程同步的方法(重要,后面详细讲解):消息队列,共享存储,信号量
      f.线程同步的方法(重要,后面详细讲解):互斥量,读写锁,自旋锁,条件变量
    4. Linux的进程管理
      a.进程的类型
       前台进程:具有终端,可以和用户交互;
       后台进程:基本不和用户交互,优先级比前台进程低;
       守护进程:特殊的后台进程,在系统引导时启动,一直运行直到系统关闭,如crond、sshd、httpd、mysqld…
      b.进程的标记
       进程ID:非负整数,进程的唯一标记,每个进程拥有不同的ID;
       进程的状态标记:R表示进程处于运行状态,S表示进程处于睡眠状态…
      c.操作Linux进程的相关命令
       ps命令:列出当前的进程,结合-aux可以打印进程的详细信息(ps -aux);
       top命令:查看所有进程的状态;
       kill命令:给进程发送信号。
    三、作业管理
    1.进程调度
      定义:指计算机通过决策决定哪个就绪进程可以获得CPU使用权
      方法:
       非抢占式调度:处理器一旦分配给某个进程,就让该进程一直使用下去,直到进程完成工作或IO阻塞才会让出处理器。
       抢占式调度:允许调度程序以一定的策略暂停当前运行地进程
    (6-7-0636)
      步骤:
       保留旧进程的运行信息,请出旧进程(收拾包袱);
       选择新进程,准备运行环境并分配CPU。
      a.三个重要的机制:
       就绪队列的排队机制:为了提高进程调度的效率,将就绪进程按照一定的方式排成队列,以便调度程序可以最快找到就绪进程。
       选择运行进程的委派机制:调度程序以一定的策略,选择就绪进程,将CPU资源分配给它。
       新老进程的上下文切换机制:保存当前进程的上下文信息,装入被委派执行进程的运行上下文。
      b.进程调度算法
       先来先服务算法:按照在就绪队列中的先后顺序执行。
       短进程优先调度算法:优先选择就绪队列中估计运行时间最短的进程,不利于长作业进程的执行
       高优先权优先调度算法:进程附带优先权,优先选择权重高的进程,可以使得紧迫的任务优先处理
       时间片轮转调度算法:按照FIFO的原则排列就绪进程,每次从队列头部取出待执行进程,分配一个时间片执行,是相对公平的调度算法,但是不能保证就是响应用户
    2.死锁:是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。 此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。
      a.死锁的产生:竞争资源(共享资源数量不满足各进程需求)、进程调度顺序不当,如下图,当调度顺序为A->B->C->D时会产生死锁,但改为A->D->B->C则不会产生。
    (6-8-0519)
      b.死锁的四个必要条件:
       互斥条件:进程对资源的使用是排他性使用,某资源只能由一个进程使用,其它进程需要使用只能等待。
       请求保持条件:进程至少保持一个资源,又提出新的资源请求,新资源被占用,请求被阻塞,被阻塞的进程不释放自己保持的资源。
       不可剥夺条件:进程获得的资源在未完成使用前不能被剥夺(包括OS),只能由进程自身释放。
       环路等待条件:发生死锁时,必然存在进程-资源环形链.
      c.死锁的处理
       预防死锁的方法:破坏四个必要条件的中一个或多个。
        破坏请求保持条件:系统规定进程运行之前,一次性申请所有需要的资源。
        破坏不可剥夺条件:当一个进程请求新的资源得不到满足时,必须释放占有的资源。
        破坏环路等待条件:可用资源线性排序,申请必须按照需要递增申请。
      银行家算法:客户申请的贷款是有限的,每次申请需要申明最大资金量,银行家在能够满足贷款时,都应该给用户贷款,客户在使用贷款后,能够及时归还贷款。
      具体请移步–>https://blog.csdn.net/huanglei305/article/details/99637605
    四、存储管理
    1.内存分配与回收
      内存分配的过程:单一连续分配、固定分区分配、动态分区分配(根据实际需要,动态的分配内存)。
      动态分区分配算法:
       首次适应算法:分配内存时,从开始顺序查找适合内存区,若无合适内存区,则分配失败。
       最佳适应算法:要求空闲区链表按照容量大小排序,遍历以找到最佳适合的空闲区。
       快速适应算法:要求有多个空闲区链表,每个空闲区链表存储一种容量的空闲区。
      内存回收的过程:

    2.段页式存储管理
      页式存储管理:将进程逻辑空间等分成若干大小的页面,相应的把物理内存空间分成与页面大小的物理块,以页面为单位把进程空间装进物理内存中分散的物理块。
      段式存储管理:将进程逻辑空间分成若干段(不等分),段的长度由连续逻辑的长度决定。
      两者相比:(6-10-1022)
      段页式存储管理:现将逻辑空间按照段式管理分成若干段,再将内存空间按照页式管理分成若干页,分页可以有效提高内存利用率分段可以更好的满足用户需求
      三者分配内存之后的对比:
    在这里插入图片描述
    3.虚拟内存
      概述:实际是对物理内存的扩充,速度接近于内存,成本接近于辅存。
      局部性原理:指CPU访问存储器时,无论是存取指令还是存取数据,所访问的存储单元都趋于聚集在一个较小的连续区域中
      虚拟内存的置换算法:先进先出(FIFO)、最不经常使用(LFU)、最近最少使用(LRU)
    4.Linux的存储管理
      Buddy内存管理算法:为解决内存外碎片的问题,算法基于计算机处理二进制的优势具有极高的效率。
      Linux交换空间:交换空间(Swap)是磁盘的一个分区,Linux内存满时,会把一些内存交换至Swap空间,Swap空间是初始化系统时配置的。
      Swap空间与虚拟内存的对比:(6-12-1533)
    五、文件管理
    1.文件管理概述
      a.文件的逻辑结构:
       逻辑结构的文件类型:有结构文件(文本文件,文档,媒体文件)、无结构文件(二进制文件、链接库)。
       顺序文件:按顺序放在存储介质中的文件,在逻辑文件当中存储效率最高,但不适合存储可变长文件。
       索引文件:为解决可变长文件存储而发明,需要配合索引表存储。
      b.辅存的存储空间分配:
       辅存的分配方式:连续分配(读取文件容易,速度快)、链接分配(隐式链接和显式链接)、索引分配
       辅存的存储空间管理:
      c.目录管理:
       目录树:使得任何文件或目录都有唯一的路径。
    2.Linux文件的基本操作
      a.Linux目录:Linux一切皆文件。
    (6-14-0415)
    (6-14-0504)
      b.Linux文件常用操作:
       (目录/文件)创建、删除、读取、写入
      c.Linux文件类型:
    在这里插入图片描述
    3.Linux的文件系统
       文件系统概览:FAT、NTFS(对FAT进行改进)、EXT2/3/4(扩展文件系统,Linux的文件系统)
       EXt文件系统:(6-15-0455)
    六、设备管理
    1.广义的IO设备:
       按照使用特性分类:存储设备(内存、磁盘、U盘)和交互IO设备(键盘、显示器、鼠标)
       按照信息交换分类:块设备(磁盘、SD卡)和字符设备(打印机、shell终端)
       按照设备共享属性分类:独占设备,共享设备,虚拟设备
       按照传输速率分类:低速设备,高速设备
    2.IO设备的缓冲区:减少CPU处理IO请求的频率,提高CPU与IO设备之间的并行性。
    3.SPOOLing技术:虚拟设备技术,利用高速共享设备将低速的独享设备模拟为高速的共享设备,逻辑上,系统为每一个用户都分配了一台独立的高速独享设备。

    操作系统之提升篇(重点)

    一、线程同步的方法
    1.互斥锁
      互斥锁是最简单的线程同步的方法,也称为互斥量,处于两态之一的变量:解锁和加锁,两个状态可以保证资源访问的串行。
    (7-2-0103)
      原子性:指一系列操作不可被中断的特性,要么全部执行完成,要么全部没有执行。
    2.自旋锁
      自旋锁是一种多线程同步的变量,使用自旋锁的线程会反复检查锁变量是否可用,自旋锁不会让出CPU,是一种忙等待状态,即死循环等待锁被释放
      特点:避免了进程或者线程上下文切换的开销,但是不适合在单核CPU使用
    (7-3-0126)
    3.读写锁
      是一种特殊的自旋锁,允许多个读操作同时访问资源以提高读性能,但是对写操作是互斥的,即对多读少写的操作效率提升很显著。
    (7-4-0355)
    4.条件变量
      是一种相对比较复杂的线程同步方法,条件变量允许线程睡眠,直到满足某种条件,当满足条件时,可以给该线程信号通知唤醒
      例如,在生产者-消费者问题当中,规定当缓冲区小于等于时,不允许消费者消费,消费者必须等待;缓冲区满时,不允许生产者往缓冲区生产,生产者必须等待;即当生产者生产一个产品时,唤醒可能等待的消费者,当消费者消费一个产品时,唤醒可能等待的生产者。
    5.线程同步方法总结
      4种线程同步方法对比:
    在这里插入图片描述
    二、进程同步
    1.使用fork系统调用创建进程
      使用fork系统调用无参数,fork会返回两次,分别返回子进程id和0,返回子进程id的是父进程,返回0的是子进程。
    2.共享内存
      在某种程度上,多进程是共同使用物理内存的,但是由于操作系统的进程管理,进程间的内存空间是独立的,因此进程默认是不能访问进程空间之外的内存空间的
      共享存储允许不相关的进程访问同一片物理内存,共享内存是两个进程之间共享和传递数据最快的方式,但是共享内存未提供同步机制,所以需要借助其它机制管理访问。即共享内存是高性能后台开发中最常用的进程同步方式。
    (7-8-0259)
    3.Unix域套接字
      域套接字是一种高级的进程间通信的方法,可以用于同一机器进程间通信。
      套接字(socket):为网络通信中使用的术语。
      Unix系统提供的域套接字提供了网络套接字类似的功能,如Nfinx、uWSGI等。
      服务端和客户端分别使用Unix域套接字的过程:
    (7-9-0247)

    操作系统之实践篇

    实现支持异步任务的线程池
    关于线程池
     线程池:线程池是存放多个线程的容器,CPU调度线程执行后不会销毁线程,将线程放回线程池重新利用。
    使用线程池的原因:
      1.线程是稀缺资源 ,不应该频繁创建和销毁;
      2.架构解耦,业务创建和业务处理解耦,更加优雅;
      3.线程池是使用线程的最佳实践。
    1.实现线程安全的队列Queue
     队列:用于存放多个元素,是存放各种元素的“池”。
     实现的基本功能:获取当前队列元素数量,往队列放入元素,往队列取出元素。
     注意:队列可能有多个线程同时操作,因此需要保证线程安全,如下两种情况:
    在这里插入图片描述
     具体实现:https://blog.csdn.net/huanglei305/article/details/99701518
    2.实现基本任务对象Task
     任务处理逻辑:
      实现的基本功能:任务参数,任务唯一标记(UUID),任务具体的执行逻辑
     具体实现:https://blog.csdn.net/huanglei305/article/details/99701991
    4.实现任务处理线程ProcessThread
     任务处理线程需要不断地从任务队列里取任务执行,任务处理线程需要有一个标记,标记线程什么时候应该停止。
     实现的基本功能:基本属性(任务队列、标记),线程执行的逻辑(run),线程停止(stop)。
    5.实现任务处理线程池Pool
     存放多个任务处理线程,负责多个线程的启停,管理向线程池的提交任务,下发给线程去执行。
     实现的基本过程:基本属性,提交任务(put,batch_put),线程启停(start,join),线程池大小(size)。
     具体实现:https://blog.csdn.net/huanglei305/article/details/99702434
    6.实现异步任务处理AsyncTask
     给任务添加一个标记,任务完成后,则标记为完成;任务完成时可直接获取任务运行结果;任务未完成时,获取任务结果,会阻塞获取线程。
     主要实现的两个函数:设置运行结果(set_result),获取运行结果(get_result)
     具体实现:https://blog.csdn.net/huanglei305/article/details/99703371

    展开全文
  • 计算机操作系统(笔记)

    万次阅读 2017-07-10 11:43:16
    计算机操作系统

    计算机操作系统

    可参考Jennica的文章:http://jennica.space/2017/03/21/os-principle/

    常用指令介绍

    答:(1)授权指令chmod

    chmod [who] [+ | - | =] [mode] 文件名;
    who:默认为a,表示“所有(all)用户”;
    +-=: + 添加某个权限; - 取消某个权限; = 赋予给定权限并取消其他所有权限(如果有的话);
    mode:0表示没有权限'-'(0用字符'-'表示);1表示可执行权限'x';2表示可写权限'w';4表示可读权限'r’。然后按照3个一组,将其相加;
    例如,rwxrw-r-x就是4-2-1-4-2-0-4-0-1,三个一组就是765。注意有时候是这样写的:-rwxrw-r-x,其前面有一个'-',这个'-'不表示0,而是表示该权限是文件的权限,若将'-'改变为'd'就表示目录的权限;

    (2)tar命令

    tar命令有3个主选项,分别是c、x、t;这三个主选项不可同时存在,其中c表示压缩,x表示解压、t表示查看;

    几个其他压缩/解压缩命令:tar是操作.tar的命令;gzip是压缩.gz压缩包的命令;compress:压缩.Z文件;uncompress:解压缩.Z文件。

    (3)tcpdump命令

    作用:简单可靠网络监控的实用工具.

    基本的用法:tcpdump -i eth0;其中,eth0为参数值,表示需要抓包的网口,这是个必需参数哦。

    (4)ARP命令

    用于查看高速缓存中的所有项目。ARP常用命令选项:arp -a或arp -g用于查看高速缓存中的所有项目;

    (5)Linux挂载设备命令mount:其语法是:mount [选项] <-t 类型> [-o 挂载选项] <设备> <挂载点>。例如挂载我们新创建的分区的命令是:mount -t ext3 /dev/hdb1 /mnt

    -t 选项用于指定分区上文件系统的类型;

    -o 选项用于指定一个或多个挂载选项;

    要卸下分区,请使用 umount 命令。语法很简单:umount <挂载点|设备>例如:从挂载点卸载:umount /mnt ;或者直接从硬件文件

    中卸载:umount /dev/hdb1。

    (6)文件描述符域标准输入/输出、重定向

    输入重定向:所谓重定向输入就是在命令中指定具体的输入来源,譬如 cat < test.c表示: 将test.c重定向为cat命令的输入源;

    输出重定向:是指定具体的输出目标以替换默认的标准输出,譬如ls > 1.txt将1.txt文本重定向为ls的标准输出结果。有时候会看到如 ls >> 1.txt这类的写法,>和>>的区别在于:>用于新建而>>用于追加。即ls>1.txt会新建一个1.txt文件并且将ls的内容输出到新建的1.txt中,而ls >> 1.txt则用在1.txt已经存在,而我们只是想将ls的内容追加到1.txt文本中的时候;

    (7)查看CPU利用率:top

    (8)free命令可以显示Linux系统中空闲的、已用的物理内存及swap内存及被内核使用的buffer。free命令是最经常使用的命令之一。

    (9)查看当前目录:pwd和ls(ls -a可以查看隐藏目录)

    (10)切换目录:cd

    (11)查看文件占用磁盘大小:du和df

    (12)创建文件夹:mkdir

    (13)新建文件:touch

    (14)查看文件:cat

    (15)拷贝:cp 移动:mv 删除:rm

    (16)查看进程:ps,如ps aux

    (17)删除进程:kill -9 PID,注-9是参数

    (18)程序运行时间:time,使用时在命令前添加time即可,如:time ./test,可得到三个时间:real 0m0.020s,user 0m0.000s,sys 0m0.018s
    (19)grep命令(重要命令之一):常用于打开文本修改保存,类似打windows开开TXT文本并修改;

    (20)sed命令(重要命令之一):主要用于对文件的增删改查;

    (21)awk命令(重要命令之一):取列是其擅长的;

    (22)find 命令(常与xargs命令配合):查找 -type 文件类型-name 按名称查找-exec执行命令;

    (23)xargs命令:配合find/ls查找,将查找结果一条条的交给后续命令处理;

    (24)gdb调试工具:要调试C/C++的程序,一般有如下几个步骤:

    ①首先在编译时,我们必须要把调试信息加到可执行文件中,编译生成可执行文件-------> g++ -g hello.cpp -o hello;
    ②启动GDB编译hello程序----------> gdb hello;
    ③显示源码------------> l;
    ④开始调试:break 16——设置断点在16行,break func——设置断点在函数func()入口处,info break——查看断点信息,n——单步运行,c——继续运行程序,r——运行程序;p i——打印i的值,finish——退出程序,q——退出gdb。


    章节一、操作系统概述

    1、计算机冯诺依曼结构的五大组成部分

    答:冯.诺依曼理论体系下的计算机五大逻辑部件分别是:控制器、运算器、存储器、输入/输出设备。Cache属于缓存,不是必需的。


    2、操作系统功能

    答:操作系统的基本功能有:
    1.处理机管理(也就是进程管理)
    2.存储器管理
    3.设备管理
    4.文件管理
    5.用户接口(或操作系统接口)

    注:一般把进程管理归为处理机管理之中,不单独说明。


    3、常见的几种操作系统类别

    答:(1)批处理操作系统:又分为单道批处理系统和多道批处理系统,其出现时间较早,主要是为了处理早期IO设备速度和CPU速度差距过大,导致昂

    贵的CPU资源浪费的问题。

    其原理是:将多个作业组成一批,然后送入CPU处理,从而避免原来CPU处理单作业后的长时间等待;

    主要目的:提高资源利用效率。

    (2)实时操作系统:有嵌入式操作系统,设计实时操作系统首先应该考虑系统的实时性和可靠性

    (3)多用户分时操作系统:利用时间片,轮转对多个用户进行服务,而时间片轮转的方式肯定是实时性不高的,分时系统所考虑的主要是使多个用户感

    觉不到是在多人共享计算机,交互性较好。所以要求交互性是最重要的


    4、操作系统的两个基本特征

    答:并发和共享是操作系统的两个最基本的特性,它们又是互为存在条件。一方面资源共享是以程序(进程)的并发性执行为条件的,若系统不允许程

    序并发执行,自然不存在资源共享问题。另一方面若系统不能对资源共享实施有效管理,则也必将影响到程序并发执行。


    5、操作系统体系结构

    答:操作系统体系结构包括4层:最底层是硬件,次底层是操作系统内核,第二层是操作系统与用户接口shell以及编译程序等,第一层是应用程序。具体如图:


    章节二、进程管理

    1、进程与进程控制块(PCB)

    答:(1)进程
    进程由PCB(进程控制块)、有关程序段和该程序段对其进行操作的数据结构集组成;
    1)进程有四种状态:执行、阻塞(等待)、就绪和挂起;
    2)进程各个状态之间互相转换:
    ①就绪——执行:对就绪状态的进程,当进程调度程序按一种选定的策略从中选中一个就绪进程,为之分配了处理机后,该进程便由就绪状态变为执行状态;
    ②执行——阻塞:正在执行的进程因发生某等待事件而无法执行,如IO请求,则进程由执行状态变为等待状态,如进程提出输入/输出请求而变成等待外部设备传输信息的状态,进程申请资源(主存空间或外部设备)得不到满足时变成等待资源状态,进程运行中出现了故障(程序出错或主存储器读写错等)变成等待干预状态等等;
    ③阻塞——就绪:处于等待状态的进程,在其等待的事件已经发生,如IO完成,资源得到满足或错误处理完毕时,处于等待状态的进程并不马上转入执行状态,而是先转入就绪状态,然后再由系统进程调度程序在适当的时候将该进程转为执行状态;
    ④执行——就绪:正在执行的进程,因时间片用完而被暂停执行,或在采用抢先式优先级调度算法的系统中,当有更高优先级的进程要运行而被迫让出处理机时,该进程便由执行状态转变为就绪状态。
    ⑤**——>挂起分三种:
    阻塞——挂起:其中阻塞可以称为活动阻塞,挂起称为静止阻塞;
    就绪——挂起:其中就绪可以称为活动就绪,挂起称为静止就绪;
    执行——挂起:其中执行不变,挂起称为静止就绪;
    故可得出结论:挂起就是静止状态;
    ⑥挂起解除只有一种情况:挂起——就绪;
    3)引入挂起的原因:用户的需求(用户需要挂起一部分进程)、父进程需求(父进程需要考察和修改子进程)、负载均和需求(挂起一部分进程缓解负载)、操作系统需求(操作系统挂起一部分进程进行检查)。
    (2)进程控制块(PCB)
    1)PCB(Processing Control Block)是系统为了管理进程设置的一个专门的数据结构。系统用它来记录进程的外部特征,描述进程的运动变化过程。同时,系统可以利用PCB来控制和管理进程,所以说,PCB(进程控制块)是系统感知进程存在的唯一标志。即:每个进程都有一个PCB,且是唯一的。
    2)PCB一般包括进程ID、处理机状态、进程调度信息、进程控制信息,具体包括:
    1.程序ID(PID、进程句柄):它是唯一的,一个进程都必须对应一个PID。PID一般是整型数字;
    2.特征信息:一般分系统进程、用户进程、或者内核进程等 ;
    3.进程状态:运行、就绪、阻塞,表示进程现的运行情况 ;
    4.优先级:表示获得CPU控制权的优先级大小 ;
    5.通信信息:进程之间的通信关系的反映,由于操作系统会提供通信信道 ;
    6.现场保护区:保护阻塞的进程用 ;
    7.资源需求、分配控制信息 ;
    8.进程实体信息,指明程序路径和名称,进程数据在物理内存还是在交换分区(分页)中 ;
    9.其他信息:工作单位,工作区,文件信息等;

    3)每个进程有一个PCB,如何组织众多的PCB
    ①链表队列模式:
    对各个状态的PCB分别建立一个链表队列,同时保存4个指针,分别是,
    第一个执行指针指向当前执行PCB;
    第二个就绪队列指针指向就绪状态的PCB链表队列首元素;
    第三个阻塞队列指针指向阻塞状态的PCB链表队列首元素;
    第四个空闲队列指针指向空闲状态的PCB链表队列首元素;

    ②索引模式:
    对各个状态PCB分别建立一个索引表,同时保存4个指针,分别是,
    第一个执行指针直接指向当前执行PCB;
    第二个就绪表指针指向就绪索引表的首地址;
    第三个阻塞表指针指向阻塞索引表的首地址;
    第二个空闲表指针指向空闲索引表的首地址;

    4)创建进程需要的步骤:
    1,申请空白PCB(进程控制块);
    2,为新进程分派资源;
    3,初始化PCB;

    4,将新进程插入就绪队列。


    2、进程切换

    答:进程切换的原因:中断的发生、更高优先级进程的唤醒、进程消耗完时间片或阻塞的发生;

    进程切换的步骤:
    ①保存处理器的上下文,包括程序计数器和其它寄存器;
    ②用新状态和其它相关信息更新正在运行进程的PCB;
    ③把原来的进程移至合适的队列-就绪、阻塞;
    ④选择另一个要执行的进程;
    ⑤更新被选中进程的PCB;
    ⑥从被选中进程中重装入;

    3、在Linux中主要提供了fork、vfork、clone三个进程创建方法

    答:fork() 函数复制时将父进程的所有资源都通过复制数据结构进行了复制,然后传递给子进程,所以 fork() 函数不带参数。实际上,fork函数将运行着的程序分成2个(几乎)完全一样的进程,每个进程都启动一个从代码的同一位置开始执行的线程。这两个进程中的线程继续执行,就像是两个用户同时启动了该应用程序的两个副本。;clone() 函数则是将部分父进程的资源的数据结构进行复制,复制哪些资源是可选择的,这个可以通过参数设定,所以 clone() 函数带参数,没有复制的资源可以通过指针共享给子进程。


    4、临界资源

    答:在操作系统中,将互斥共享资源成为临界资源,即该资源可共享,但每次只能一个进程访问,例如输入机、打印机、磁带机等。每个进程中访问临界资源的那段代码称为临界区,在操作系统中,有临界区的概念。临界区内放的一般是被1个以上的进程或线程(以下只说进程)共用的数据。临界区内的数据一次只能同时被一个进程使用,当一个进程使用临界区内的数据时,其他需要使用临界区数据的进程进入等待状态。操作系统需要合理的分配临界区以达到多进程的同步和互斥关系,如果协调不好,就容易使系统处于不安全状态,甚至出现死锁现象。

    5、进程饥饿

    答:由于别的并发进程持久占有所需资源,使某个异步过程在一定时间内不能被激活,从而导致进程推进和响应受到明显影响时,称发生了进程饥饿。当饥饿到一定程度,进程所赋予的任务即使完成也不再具有实际意义时称该进程被饿死。

    6、孤儿进程、僵尸进程、守护进程

    答:定义如下:
    (1)僵尸进程:一个子进程在其父进程还没有调用wait()或waitpid()的情况下退出。这个子进程就是僵尸进程;
    (2)孤儿进程:一个父进程退出,而它的一个或多个子进程还在运行,那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养,并由init进程对它们完成状态收集工作;
    注:僵尸进程将会导致资源浪费,而孤儿则不会。
    (3)守护进程:守护进程(Daemon Process),也就是通常说的 Daemon 进程(精灵进程),是 Linux 中的后台服务进程。它是一个生存期较长的进程,通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。
    守护进程是个特殊的孤儿进程,这种进程脱离终端,为什么要脱离终端呢?之所以脱离于终端是为了避免进程被任何终端所产生的信息所打断,其在执行过程中的信息也不在任何终端上显示。

    守护进程更多参考:http://blog.csdn.net/lianghe_work/article/details/47659889


    7、程序执行特征

    答:程序的顺序执行的特征包括:

    1)顺序性;

    2)封闭性;

    3)程序执行结果的确定性;

    4)程序执行结果的可再现性。

    程序的并发(多道程序)执行可能特征包括:1)在执行期间并发程序相互制约;2)程序与计算不再一一对应;3)并发执行的结果不可再现;4)程

    序的并行执行与程序的并发执行。


    8、并行与并发

    答:并发与并行是两个不同的概念:并发是指多个请求向处理器同时请求,服务器的响应过程是依次响应,或者轮转响应的;并行是多个请求向多个处理器,各自处理各自的请求。

    或者说:在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行。


    9、管程

    答:管程的基本思想是,将共享变量和对它们的操作集中在一个模块中,操作系统或并发程序就由这样的模块构成。这样模块之间联系清晰,便于维护和修改,易于保证正确性。
    管程有一个很重要的特性,即任一时刻管程中只能有一个活跃进程,这一特性使管程能有效地处理互斥问题。

    10、核心态和用户态、内核级线程与用户级线程

    答:(1)进程的执行状态分为:核心态和用户态

    两者的主要区别就在于进程能否获取计算机的所有资源(核心态可以,用户态则受到限制)。

    用户态:Ring3运行于用户态的代码则要受到处理器的诸多检查,它们只能访问映射其地址空间的页表项中规定的在用户态下可访问页面的虚拟地址,且只能对任务状态段(TSS)中I/O许可位图(I/O Permission Bitmap)中规定的可访问端口进行直接访问。

    核心态:Ring0 在处理器的存储保护中,核心态,或者特权态(与之相对应的是用户态),是操作系统内核所运行的模式。运行在该模式的代码,可以无限制地对系统存储、外部设备进行访问。

    凡是涉及到计算机根本运行的事情都应该在核心态下执行,而中断、时钟日期、存储映象图都属于系统级(相对应的是用户级)的资源,对这些资源的修改都必须在核心态,但是读取则没有强制要求。

    用户态切换到内核态的3种方式:

    a、系统调用

    这是用户态进程主动要求切换到内核态的一种方式,用户态进程通过系统调用申请使用操作系统提供的服务程序完成工作,比如前例中fork()实际上就是执行了一个创建新进程的系统调用。而系统调用的机制其核心还是使用了操作系统为用户特别开放的一个中断来实现,例如Linux的int 80h中断。

    b、 异常

    当CPU在执行运行在用户态下的程序时,发生了某些事先不可知的异常,这时会触发由当前运行进程切换到处理此异常的内核相关程序中,也就转到了内核态,比如缺页异常。

    c、 外围设备的中断

    当外围设备完成用户请求的操作后,会向CPU发出相应的中断信号,这时CPU会暂停执行下一条即将要执行的指令转而去执行与中断信号对应的处理程序,如果先前执行的指令是用户态下的程序,那么这个转换的过程自然也就发生了由用户态到内核态的切换。比如硬盘读写操作完成,系统会切换到硬盘读写的中断处理程序中执行后续操作等。

    总结:这3种方式是系统在运行时由用户态转到内核态的最主要方式,其中系统调用可以认为是用户进程主动发起的,异常和外围设备中断则是被动的。

    (2)线程级别分为内核级和用户级

    内核线程: 由操作系统内核创建和撤销。内核维护进程及线程的上下文信息以及线程切换。一个内核线程由于I/O操作而阻塞,不会影响其它线程的运

    行。Windows NT和2000/XP支持内核线程 

    用户线程:由应用进程利用线程库创建和管理,不以来于操作系统核心。不需要用户态/核心态切换,速度快。操作系统内核不知道多线程的存在,因

    此一个线程阻塞将使得整个进程(包括它的所有线程)阻塞。由于这里的处理器时间片分配是以进程为基本单位,所以每个线程执行的时间相对减少。

    Windows NT和OS/2支持内核线程;Linux 支持内核级的多线程


    11、线程的互斥量(锁)与信号量

    答:(1)互斥量用于线程的互斥,信号量用于线程的同步;这是互斥量和信号量的根本区别,也就是互斥和同步之间的区别。

    互斥:是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序,即访问是无序的;

    同步:是指在互斥的基础上(大多数情况),通过其它机制实现访问者对资源的有序访问。在大多数情况下,同步已经实现了互斥,特别是所有写入

    资源的情况必定是互斥的,少数情况是指可以允许多个访问者同时访问资源;

    (2) 互斥量值只能为0/1,信号量值可以为非负整数;

    (3)互斥量的加锁和解锁必须由同一线程分别对应使用,信号量可以由一个线程释放,另一个线程得到。

    即:互斥量是针对一个线程的状态而言的,信号量是针对多个线程状态的;例如:

    当信号量用于临界资源的共享时,信号量初始值为1,取值范围为(-1, 0,1),

    当信号量为1时,表示两个进程皆未进入需要互斥的临界区;

    当信号量为0时,表示有一个进程进入临界区运行,另一个必须等待;

    当信号量为-1时,表示有一个进程正在临界区运行,另一个进程因等待而阻塞在信号量队列中,需要当前已在临界区运行的进程退出时唤醒。


    12、使用线程是如何防止出现大的波峰

    答:意思是如何防止同时产生大量的线程,方法是使用线程池,线程池具有可以同时提高调度效率和限制资源使用的好处,线程池中的线程达到最大数

    时,其他线程就会排队等候。


    13、进程与线程

    答:线程和进程的区别联系:

    (1)进程有自己独立的进程资源(如:地址空间),线程则共享资源;

    (2)进程是并行工作的基本单位和资源分配基本单元,线程是CPU调度的基本单位;

    (2)二者均可并发执行;

    (3)一个程序至少有一个进程,一个进程至少有一个线程,它们是包含关系;

    练习与区别见下图:


    如上图:线程在共享进程的静态、动态区和其他资源时,自己会独立维护一个线程堆(用于存储线程自己私有的全局数据)和一个线程栈(用于存储自己局部数据),这两者是不共享的。


    更多区别见下表:

    根本区别就一点:进程有自己独立的进程资源(如:地址空间),线程则共享资源。

    线程私有与共享:

    1)线程私有包括:栈、寄存器、状态、程序计数器;

    2)线程间共享的有:堆,地址空间,全局变量,静态变量;

    进程间的通信与线程间通信方式:

    进程间通信方法有:共享内存、消息传递(直接或间接传递)、管道;

    线程间通信方法主要有3种:全局变量、消息机制、事件;
    # 全局变量——这个容易理解,也是最常用的方式,通过修改和读取全局变量来实现多个线程之间通信;

    #Message消息机制——windows程序设计中都有线程间的消息通信机制。常用的Message通信的接口主要有两个:PostMessage和PostThreadMessage,PostMessage为线程向主窗口发送消息。而PostThreadMessage是任意两个线程之间的通信接口;

    # CEvent对象——CEvent为MFC中的一个对象,可以通过对CEvent的触发状态进行改变,从而实现线程间的通信和同步。

    注意:线程间的通信目的主要是用于线程同步,所以线程中一般没有像进程通信中的用于数据交换的通信机制

    更多关于进程、线程的详情参见:http://blog.csdn.net/xiongchao99/article/details/74858900


    章节三、处理机调度与死锁

    1、操作系统作业调度

    答:作业(job)是操作系统中一个常见的概念,所谓作业是指用户在一次计算过程或者事务处理过程中,要求计算机系统所作工作的集合。

    设计作业调度算法时应达到如下目标:

    •    (1) 某段时间内尽可能运行更多的作业,应该优先考虑短作业。

    •    (2) 使处理机保持繁忙,应该优先考虑计算量大的作业,即计算型作业。

    •    (3) 使I/O设备保持繁忙,应该优先考虑I/O繁忙的作业,即I/O型作业。

    •    (4) 对所有的作业尽可能公平合理的。这就要求对每个作业尽可能公平对待,不无故地或无限期地拖延一个作业的执行。

    常见的调度模式:

    高级调度 :就是作业调度或长程调度;

    中级调度 :就是存储系统中的“对换”,页面置换就是使用对换技术;

    低级调度 :就是进程调度或短程调度;

    具体就是:

    高级调度:从后备作业队列(作业控制块)中将作业调入进就绪进程队列,所以作业控制块中存放的是后背作业队列。

    中级调度:引入中级调度是为了提高内存的使用率吞,将一些暂时不能运行的进程从内存移动到外存上去。即内存外存之间不断交换,所以中级调度会涉及到虚拟存储器。暂时不能运行的进程,由就绪挂起队列,阻塞挂起队列。而阻塞队列里的进程会由于等待时间过长自动调入到阻塞挂起队列里面去。

    低级调度(进程调度或者短程调度)分两类:非抢占式调度和抢占式调度,从就绪进程队列中选取合适进程送到CPU上运行。


    (一)作业调度离不开具体调度算法,常用的几种作业调度算法:

    (1)先来先服务调度算法

    该算法优先考虑在系统中等待时间最长的作业,而不考虑作业运行时间的长短。如下例,作业运行的次序为:1,2,3,4:


    (2)短作业优先调度算法

    短作业优先调度算法(shortest job first,SJF)总是从作业的后备队列中挑选运行时间最短的作业,作为下—个调度运行的对象。如下例,作业运行的次序为:1,3,4,2:


    (3)响应比高者优先调度算法

    所谓响应比高者优先调度算法,就是在每次调度作业运行时,先计算后备作业队列中每个作业的响应比,然后挑选响应比最高者投入运行。响应比R定义如下:

    R=作业的响应时间/作业的运行时间

    作业的响应时间=作业的等待时间+作业的运行时间

    因此,作业的响应比为:R=1+作业的等待时间/作业的运行时间。

    从以上公式中可从看出,一个作业的响应比随着等待时间的增加而提高。这样,只要系统中的某作业等待了足够长的时间,它总会成为响应比最高者而获得运行的机会。如下例,作业运行的次序为:1,3,2,4:


    (4)最高优先数调度算法

    此算法根据作业的优先数调度作业进入系统运行。为每个作业确定一个优先数,资源能满足且优先数高的作业优先被选中,当几个作业有相同的优先数时,对这些具有相同优先数的作业再按照先来先服务原则进行调度。作业优先数的确定各系统有所不同,有些系统由系统本身根据作业对资源的要求确定其优先数,有的由用户自行确定自己作业的优先数。

    优先数一般在系统中是根据进程运行情况动态确定的,但也有静态优先数调度;

    (5)均衡调度算法

       这种调度算法根据作业对资源的要求进行分类,作业调度从各类作业中挑选,尽可能地使使用不同资源的作业同时执行。这样不仅可以使系统中的不同类型的资源都在被使用,而且可以减少作业等待使用相同资源的时间,从而加快作业的执行。

    (6)时间片轮转调度算法

            时间片轮询算法,这是对FIFO算法的改进,目的是改善短程序(运行时间短)的响应时间,其方法就是周期性地进行进程切换。这个算法的关键点在于时间片的选择,时间片过大,那么轮转就越接近FIFO,如果太小,进程切换的开销大于执行程序的开销,从而降低了系统效率。因此选择合适的时间片就非常重要。选择时间片的两个需要考虑的因素:一次进程切换所使用的系统消耗以及我们能接受的整个系统消耗、系统运行的进程数。
            时间片轮询看上起非常公平,并且响应时间非常好,然而时间片轮转并不能保证系统的响应时间总是比FIFO短,这很大程度上取决于时间片大小的选择,以及这个大小与进程运行时间的相互关系。

    (二)补充:时间片轮转调度算法与系统开销比例计算

    (1)时间片轮转调度算法主要适用于分时系统。在这种算法中,系统将所有就绪进程按到达时间的先后次序排成一个队列,进程调度程序总是选择就绪队列中第一个进程执行,即先来先服务的原则,但仅能运行一个时间片,如100ms。在使用完一个时间片后,即使进程并未完成其运行,它也必须释放出(被剥夺)处理机给下一个就绪的进程,而被剥夺的进程返回到就绪队列的末尾重新排队,等候再次运行。
        在时间片轮转调度算法中,时间片的大小对系统性能的影响很大。如果时间片足够大,以至于所有进程都能在一个时间片内执行完毕,则时间片轮转调度算法就退化为先来先服务调度算法。如果时间片很小,那么处理机将在进程间过于频繁切换,使处理机的开销增大,而真正用于运行用户进程的时间将减少。因此时间片的大小应选择适当。

    (2)系统开销比例的计算方法:切换进程总时间/进程总的运行时间。可以知道,理论上这个比例与具体进程数无关。例如,进程数为 10 的情况下,系统开销比率等于切换进程总时间 / 进程总共运行时间,其中切换进程运行时间为 10*10ms ,进程运行总时间为 300*10+10*10ms ,因此系统开销比率为 10*10/(300*10+10*10), 可以看出系统开销比率与程数无关。


    2、轮询任务调度与抢占式任务调度的区别?

    答:轮询调度算法的原理是每一次把来自用户的请求轮流分配给内部中的服务器,从1开始,直到N(内部服务器个数),然后重新开
    始循环;
    抢占式任务调度算法允许调度程序根据某种原则去暂停某个正在执行的进程,将已分配给该进程的处理机重新分配给另一进程。抢
    占方式的优点是,可以防止一个长进程长时间占用处理机,能为大多数进程提供更公平的服务,特别是能满足对响应时间有着较严
    格要求的实时任务的需求。
    总结:因为抢占式调度可能会暂停一些进程,需要记录进程的运行状态,较为复杂,轮询式只需要轮流分配资源,调度简单。


    3、死锁

    死锁产生原因:

    (1) 因为系统资源不足。
    (2) 进程运行推进的顺序不合适。
    (3) 资源分配不当等。

    产生死锁的四个必要条件:
    1.互斥条件:所谓互斥就是进程在某一时间内独占资源。
    2.请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
    3.不剥夺条件:进程已获得资源,在末使用完之前,不能强行剥夺。
    4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

    注意区分:死锁发生原因和必要条件;

    死锁预防:破坏产生死锁的4个必要条件之一即可;

    死锁避免:该方法同样是属于事先预防的策略,但它并不须事先采取各种限制措施去破坏产生死锁的的四个必要条件,而是在资源的动态分配过程中,用某种方法去防止系统进入不安全状态,从而避免发生死锁。最常用的死锁避免算法是银行家算法

    死锁检测这种方法并不须事先采取任何限制性措施,也不必检查系统是否已经进入不安全区,此方法允许系统在运行过程中发生死锁。但可通过系统所设置的检测机构,及时地检测出死锁的发生,并精确地确定与死锁有关的进程和资源。检测方法包括定时检测、效率低时检测、进程等待时检测、资源分配图简化法等;

    死锁解除

    1) 资源剥夺法。挂起某些死锁进程,并抢占它的资源,将这些资源分配给其他的死锁进程。但应防止被挂起的进程长时间得不到资源,而处于资源匮乏

    的状态;

    2) 撤销进程法。强制撤销部分、甚至全部死锁进程并剥夺这些进程的资源。撤销的原则可以按进程优先级和撤销进程代价的高低进行;

    3)进程回退法。让一个或多个进程回退到足以回避死锁的地步,进程回退时自愿释放资源而不是被剥夺。要求系统保持进程的历史信息,设置还原

    点。


    4、银行家算法

    答:它是最具有代表性的避免死锁的算法。我们可以把操作系统看作是银行家,操作系统管理的资源相当于银行家管理的资金,进程向操作系统请求分配资源相当于用户向银行家贷款。为保证资金的安全,银行家规定:

    (1) 当一个顾客对资金的最大需求量不超过银行家现有的资金时就可接纳该顾客;

    (2) 顾客可以分期贷款,但贷款的总数不能超过最大需求量;

    (3) 当银行家现有的资金不能满足顾客尚需的贷款数额时,对顾客的贷款可推迟支付,但总能使顾客在有限的时间里得到贷款;

    (4) 当顾客得到所需的全部资金后,一定能在有限的时间里归还所有的资金。

    操作系统按照银行家制定的规则为进程分配资源,当进程首次申请资源时,要测试该进程对资源的最大需求量,如果系统现存的资源可以满足它

    的最大需求量则按当前的申请量分配资源,否则就推迟分配。当进程在执行中继续申请资源时,先测试该进程本次申请的资源数是否超过了该资源所剩

    余的总量。若超过则拒绝分配资源,若能满足则按当前的申请量分配资源,否则也要推迟分配。



    章节四、存储管理

    常用内存分配算法

    答:(1)最佳适配算法(best fit):它从全部空闲区中找出能满足分配大小要求的、且且又是最小的空闲分区,这种方法能使碎片尽量小。为适应此

    算法,空闲分区表(空闲区链)中的空闲分区要按从小到大进行排序,自表头开始查找到第一个满足要求的自由分区分配。

    缺点:该算法保留大的空闲区,但造成许多小的空闲区。


    基本分页存储管理系统和请求分页存储管理系统

    答:(1)基本分页存储管理系统:为了防止连续存储的的碎片产生,采用离散存储方式,也就出现了根据分配的基本单位是页还是段的两种离散存储管理,分为基本分页或者分段存储管理系统。

    分段与分页的区别:

    1)页式的逻辑地址是连续的,段式的逻辑地址可以不连续;
    2)页式的地址是一维的(因为每页大小固定,故只需页起始地址),段式的地址是二维的;
    3)分页是操作系统进行,分段是用户确定;
    4)各页可以分散存放在主存,每段必须占用连续的主存空间;


    我们重点分析分页管理系统:

    基本的分页存储管理方式,或称为纯分页存储管理方式,它不具有支持实现虚拟存储器的功能,它要求把每个作业全部装入内存后方能运行。

    分页中的页是指“将一个进程的逻辑地址空间分成若干个大小相等的片”,并为各页加以编号,从0开始,如第0页、第1页等。相应地,也把内存空间分

    成与页面相同大小的若干个存储块,称为(物理)块或页框(frame),也加以编号,如0#块,1#块等。注意,每一个进程都拥有一个自己的页表。

    注意:

    ①要区分页与页表,页是指进程逻辑空间被分割的大小相等的片。页表是指存储页号的索引表,每个进程只有一个页表,每个页表项对应一个页的索引映射。

    例如,一个进程分页系统的页号有8位,那么8位二进制最多表示2^8个号码,所以页表长度=2^8*8(B)=2^8字节。


    ②页式存储和段式存储还是会产生碎片,只是很少。其中,

    ——页式存储由于最后一页一般装不满,就会产生内部碎片;

    ——段式存储由于换入换出会产生外部碎片。

    补充:在内存管理中,内部碎片是已经被分配出去的的内存空间大于请求所需的内存空间;外部碎片是指还没有分配出去,但是由于大小太小而无法分配给申请空间的新进程的内存空间空闲块。


    (2)请求分页存储管理系统:发展自基本分页存储管理系统,是为了能支持虚拟存储器功能,防止内存碎片化,实现逻辑存储地址和物理存储地址之间的转换而产生的。它有两个主要功能:请求调页功能和页面置换功能。其中,

    请求调页功能:在进程运行过程中,若其所要访问的页面不在内存中,就需把它们调入内存;

    页面置换功能:如果在调页过程中,内存中已无空闲空间时,为了保证该进程能正常运行,系统必须实现从内存中调出一页程序或数据到磁盘的对换区中的功能。

    补充:基本分页管理系统与请求分页存储管理系统的区别就是不支持虚拟存储器(也就不支持页面置换功能),所以一开始就需要将所有页面存储到内存中,而请求页面系统则只需要存储当前需要的页面。


    1)请求分页系统的请求页面分配策略和页面置换策略分别有两种:

    请求页面分配策略:固定分配和可变分配;固定分配时内存中的页面数保持不变,可变分配时内存中的页面数可变化;

    页面置换策略:局部置换和全局置换;局部置换只可以对置换本进程内的物理页面进行置换,相反全局置换可以在内存不足时对所有进程的页面进行置换,即使用一个进程的新页面替换另一个进程的页面。这样,局部置换可以保证每个进程在内存中页面数不变,而全局置换就可能改变每个进程在内存中的页面数。


    所以,分配策略和置换策略的组合只有3种模式:

    固定分配与局部置换;

    可变分配与局部置换;

    可变分配与全局置换;

    不包括固定分配与全局置换,因为全局置换会改变页面数,与页面固定分配不符合。


    2)两种置换策略对应的算法:
    局部置换:
    最优算法;
    先进先出算法(有Belady异常);
    Least Recently Used(最近最久未使用算法);
    时钟算法;
    最不常用算法(Least Frequently Used)算法;


    全局置换:
    工作集算法;
    缺页率算法;


    (3)页面置换策略下的逻辑地址与物理地址转换

    页表作用:页表的作用是实现从页号到物理块号的地址映射;

    物理地址的计算公式为:

    物理地址=块的大小(即页的大小L)* 块号f+页内地址d;

    过程:以逻辑地址的页号检索页表,得到该页的物理块号;同时将页内地址d直接送入物理地址寄存器的块内地址字段中。这样物理

    块号和块内地址拼接成了实际访问内存的地址,从而完成了从逻辑地址到物理地址的转换。

    例如:设页号为p,页内位移为d,则对于逻辑地址1011对应的物理地址求法如下:

    p=int(1011/1024)=0,d=1011 %1024=1011。查页表第0页在第5块,所以物理地址为1024*5+1011=6131;



    分页和分段存储管理的主要区别

    答:(1)页是信息的物理单位,是为了满足系统要求。段是信息的逻辑单位,是为了满足用户要求;

    (2)页的大小固定且由系统决定,段大小不固定且由用户程序决定;

    (3)分页的作业空间是一维的,分段的作业地址空间则是二维的。


    页面置换算法

    答:(1)最佳(Optimal)置换算法:指其所选择的被淘汰页面,将是以后永不使用的,或许是在最长(未来)时间内不再被访问的页面。采用最佳置换算法,通常可保证获得最低的缺页率。但由于人们目前还无法预知一个进程在内存的若干个页面中,哪一个页面是未来最长时间内不再被访问的,因而该算法是无法实现的,但可以利用该算法去评价其它算法。

    (2)先进先出(FIFO)页面置换算法:该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单,只需把一个进程已调入内存的页面,按先后次序链接成一个队列,并设置一个指针,称为替换指针,使它总是指向最老的页面。但该算法与进程实际运行的规律不相适应,因为在进程中,有些页面经常被访问,比如,含有全局变量、常用函数、例程等的页面,FIFO 算法并不能保证这些页面不被淘汰。

    (3)最近最久未使用(LRU)置换算法:是选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间t。当需要淘汰一个页面时,选择现有也面中t值最大的,即最近最久未使用的页面予以淘汰。

    (4)Clock置换算法:LRU算法的近似实现,是把所有的页面都保存在一个类似钟面的环形链表中,一个表针指向最老的页面,当发生缺页中断时,算法首先检查表针指向的页面,如果它的R位是0就淘汰该页面,并把新的页面插入这个位置,然后把表针前移一个位置;如果R位是1就将R位置0并把表针前移一个位置,重复这个过程直到找到了一个R位为0的页面为止。如下图:



    3、系统抖动与Belady现象

    答:系统抖动:在请求分页存储管理中,从主存(DRAM)中刚刚换出(Swap Out)某一页面后(换出到Disk),根据请求马上又换入(Swap In)该页,这种页面频繁换出换入的现象,称为系统颠簸,也叫系统抖动。

    造成系统抖动的根本原因是置换算法选择不当,表面原因是缺页率高造成的。

    Belady现象:指在分页式虚拟存储器管理中,发生缺页时的置换算法采用FIFO( 先进先出 )算法时,如果对—个进程未分配它所要求的全部页面,有时就会出现分配的页面数增多但缺页率反而提高的异常现象。


    4、页面请求中的缺页率计算

    答:缺页率 = (页面置换次数+分配给该进程的物理块数)/要访问的页面总数;

    缺页数=页面置换次数+分配给该进程的物理块数;

    注意: 
    1)要访问的页面总数:不是数值最大,而是看要访问的总次数,例如某程序访问以下页面0、1、4、2、0、2、6、5、1、2、3、

    2、1、2、6、2、1、3、6、2,总共20个数,则要访问的页面总数是20,并不是6;

    2)由于进程开始时,都会给该进程分配一定数量的物理块,当物理块充足时,直接将要访问的页面添加进物理块中就好,并不算页面置换次数;

    3)页面置换次数:当前要访问的页面不在内存中,且,物理块已经被占满,没有物理块可用,就需要将物理块中的页面按照一定的算法将不用的页面换出内存,把要访问的页面换进内存中。

    技巧:在算缺页率时,可以假设分配给进程的物理块为0,则每进入一个页面就算一次缺页,这样就把分配给该进程的物理块数合并到页面置换次数中,方便记忆。当把物理块占完以后,再考虑要不要从物理块中换出内存。


    举例:

    若进程访问页面的次序是1、2、3、6、4、7、3、2、1、4、7、5、6、5、2、1,采用最佳置换算法,情况如下图:


    5、虚拟存储器

    答:虚拟存储器:由于常规内存的一次性(要求将作业全部装入内存后才能运行)和驻留性(作业装入内存后,就一直驻留在内存中,知道作业运行结

    束),难以满足大量作业要求运行的情况。虚拟存储器是一种借助于外存空间,从而允许一个进程在其运行过程中部分地装入内存的技术,剩

    余部分存储在外存,需要时就将其置换到内存。之所以采用虚拟存储管理方式,是因为程序执行时呈现局部性原理:

    1)空间局部性:一条指令的一次执行和下次执行,都集中在一个较短时间内;

    2)时间局部性:当前访问的数据和下次访问的数据,都集中在一个较小的区域内;

    虚拟存储器实现方法:请求分页机制和请求分段机制;

    虚存的硬件支持:1)内存;2)外存;3)地址变换机构:实现虚拟地址到实地址的地址变换。例如,在页式存储结构中,根据页号-块号对照表,将虚地址中的页号换成块号,得到实地地(物理地址)。

    替换算法:用来确认替换内存中的哪个页面,以便腾空部分内存,存放来自外存要调入的那部分内容。

    1)先进先出算法:替换掉最先调入主存的页面;

    2)LRU算法:替换最长时间不用的算法等。

    虚拟存储器的作用:提高内存运行效率,适合大容量作业运行;


    章节五、设备管理

    1、IO设备分类

    答:1)按共享属性分类:

    独占设备: 在一个用户作业未完成或退出之前,此设备不能分配给其他作业用。所有字符设备都是独享设备。如输入机、磁带机、打印机等。

    共享设备:指在同一段时间内允许多个进程同时访问的设备。典型的共享设备如磁盘。

    虚拟设备: 通过软件技术将独享设备改造成共享设备。例如:通过SPOOLing 技术将一台打印机虚拟成多台打印机。

    2)按传输速率分类:

    低速设备:键盘、鼠标、语音输入输出设备反人等;

    中速设备:打印机等;

    高速设备:存储设备如磁带机、磁盘机、光盘机等。

    3)按信息交换方式分类:

    块设备:主要用于存储信息,数据存取单位是块,如磁盘;

    字符设备:用于数据输入输出,数据传输单位是字符,如打印机;


    2、IO控制方式

    答:(1)程序控制

    CPU 向控制器发指令,启动I/O 设备,同时把状态寄存器中的状态标志置1 ,busy=1;然后不断地循环检测状态标志。

    如果busy=1, 说明I/O 设备忙,CPU 再进行下一轮检测; 

    如果busy=0, 说明I/O 操作结束,CPU 执行下一条指令。

    在程序I/O方式中,由于CPU的速度远远高于I/O设备,导致CPU的绝大部分时间都处于等待I/O设备完成而循环测试之中,造成了CPU的极大浪费。但是它管理简单,在要求不高的场合可以被采用。


    (2)中断控制 

    启动:由CPU根据进程的I/O请求发出一条I/O命令;此后CPU继续执行其它进程,即CPU与外设并行工作。I/O设备完成操作后,由

    控制器通过控制线向CPU发送一中断信号,由CPU检查I/O操作是否正确,若无错,便从数据寄存器中读出数据,写入指定内存单

    元。

    中断驱动方式在I/O设备输入数据的过程中,无需 CPU干预,可以使CPU与I/O设备并行工作。仅当输完一个数据时,才需 CPU

    花费极短的时间去进行中断处理。从而大大地提高了整个系统的资源利用率及吞吐量,特别是CPU的利用率,但中断控制仍然是以

    字符为传输单位。


    (3)DMA控制方式

    中断驱动I/O方式虽然大大提高了主机的利用率,但是它以字(节)为单位进行数据传送,每完成一个字(节)的传送,为了进一步

    减少CPU对I/O的干预,引入了直接存储器访问DMA(Direct Memory Access)控制方式。DMA(Direct Memory Access)引入,适

    应了一次传送大量数据的应用要求,尽量减少CPU对高速外设的干预,DMA控制方式以块为单位进行数据传送。

    DMA控制器的组成:命令/状态寄存器CR,内存地址寄存器MAR,数据寄存器DR,数据计数器DC;


    DMA方式下的数据传送过程可分为三个阶段:

    1) 预处理阶段:当进程要求设备输入数据时,CPU把准备存放输入数据的内存起始地址以及要传送的字节数分别送入DMAC中的内

    存地址寄存器和传送字节计数器。另外,还把控制状态寄存器中的中断允许位和启动位置成1,从而启动设备,开始进行数据输入。

    2) 数据传送阶段:发出数据传输要求的进程进入等待状态,进程调度程序调度其他进程占据CPU。DMAC不断地窃取CPU工作周

    期,执行数据传送的操作:向内存发出地址和控制信号,进行地址修改,对传送字的个数计数,直到所要求的字节全部传送完毕。 

    3) 后处理阶段:DMAC在传送完所有字节时,通过中断请求线发出中断信号。CPU在接收到中断信号后,转入中断处理程序进行后

    续处理。中断处理结束后,CPU返回到被中断的进程中,或切换到新的进程上下文环境中,继续执行。

    DMA方式起到代理cpu的功能,较之中断驱动方式,又是成百倍地减少了CPU对 I/O控制的干预,进一步提高了CPU与I/O设备的并行

    操作程度。


    (4) I/O通道控制方式

    I/O通道控制方式的引入,进一步减少CPU对I/O操作的干预,以多个块为单位进行数据传送,一次传送多组数据到多个不同的内存区

    域。

    通道程序:由一系列通道指令(通道命令)构成,通道指令与一般的机器指令不同,在每条指令中包含的信息较多每条指令都包

    含:操作码、内存地址、计数、通道程序结束位P、记录结束标志R。通道程序是在cpu执行I/O命令时通过设备管理程序产生的,传

    递给通道。

    由于外围设备的种类较多,且其传输速率相差很大,所以通道也具有多种类型。根据信息交换方式,可以把通道分成以下三种类型:(1)字节多路通道、(2)数组选择通道、(3)数组多路通道。

    通道工作原理:

    CAW----通道程序的内存起始地址,CCW----通道程序指令寄存器,CSW----存放通道程序结果的寄存器;

    CPU在执行用户程序时遇到I/O请求,操作系统根据该请求生成通道程序放入内存,并将该通道程序的首地址放入通道地址字

    CAW中。之后执行“启动I/O”指令,启动通道工作。通道接收到“启动I/O”指令后,从CAW中取出通道程序的首地址,并根据首地址取

    出第一条指令放入通道命令字CCW中,同时向CPU发回答信号,使CPU可继续执行其他程序,而通道则开始执行通道程序,与CPU

    并行完成I/O设备数据传输工作。

    通道程序指令先通过驱动转化然后通过控制器一起完成实际I/O,启动I/O设备,执行完毕后,如果还有下一条指令,则继续执行。

    当通道传输完成最后一条指令时停止工作,向CPU发I/O中断。CPU接收中断信号,执行中断子程序,从通道状态字CSW中取得有关

    通道状态信息,决定下一步做什么。


    3、IO通道控制方式

    答:通道是独立于CPU的、专门负责数据共享以及传输工作的处理单元,主要针对内存和外设通信和数据传输。

    I/O通道控制类似于DMA控制,I/O操作过程为:当CPU在执行主程序时遇到I/O请求,CPU启动在指定通道上选址的设备,一旦启动成功,通道开始控制设备进行操作,这时CPU就可以执行其他任务并与通道并行工作,直到I/O操作完成。当通道发出I/O操作结束中断时,CPU才响应并停止当前工作,转而处理I/O操作结束事件。

    可见,I/O通道控制方式在通道控制开始和结尾都需要CPU干预


    4、操作系统的IO软件层次问题

    答:IO软件层次从上到下依次为:用户级IO软件,与设备无关的操作系统软件,设备驱动程序,中断处理程序,硬件。

    例如:用户程序发出磁盘I/O 请求后,系统的正确处理流程一般是:用户程序→系统调用处理程序→设备驱动程序→中断处理程序。


    5、操作系统中断

    答:从中断事件的性质出发,中断可以分为两大类:

    强迫性中断事件:包括硬件故障中断,程序性中断,外部中断和输入输出中断等;

    自愿性中断事件:是由正在运行的进程执行一条访管指令用于请求系统调用而引起的中断,这种中断也称为"访管中断"。

    一般情况下,优先级的高低顺序依次为:硬件故障中断、自愿中断、程序性中断,外部中断和输入输出中断。

    自愿中断的断点是确定的,而强迫性中断的断点可能发生在任何位置。


    6、计算机读取缓存、内存和硬盘所用时间排序

    答: 首先速度最快的当然是缓存,接着消耗时间最少的是内存,最后是硬盘连续读取时间,即:缓存读取时间<内存读取时间<硬盘读取时间;

    缓存直接与cpu进行数据交互,这个是最快最直接的;当通过缓存寻找数据时发现数据在缓存中不存在这时需要通过,到内存中去寻找,但是内存的传输速度就没有缓存这么快了,所以内存读取数据的时间消耗要大于缓存;最慢的硬盘读取时间主要包括:寻道时间, 数据传输时间,还有旋转时间三部分时间组成。


    7、操作系统引入缓冲技术的作用

    答:引入缓冲的主要原因包括:1)缓和CPU与I/O设备间速度不匹配的矛盾,减少对CPU的中断频率,放宽对中断响应时间的限制,提高CPU和I/O设

    备之间的并行性;例如,CPU 输出数据的速度远远高于打印机的打印速度,为解决这一矛盾,一般采用缓冲技术

    2)减少访问主存或CPU中断次数。


    8、计算机存储中的双缓冲区与单缓冲区

    答:缓冲区不在外存,计算机最大的缓冲区在内存中,还有部分在CPU中。

    区别:

    单缓冲:假定从磁盘把一块数据输入到缓冲区的时间为T,操作系统将该缓冲区中的数据传送到用户区的时间为M,而CPU对这一块数据处理的时间为 C。由于T和C是可以并行的,当T>C时,系统对每一块数据的处理时间为M十T,反之则为M+C,故可把系统对每一块数据的处理时间表示为Max(C, T)+M;如图:


    双缓冲:双缓冲状态下,磁盘上的一个数据块中的信息输入到一个双缓冲区的时间为T1,操作系统将该缓冲区中的数据传送到用户
    区的时间为M,CPU对这一块数据处理的时间为 C。由于T和C是可以并行的,同时由于双缓冲的原因,M也是可以并行的,所以最后的结果是max(T,M,C)。如图:


    9、ROM与RAM

    答:RAM是易失性的,一旦掉电,则所有信息全部丢失;ROM是非易失性的,其信息可以长期保存,常用于存放一些固定用的数据和程序,如计算机的自检程序、BIOS、游戏卡中的游戏,等等;一般Cache采用高速的SRAM制作,比ROM速度快很多;RAM需要刷新,而ROM不需要刷新。


    10、CPU不可以直接访问外存数据

    答:CPU不能对外存上的数据进行直接访问,必须先将外存上的数据调入内存。


    11、固态硬盘与机械硬盘相比的优势

    答:读写快、功耗低、耐碰撞不易损坏、寿命长(最后一条存疑)。


    12、磁盘组成与磁盘访问

    答:磁盘组成:磁盘上的数据都存放于磁道上,磁道就是磁盘上的一组同心圆,其宽度与磁头的宽度相同。而磁道中是扇区,扇区是磁盘存储基本单位,即块。一般磁盘容量计算如下:

    存储容量 = n×t×s×b;

    其中n为保存数据的总盘面数(一个盘片分两面);t为每面磁道数;s为每道的扇区数;b为每个扇区存储的字节数(512B)。

    磁盘分类:软盘与硬盘分类;单片盘与多片盘分类;固定磁头与移动磁头分类;关于固定磁头与移动磁头,介绍如下:

    1)固定磁头磁盘

    磁头用于读取磁道中的扇区存储信息,故固定磁头就是每个磁道都有一个磁头,,透过这些磁头可以访问所有的磁道,且可以并行进行读写,提高IO速度。该模式一般应用于大容量磁盘上。

    2)移动磁头磁盘

    每个盘面仅配一个磁头,该磁头可以移动寻道,以串行方式读写,所以IO速度较慢。但由于结构简单常用语中小容量磁盘设备中。

    移动头磁盘访问时间

    访问时间由三部分组成:寻道时间Ts、旋转延迟时间、传输时间Tt

    寻道时间:启动磁头移动的时间与将磁头移动到指定磁道的时间之和,Ts=m*n+s,其中m是磁头移动一个磁道的时间,n为磁道数,s为启动磁头移动时间;

    旋转延迟时间:将扇区旋转到磁头下面的时间;

    传输时间:指将数据从磁盘读出或向磁盘写入数据所经历的时间。


    13、最短寻道时间优先算法

    答:最短寻道时间优先算法(SSTF——Shortest Seek Time First) :该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。


    14、磁盘调度算法

    答:1)先来先服务FCFS

    该算法根据进程请求访问磁盘的先后顺序进行调度;

    2)最短寻道时间优先SSTF

    该算法要求访问的磁道与当前磁头所在磁道距离最近,以使每次寻到时间最短。

    3)扫描算法SCAN

    该算法不仅考虑磁道最近,还考虑磁头移动方向是否和最近磁道一致,否则不遵循最近磁道距离原则。有点类似电梯调度算法。

    4)循环扫描算法CSCAN

    5)N-Step-SCAN和FSCAN调度算法

    15、设备分配中所需的数据结构

    答:系统中设备供所有进程共享,为防止无序竞争,设备都由系统统一分配。设备分配时所需的数据结构有:设备控制表、控制器控制表、通道控制表和系统设备表等。

    16、可变分区存储管理之紧凑技术

    答:移动所有的占用区域,使所有的空闲碎片区合并成一片连续区域,这一技术称为移动技术(紧凑技术)。所谓碎片是指内存中出现的一些零散的小

    空闲区域,由于碎片都很小,无法再利用。如果内存中碎片很多,将会造成严重的存储资源浪费。解决碎片的方法是移动技术,除了可解决碎片问题还

    使内存中的作业进行扩充。当然,移动带来系统开销加大,并且当一个作业如果正与外设进行I/O时,该作业是无法移动的。


    章节六、文件管理

    1、Unix/Linux系统的目录结构

    答:Unix/Linux系统的目录是带链接树形目录结构,带链接树形目录结构又称非循环图目录结构,它是指访问一文件(或目录)可以有多条路径。一般常说UNIX的文件系统是树形结构,其实是指带链接的树形结构,而不是纯树形目录结构。

    2、Linux下对文件的操作

    答:Linux下对文件操作有两种方式:系统调用(system call)和库函数调用(Library functions)。系统调用实际上就是指最底层的一个调用,在linux程序设计里面就是底层调用的意思,面向的是硬件。而库函数调用则面向的是应用开发的,相当于应用程序的api。

    简明的回答是:函数库调用是语言或应用程序的一部分,而系统调用是操作系统的一部分。

    3、在FAT文件系统中,基本的文件分配单位是什么?

    答:FAT文件系统基本的文件分配单位是

     :系统文件分配的基本单位,一般为2的n次方个扇区(由文件系统决定);

    扇区: 硬盘不是一次读写一个字节,而是一次读写一个扇区(512个字节),扇区就是硬盘读取单元块 ;

    簇的大小选择,例如U盘的FAT32模式下,分配单元——簇的大小选择:
    簇是分配给U盘的最小单元,大了不适合存储小文件,比如你分配了16K的,你只存一个1K的TXT的话,这个16K就被占用了,所以又点浪费空间。但是如果你存的是5M左右的歌曲,那么存的文件就比较快,而且整体性好点。


    4、文件索引结

    答:为了提高文件的检索效率,可以采用索引方法组织文件。采用索引这种结构,逻辑上连续的文件可以存放在若干不连续的物理块中,但对于每个文件,在存储介质中除存储文件本身外,还要求系统另外建立一张索引表,索引表记录了文件信息所在的逻辑块号和与之对应的物理块号。索引表也以文件的形式存储在存储介质中,索引表的物理地址则由文件说明信息项给出。

    在很多情况下,有的文件很大,文件索引表也就较大。如果索引表的大小超过了一个物理块,可以采用间接索引(多重索引),也就是在索引表所指的物理块中存放的不是文件地址映射信息本身,而是装有这些信息的物理块地址。

    索引结构既适用于顺序存取,也适用于随机存取,并且访问速度快,文件长度可以动态变化。索引结构的缺点是由于使用了索引表而增加了存储空间的开销。


    5、文件逻辑结构

    答:文件分为两大类:有结构文件(即记录式文件),无结构文件(即流式文件)。

    大量的数据结构和数据库采用有结构文件;大量的源程序,可执行程序,库函数等采用无结构文件,其长度以字节为单位,对流式文件的访问是利用读

    写指针来指出下一个要访问的字符。

    有结构的文件分为:定长和不定长两类;

    定长又分为:定长记录,变长记录;

    变长记录文件根据文件组织方式的不同又分为:顺序文件,索引文件,索引顺序文件。


    6、数据项、记录和文件在文件系统中的关系

    答:文件系统按层次有个底到高为:数据项—>记录—>文件,后者是由前者的集合组成;


    7、顺序文件

    答:顺序文件有两种结构:串结构和顺序结构;

    串结构:按存入时间顺序决定;

    顺序结构:按关键字如文件名的字母顺序决定。


    8、Linux系统的i节点介绍

    答:i节点也叫索引节点,是对文件进行控制和管理的一种数据结构,每一个文件都有自己的i节点,每个i节点都有一个唯一的i节点号。i节点结构如下:

    struct dinode

    {
    ushort di_mode; /*文件类型+用户权限*/
    short di_nlink; /*文件链接数*/
    ushort di_uid; /*属主用户id*/
    ushort di_gid; /*属主用户组id*/
    off_t di_size; /*文件大小*/
    char di_addr[40]; /*文件数据区起点地址*/
    time_t di_atime; /*最后访问时间*/
    time_t di_mtime; /*最后修改时间*/
    time_t di_ctime; /*创建时间*/
    };
    从上面这个结构可以看出以下一些信息:
    1、i节点保存了文件的属性和类型、存放文件内容的物理块地址、最近一次的存取时间、最近一次的修改时间、创建此文件的时间。
    2、i节点中没有记录文件名字;

    linux下,i节点其实就是可以这么认为,把i节点看作是一个指向磁盘上该文件存储区的地址。只不过这个地址我们一般是没办法直接使用的,而是

    通过文件名来间接使用的。事实上,i节点不仅包含了文件数据存储区的地址,还包含了很多信息,比如数据大小,等等文件信息。但是i节点是不保存

    文件名的。文件名是保存在一个目录项中。每一个目录项中都包含了文件名和i节点。

    我们可以通过一个图来看看目录项,i节点,文件数据四者之间的关系:



    下面是关于i节点、硬链接、软链接的总结:

    1)i节点

    1、inode是一个数值,通过ls -i 命令可以查看某文件的inode值;

    2、本质上inode是一个索引号,也可以理解为一个指针,指向唯一的一个文件,准确的是说是指向一个文件的存储区,该存储区是属于该文件的一部分,不一定是全部;

    3、因此,有两个或多个inode指向同一个文件的情况。即inode和文件不是一一对应的关系,是n对1的关系(n>=1)

    4、当文件拷贝时,理所当然的会创建新的inode,而且也复制了数据区。尽管两个文件完全一样。即:复制文件时,产生两个完全独立的文件。


    2)硬链接:为原文件创建一个新的文件名,但本质中只增加了一个目录项,并使用与原来相等的inode,指向原文件的区域。数据

    区为两个名字共享。

    使用限制:源文件和链接文件必须在同一个文件系统内,且目录文件不能创建硬链接。

    命令:ln a b // 给a创建链接文件b

    可以使用ls -i查看两个inode是完全一样的。

    同时注意连接计数count。count的意义对于文件来说是硬链接的个数,对于目录,一般(count-2)为目录包含的子文件个数。

    注意:两者的权限也是完全一样的。对其中一个进行读写操作,另外一个也会更新。但删除其中一个,只会删除目录项,不会删除

    存储区数据。另外一个文件的使用和操作完全不受影响。除非count-1结果0,才将数据区删除。

    作用:节省空间,两个文件能同步更新,防止重要文件被“误删”。

    注意:软驱 光驱等都是独立的文件系统。不同文件系统的inode没有任何联系。系统通过设备号和inode号确定一个文件。

    inode是文件系统内的一个概念。但Linux可以支持多种不同的文件系统。其实Linux提供了一个虚拟文件系统VFS,是实际系统上层

    的一个接口软件。因此inode是只存在于内存的数据结构中。只有linux量身定制的ext2文件系统是具有实际意义的inode和目录项结

    构。

    3)软链接:也叫符号链接。本质是创建一个新的文件,保存源文件的路径名。因此inode和源文件的inode是不一样的。使用没有文

    件系统的限制,也没有文件和目录的限制。

    命令:ln -s a b

    注意:产生的文件权限和源文件是不一样的。由于软链接使用比较灵活,可能断链,也可以自循环,往往需要多次查找增加文件操

    作的步骤而降低效率。尽量少用,并避免出现循环。

    注意:删除文件时,如果源文件被删除,即便只是硬链接被删除,存储区没有被删,本文件也会失效。因为它是对文件名而言的。


    9、Linux中的makefile文件

    答:makefile文件保存了编译器和连接器的参数选项,还表述了所有源文件之间的关系(源代码文件需要的特定的包含文件,可执行文件要求包含的目标文件模块及库等)。创建程序(make程序)首先读取makefile文件,然后再激活编译器,汇编器,资源编译器和连接器以便产生最后的输出,最后输出并生成的通常是可执行文件。makefile文件实现了编译流程的规定,即实现了编译自动化,只需要调用make命令就可根据该文件实现编译。Makefile里主要包含了五个东西:显式规则、隐晦规则、变量定义、文件指示和注释。



    章节七、操作系统接口

    1、Shell环境中的预定义变量

    答:预定义变量和环境变量相类似,也是在Shell一开始时就定义了的变量。所不同的是,用户只能根据Shell的定义来使用这些变量,而不能重定义它。所有预定义变量都是由$符和另一个符号组成的,常用的Shell预定义变量如下表所示:

    判断上一个命令是否执行成功:[$? -eq 0]; echo True;


    2、操作系统中应用程序和用户提供的接口是什么?

    答:内核对所有应用程序和用户提供的接口就是系统调用;注意,一些系统调用是可以被中断的。


    3、命令后台运行

    答:例如sh test.sh要后台运行,有3种方式:

    ①在命令末尾添加取地址符:sh test.sh&;

    ②使用nohup命令和&的组合,如:nohup sh test.sh&;nohup命令会忽略SIGHUP信号,从而终端窗口退出时不会影响到后台作业;

    ③通过ctrl+z;bg等一系列的命令,将已经在前台运行的作业放到后台执行。如果一个作业已经在前台执行,可以通过ctrl+z将该作业放到后台并挂起。然后通过jobs命令查看在后台执行的作业并找到对应的作业ID,执行bg %n(n为通过jobs查到的作业ID)唤醒该作业继续执行。


    章节八、其他

    1、计算机为什么要使用内存对齐机制?

    答:(1)、平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,

    否则抛出硬件异常。

    (2)、性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。访问未对齐的内存,处理器需要作两次内存访问,而对齐的内存访问仅需要一

    次访问。(提高对数据的读取效率,以空间换时间)


    2、操作系统的交换分区大小

    答:系统交换分区大小设置一般是计算机物理内存的2倍左右;


    3、内核对象

    答:内核对象是操作系统为一些系统级的对象(像进程,线程,信号量)维护的一些数据结构。这些数据构保存了与系统级对象相关的系统级信息。操作系统中所有内核对象是保存在一块内存空间中,系统上所有的进程都共享这一块内存空间。

    (1)内核对象的访问

    ①内核对象不能被应用程序直接访问,应用程序只能通过操作系统提供的API对他们进行操作;

    ②多个进程可以共享访问同一个内核(对象通过给内存对象命名即可以实现内核对象在多个进程中共享);

    ③当应用程序创建或打开一个内核对象时,系统API会返回给应用程序一个句柄(该句柄是进程级别的),然后应用程序便可以使用该句柄来指定对该内核对象进行操作。该句柄是进程级别的,因此同一个内核对象在两个进程中的句柄不会一样;

    (2)内核对象的分类

    分类有:存取符号对象、事件对象、文件对象、文件映射对象、I/O完成端口对象、作业对象、信箱对象、互斥对象、管道对象、进程对象、信标对象、线程对象和等待计时器对象等。这些对象都是通过调用函数来创建的。


    4、IO多路复用机制——select机制和epoll机制

    答:(1)作用

    主要意义 :在不使用多进程或多线程的情况下,实现对多个客户端IO请求的处理,从而减少CPU开销,提高处理效率。

    如:当需要读两个以上的I/O的时候,如果使用阻塞式的I/O,那么可能长时间的阻塞在一个描述符上面,另外的描述符虽然有数据但是不能读出来,这样实时性不能满足要求,大概的解决方案有以下几种:

    ①同步阻塞IO,不采用特别处理方法,仍然一个个处理,这样不可以同时处理多个请求,如下:


    ②同步不阻塞IO,写一个轮询函数,检测到有请求数据准备就绪就跳出轮询进行处理,否则继续轮询,这样就可以同时处理多个请求,如下:


    ③使用多进程或者多线程,但是这种方法会造成程序的复杂,而且对与进程与线程的创建维护也需要很多的开销(Apache服务器就是用的子进程的方式,优点可以隔离用户);

    ④I/O多路复用,所谓I/O复用,是指根据事件驱动原理,同时监视多个IO状态,当一个或多个I/O条件满足(可读、能写或出现异常)时,立即通知进程,从而正确并高效地对它们进行处理。

    (2)select机制(IO多路复用)

    select机制的作用:实现一个进程能同时等待多个文件描述符,而这些文件描述符(套接字描述符)其中的任意一个条件事件(可读、可写或异常)发生,select()函数就可以返回。

    用以下select机制的原理图介绍:

     

    select机制解释:

           当用户进程调用了select,则当前进程会被block。同时所有的socket请求都在select中阻塞,且select负责监视所有的socket,当任何一个socket数据就绪事件发生,select函数就会返回。这个时候用户进程再调用read操作,将数据从kernel拷贝到用户进程。

    针对上述select机制解释select的特点:

    1)select/poll每次都需要重复传递全部的监听fd进来,涉及用户空间和内核直接的数据拷贝(即:每处理一次就要把已处理的请求剔除后,拷贝剩下的请求到select中);

    2)fd事件回调函数是pollwake,只是将本进程唤醒,本进程需要重新遍历全部的fd检查事件,然后保存事件,拷贝到用户空间,函数返回(select返回只是唤醒进程,获取fd状态还是由进程自己遍历并拷贝);

    3)每次循环都是对全部的监测的fd进行轮询检测,可能发生事件的fd很少,这样效率很低;

    4)select/poll返回时,会将该进程从全部监听的fd的等待队列里移除掉,这样就需要select/poll每次都要重新传入全部监听的fd,然后重新将本进程挂载到全部的监测fd的等待队列,大量重复劳动,效率很低。

    select适用场景:当有很多请求同时发生时,适用select机制,若请求较少使用select机制反而会造成效率较低,因为select机制有两次系统调用,而同步阻塞IO只有一次。

    (3)epoll机制

    在 select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一 个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个注册的文件描述符,当进程调用epoll_wait() 时便得到通知(此处去掉了遍历文件描述符,而是通过监听回调的的机制,这正是epoll的优势所在)。epoll触发方式:epoll有水平触发和边缘触发两种就绪通知模式,默认为LT(水平触发);

    特点:

    1)每次累加添加,不需要每次传入全部的监测fd。
    2)每个fd只将本进程挂载到自己的等待队列一次,直到该fd被从epoll移除,不需要重复挂载。
    3)fd事件回调函数是ep_epoll_callback,该函数将发生事件的fd加入到epoll专门的就绪队列rdllist中,同时唤醒本进程。
    4)本进程不需要遍历每一个fd去监测事件是否发生,而只需要判断epoll中的就绪队列rdllist是否为空即可。
    5)epoll返回时,只返回就绪队列rdllist中的项,避免了无关项的操作,应用层也就不需要再次重复遍历。
    6)epoll内部使用红黑树存储监测fd,支持大量fd的快速查询、修改和删除操作。

    (4)IO多路复用中select和epoll的区别:

    ①select支持的并发数有限,epoll支持并发数无上限。因为select内部的fd存储由数组实现,而epoll内部的fd存储由红黑树实现;

    ②select效率会随着并发数增多而下降,epoll则不会。因为select是通过遍历所有的fd来判断哪个fd有事件发生,所以fd数量增多遍历时间越长,而epoll是通过判断就绪队列是否为空来判断事件发生与否并且只返回就绪项,fd增多并不影响;

    ③select在实现内核传递fd消息至用户空间时需要内存拷贝,而epoll是用共享内存实现的,避免了一些不必要的重复拷贝。


    (5)epoll与select/poll机制的相同点:

    ①主要监测流程是一样的,都需要将当前进程挂载到对应fd的队列中去。如果fd有事件发生,调用挂载的回调函数,该回调函数基本的作用是唤醒本进程。

    ②主事件检测循环是一样的,循环检测是否有事件发生,有则处理事件后返回;没有则调用schedule_timeout睡眠一会。不同的是,select/poll直接检测每个fd,而epoll只需检测就绪队列rdllist是否有数据即可。

    (6)epoll针对select/poll的缺点进行的修改,但在并发不多时select不见得比epoll效率低。

    其他相关信息参看:http://blog.csdn.net/xiongchao99/article/details/74524807#t5



    展开全文
  • 计算机操作系统 一.操作系统引论 1.操作系统的目标和功能 目标 方便性 有效性 提高系统资源利用率 提高系统吞吐量 可扩充性 开放性 作用 OS作为用户与计算机硬件系统之间的接口 ...
  • 计算机组成原理、计算机操作系统、计算机网络 一、计算机发展简史
  • 计算机操作系统-操作系统的特征

    千次阅读 2019-01-14 18:18:50
    操作系统的特征 并发 共享 虚拟 异步 ...指的是计算机操作系统中同时存在着多个运行着的程序。 对于单核CPU,同一个时刻只能执行一个程序,当有多个程序需要执行时,操作系统就会采取并发的...
  • 计算机操作系统原理

    千次阅读 2018-09-29 16:42:50
    最近准备i面试,抽时间回顾一下计算机操作系统原理. -2018.10.1 1、硬件基础 计算机的构成: 处理器(CPU):主要包括运算器、控制器 内存(主存储器) 输入输出设备 详细的讲,CPU内部包括: 存储器地址寄存器...
  • 计算机操作系统(第三版)

    千次下载 热门讨论 2013-08-13 17:19:05
    计算机操作系统》可作为计算机硬件和软件以及计算机通信专业的本科生教材,也可作为从事计算机及通信工作的相关科技人员的参考书。 目录 第一章 操作系统引论 1.1 操作系统的目标和作用 1 1.1.1 操作系统的...
  • 计算机操作系统考试习题

    千次阅读 2019-07-26 08:06:18
    计算机操作系统考试习题 1.设计现代OS的主要目标是什么? 答:(1)方便性(2)有效性(3)可扩充性(4)开放性(兼容性) 2.OS的作用可表现为哪几个方面? 答:(1)OS作为用户与计算机硬件系统之间的接口。 ...
  • 计算机操作系统简介 目标 了解操作系统的发展历史 知道 Linux 内核及发行版的区别 知道 Linux 的应用领域 任何计算机都必须在加载相应的操作系统之后,才能构成一个可以运转的、完整的计算机系统。操作系统的...
  • 计算机操作系统复习资料

    千次阅读 2018-03-18 20:45:34
    · 第一讲o 什么叫操作系统§ 计算机操作系统是指控制和管理计算机的软、硬件资源,合理组织计算机的工作流程,方便用户使用的程序集合。o 操作系统的三个作用 管理者 ……虚拟机§ 计算机系统软硬件资源的...
  • 计算机操作系统发展史

    千次阅读 2016-09-18 12:24:46
    在当下这个互联网时代,计算机已经成为了人类的生活必需品,而计算机操作系统的发展历史,也就代表着计算机的发展历史,今天,我就向大家分享一下操作系统的发展史。 无操作系统时代 一定很多人非常的惊讶,没有...
  • 计算机操作系统课后习题答案

    千次阅读 多人点赞 2019-04-14 17:16:19
    计算机操作系统(第四版)课后习题答案(完整版) 第一章 1.设计现代OS的主要目标是什么? 答:(1)有效性 (2)方便性 (3)可扩充性 (4)开放性 2.OS的作用可表现在哪几个方面? 答:(1)OS作为用户与计算机...
  • 计算机操作系统-考研复试面试题-汇总大合集

    万次阅读 多人点赞 2020-03-14 19:33:58
    写在前面的话:本文重要涉及计算机操作系统的面试题,收集了网上各种常见面试题,加以整理,本人操作系统学习的不太扎实,如有写的不妥的欢迎指正,(WeChat:YEZHENGJIE) 主要针对计算机复试,希望复试过过过。 ...
  • 计算机操作系统学习笔记

    千次阅读 2018-04-06 16:16:43
    学习教材是《计算机操作系统》第三版操作系统基本特征一、并发性两个概念:并发与并行。并发指的是在一段时间内发生了两个或者多个事件。并行指的是同一时刻发生了两个或者多个事件。对于多处理机系统,可以实现并行...
  • 计算机操作系统-操作系统的定义

    千次阅读 2019-01-14 12:12:57
    操作系统层往两侧看:负责管理协调硬件、软件等计算机资源的工作 从上往下看:为上层的应用程序和用户提供简单易用的服务 从下往上看:操作系统系统软件,而不是硬件 定义 Operating System是指控制和管理整个...
  • 从六大角度理解计算机操作系统

    千次阅读 2019-04-06 20:03:51
    计算机操作系统】 操作系统的概念 操作系统(Operating System),简称OS OS是计算机系统最基础的系统软件,管理软硬件资源、控制程序执行,改善人机界面,合理组织计算机工作流程,为用户使用计算机提供良好运行...
  • 思维导图-深入理解计算机操作系统

    千次阅读 2017-09-29 21:43:49
    深入理解计算机操作系统
  • 计算机操作系统(第四版)》知识点归纳

    万次阅读 多人点赞 2016-11-06 19:52:34
    计算机操作系统(第四版)》的前7章知识点归纳
  • 计算机操作系统-操作系统启动过程

    千次阅读 2019-01-06 14:19:44
    操作系统的两种模式 1.实模式(实地址模式) 计算机刚加电时处于实模式下 程序按照8086寻址方式访问0h-FFFFFh(1MB)空间 寻址方式:物理地址(20位)=短地址:偏移地址 CPU单任务运行 2.保护模式 计算机启动成功...
  • 计算机操作系统下载重装

    千次阅读 2018-06-17 07:13:49
    计算机操作系统下载重装  作者:任尚益    ...
  • 1、操作系统的基本概念 计算机系统自上而下可粗分为四个部分:硬件、操作系统、应用程序和 用户(这里的划分与计算机组成原理的分层不同)。操作系统管理各种计算机硬件,为应用程序提供基础,并充当计算机硬件与...
  • 计算机操作系统原理与设计.pdf 下载
  • 计算机操作系统操作系统(第四版)汤小丹版 思维导图(第一章到第七章)
  • 计算机操作系统--PV操作详细说明

    千次阅读 2012-10-23 13:49:38
    计算机操作系统--PV操作详细说明   在计算机操作系统中,PV操作是进程管理中的难点。 首先应弄清PV操作的含义:PV操作由P操作原语和V操作原语组成(原语是不可中断的过程),对信号量进行操作,具体定义如下: ...
  • 计算机操作系统基础

    千次阅读 2018-01-17 09:22:32
    操作系统基础  3.1 操作系统的定义  是计算机硬件的第一级扩充,是机器的管理者,控制和管理计算机硬件和软件资源、合理的组织计算机工作流程以及方便用户使用计算机的一个大型系统文件。  3.2 操作系统的发展...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,388
精华内容 36,155
关键字:

计算机操作系统