操作系统报告(优选15篇)

操作系统报告 篇1

什么是操作系统

手机操作系统一般只应用在高端智能化手机上。目前，在智能手机市场上，中国市场仍以个人信息管理型手机为主，随着更多厂商的\'加入，整体市场的竞争已经开始呈现出分散化的态势。从市场容量、竞争状态和应用状况上来看，整个市场仍处于启动阶段。

目前应用在手机上的操作系统主要有PalmOS、Symbian、Windows CE和Linux四种。

相关术语：

1、Palm OS操作系统

2、Symbian操作系统

3、Windows CE操作系统

4、Linux操作系统

操作系统报告 篇2

1、什么是进程(Process)和线程(Thread)?有何区别?

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而进程则是处于动态条件下由操作系统维护的系统资源管理实体。

2、Windows下的内存是如何管理的?

Windows提供了3种方法来进行内存管理：虚拟内存，最适合用来管理大型对象或者结构数组;内存映射文件，最适合用来管理大型数据流(通常来自文件)以及在单个计算机上运行多个进程之间共享数据;内存堆栈，最适合用来管理大量的小对象。

Windows操纵内存可以分两个层面：物理内存和虚拟内存。

其中物理内存由系统管理，不允许应用程序直接访问，应用程序可见的只有一个2G地址空间，而内存分配是通过堆进行的。对于每个进程都有自己的默认堆，当一个堆创建后，就通过虚拟内存操作保留了相应大小的地址块(不占有实际的内存，系统消耗很小)。当在堆上分配一块内存时，系统在堆的地址表里找到一个空闲块(如果找不到，且堆创建属性是可扩充的，则扩充堆大小)，为这个空闲块所包含的所有内存页提交物理对象(在物理内存上或硬盘的交换文件上)，这时就可以访问这部分地址。提交时，系统将对所有进程的内存统一调配，如果物理内存不够，系统试图把一部分进程暂时不访问的页放入交换文件，以腾出部分物理内存。释放内存时，只在堆中将所在的页解除提交(相应的物理对象被解除)，继续保留地址空间。

如果要知道某个地址是否被占用/可不可以访问，只要查询此地址的虚拟内存状态即可。如果是提交，则可以访问。如果仅仅保留，或没保留，则产生一个软件异常。此外，有些内存页可以设置各种属性。如果是只读，向内存写也会产生软件异常。

3、Windows消息调度机制是?

A)指令队列;B)指令堆栈;C)消息队列;D)消息堆栈

答案：C

处理消息队列的顺序。首先Windows绝对不是按队列先进先出的次序来处理的，而是有一定优先级的。优先级通过消息队列的状态标志来实现的。首先，最高优先级的是别的线程发过来的消息(通过sendmessage);其次，处理登记消息队列消息;再次处理QS_QUIT标志，处理虚拟输入队列，处理wm_paint;最后是wm_timer。

4、描述实时系统的基本特性

在特定时间内完成特定的任务，实时性与可靠性。

所谓“实时操作系统”，实际上是指操作系统工作时，其各种资源可以根据需要随时进行动态分配。由于各种资源可以进行动态分配，因此，其处理事务的能力较强、速度较快。

5、中断和轮询的特点

对I/O设备的程序轮询的方式，是早期的计算机系统对I/O设备的一种管理方式。它定时对各种设备轮流询问一遍有无处理要求。轮流询问之后，有要求的，则加以处理。在处理I/O设备的要求之后，处理机返回继续工作。尽管轮询需要时间，但轮询要比I/O设备的速度要快得多，所以一般不会发生不能及时处理的问题。当然，再快的处理机，能处理的输入输出设备的数量也是有一定限度的。而且，程序轮询毕竟占据了CPU相当一部分处理时间，因此，程序轮询是一种效率较低的方式，在现代计算机系统中已很少应用。

程序中断通常简称中断，是指CPU在正常运行程序的过程中，由于预先安排或发生了各种随机的内部或外部事件，使CPU中断正在运行的程序，而转到为响应的服务程序去处理。

轮询――效率低，等待时间很长，CPU利用率不高。

中断――容易遗漏一些问题，CPU利用率高。

6、什么是临界区?如何解决冲突?

每个进程中访问临界资源的那段程序称为临界区，每次只准许一个进程进入临界区，进入后不允许其他进程进入。

(1)如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入;

(2)任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区，则其它所有试图进入临界区的进程必须等待;

(3)进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区;

(4)如果进程不能进入自己的临界区，则应让出CPU，避免进程出现“忙等”现象。

7、说说分段和分页

页是信息的物理单位，分页是为实现离散分配方式，以消减内存的外零头，提高内存的利用率;或者说，分页仅仅是由于系统管理的需要，而不是用户的需要。

段是信息的逻辑单位，它含有一组其意义相对完整的信息。分段的目的是为了能更好的满足用户的需要。

操作系统报告 篇3

操作系统实习报告样本

图1  地址转换模拟算法 如果作业依次执行的指令序列为：  操作 页号 单元号 操作 页号 单元号 + 0 070 移位 4 053 + 1 050 + 5 023 2 015 存 1 037 存 3 021 取 2 078 取 0 056 + 4 001 - 6 040 存 6 084  运行设计的地址转换程序，显示或打印运行结果。因仅模拟地址转换，并不模拟指令的执行，故可不考虑上述指令序列中的操作。第二题：用先进先出（FIFO）页面调度算法处理缺页中断。[设计思路、数据结构、流程图]：(1) 在分页式虚拟存储系统中，当硬件发出“缺页中断”后，引出操作系统来处理这个中断事件。如果主存中已经没有空闲块，则可用FIFO页面调度算法把该作业中最先进入主存的一页调出，存放到磁盘上。然后再把当前要访问的页装入该块。调出和装入后都要修改页表中对应页的标志。(2) FIFO页面调度算法总是淘汰该作业中最先进入主存的那一页，因此可以用一个数组来表示该作业已在主存的页面。假定作业被选中时，把开始的m个页面装入主存，则数组的元素可定为m个。例如：P[0]，P[1]…，P[m-1]其中每一个P[i] (I=0, 1, …, m-1) 表示一个在主存中的页面号。它们的初值为：P[0]： =0,  P[1]： =1,  …,  P[m-1]： =m-1用一指针K指示当要装入新页时，应淘汰的页在数组中的位置，K的初值为“0”。当产生缺页中断后，操作系统选择P[k]所指出的页面调出，然后执行：P[k]： =要装入页的页号k： = (k+1) mod m再由装入程序把要访问的一页信息装入到主存中。重新启动刚才那条指令执行。(3) 编制一个FIFO页面调度程序，为了提高系统效率，如果应淘汰的页在执行中没有修改过，则可不必把该页调出（因在磁盘上已有副本）而直接装入一个新页将其覆盖。因此在页表中增加是否修改过的标志，为“1”表示修改过，为“0”表示未修改过，格式为：  页号 标志 主存块号 修改标志 在磁盘上的位置                          由于是模拟调度算法，所以，不实际地启动调出一页和装入一页的程序，而用输出调出的页号和装入的页号来代替一次调出和装入的过程。

把第一题中程序稍作改动，与本题结合起来，FIFO页面调度模拟算法如图2。 图2  FIFO页面调度模拟算法 (4) 如果一个作业的副本已在磁盘上，在磁盘上的存放地址以及已装入主存的页和作业依次执行的指令序列都同第一题中（4）所示。于是增加了“修改标志”后的初始页表为：  页号 标志 主存块号 修改标志 在磁盘上的位置 0 1 5 0 011 1 1 8 0 012 2 1 9 0 013 3 1 1 0 021 4 0   0 022 5 0   0 023 6 0   0 121  按依次执行的指令序列，运行你所设计的程序，显示或打印每次调出和装入的页号，以及执行了最后一条指令后的数组P的值。(5) 为了检查程序的正确性，可再任意确定一组指令序列，运行设计的程序，核对执行的结果。第三题：用最近最少用（LRU）页面调度算法处理缺页中断。[设计思路、数据结构、流程图]：(1) 在分页式虚拟存储系统中，当硬件发出“缺页中断”后，引出操作系统来处理这个中断事件。如果主存中已经没有空闲块，则可用LRU页面调度算法把该作业中距现在最久没有被访问过的一页调出，存放到磁盘上。然后再把当前要访问的页装入该块。调出和装入后都要修改页表中对应页的标志。(2) LRU页面调度算法总是淘汰该作业中距现在最久没被访问过的那页，因此可以用一个数组来表示该作业已在主存的页面。数组中的第一个元素总是指出当前刚访问的页号，因此最久没被访问过的页总是由最后一个元素指出。如果主存只有四块空闲块且执行第一题中提示（4）假设的指令序列，采用LRU页面调度算法，那么在主存中的页面变化情况如下：  3   0   6   4   5   1   2   4   6 2   3   0   6   4   5   1   2   4 1   2   3   0   6   4   5   1   2 0   1   2   3

操作系统报告 篇4

实训一 DDNS 服务

实训目的

目的：

(1)了解linux所提供的DDNS动态DNS更新服务是DHCP服务与DNS 服务相结合，实现动态更新DNS区域数据库文件内容。

(2) 熟练掌握 DDNS 服务配置的基本功能。

DDNS是动态DNS更新服务，是DHCP服务与DNS服务相结合，实现动

态更新DNS区域数据库文件内容的一项综合服务。简单的说就是如何为DHCP

客户机在DNS区域数据库中建立资源记录，并能及时随着DHCP客户机IP地

址的变化而动态更新相应的资源记录。

实训步骤

实现DDNS服务的步骤可以分为3部分：一是生成动态更新密钥;二是配置

DNS服务支持动态更新;三是配置DHCP服务支持动态更新。

逻辑拓扑图Vlan1

xp

Linux

详细配置

(1)创建DNS的中正向区域数据库文件：

图(一)

图(一)表示在var/named/chroot/var/named的虚根目录下用vi创建正向区域数据库文件。@表示区域名称，其值为主配置文件中相应区域名称，本例中的@的值就是。

(2)创建DNS中的反向数据库文件：

图(二)

图(二)表示在var/named/chroot/var/named的虚根目录下用vi创建反向区域数据库文件。

操作系统报告 篇5

什么是操作系统

目前工作站中主要存在以下几类操作系统：

Windows类

对于这类操作系统相信用过电脑的人都不会陌生，这是全球最大的软件开发商--Microsoft（微软）公司开发的。Microsoft公司的Windows系统在操作系统中占有绝对优势。主流Windows系统都可以用在工作站中，如高Windows NT 、Windows 9x/ME/XP、Windows ，以及最新的Windows 等。

Unix系统

Linux 系统

操作系统报告 篇6

实验二

进程调度

1．目的和要求

通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。

2．实验内容

阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。

编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有n个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度（调度过程中，假设处于执行状态的进程不会阻塞），且每过t个时间片系统释放资源，唤醒处于阻塞队列队首的进程。

程序要求如下：

1）输出系统中进程的调度次序； 2）计算CPU利用率。

3．实验环境

Windows操作系统、VC++ C语言

4设计思想：

（1）

程序中进程可用PCB表示，其类型描述如下：

struct PCB_type

int pid ；

//进程名 int

state ；

//进程状态

2——表示“执行”状态

1——表示“就绪”状态

0——表示“阻塞”状态

int cpu_time ； //运行需要的CPU时间（需运行的时间片个数）

} 用PCB来模拟进程；

（2）设置两个队列，将处于“就绪”状态的进程PCB挂在队列ready中；将处于“阻塞”状态的进程PCB挂在队列blocked中。 队列类型描述如下：

struct QueueNode{

struct PCB_type

PCB;

Struct QueueNode *next; } 并设全程量：

struct QueueNode *ready_head=NULL,//ready队列队首指针

*ready_tail=NULL ， //ready队列队尾指针

*blocked_head=NULL,//blocked队列队首指针 *blocked_tail=NULL; //blocked队列队尾指针 （3）设计子程序：

start_state()；

读入假设的数据，设置系统初始状态，即初始化就绪队列和阻塞队列。

dispath()；

模拟调度，当就绪队列的队首进程运行一个时间片后，放到就绪队列末尾，每次都是队首进程进行调度，一个进程运行结束就从就绪队列中删除，当到t个时间片后，唤醒阻塞队列队首进程。

calculate()；

就绪进程运行一次，usecpu加1，当就绪队列为空时unusecpu加1，CPU利用率为use_cpu/(use_cpu+unuse_cpu)。

5源代码：

#include#include

struct PCB_type {

int pid ；

//进程名

int

state ；

//进程状态

//2--表示“执行”状态

//1--表示“就绪”状态

//0--表示“阻塞”状态

int cpu_time ； //运行需要的CPU时间（需运行的时间片个数） }； struct QueueNode{

struct PCB_type

PCB;

struct QueueNode *next; }； struct QueueNode *ready_head=NULL,

//ready队列队首指针

*ready_tail=NULL,

//ready队列队尾指针

*block_head=NULL,

//blocked队列队首指针

*block_tail=NULL;

//blocked队列队尾指针

int use_cpu,unuse_cpu;

void start_state() //读入假设的数据，设置系统初始状态 {

int n,m;

int i;

struct QueueNode *p,*q;

printf（“输入就绪节点个数n:”）；

scanf（“%d”，&n）；

printf（“输入阻塞节点个数m:”）；

scanf（“%d”，&m）；

p=（struct QueueNode *）malloc（sizeof(struct QueueNode)）；

p->next =NULL;

ready_head=ready_tail=p;

for(i=0;i

{

p=（struct QueueNode *）malloc（sizeof(struct QueueNode)）；

p->next =NULL;

p->;

printf（“输入就绪进程%d的pid和cpu_time:”，i+1）；

scanf(“%d%d”，&p->;p->)；

ready_tail->next=p;

ready_tail=p;

q=（struct QueueNode *）malloc（sizeof(struct QueueNode)）；

q->next =NULL;

block_head=block_tail=q;

for(i=0;i

{

q=（struct QueueNode *）malloc（sizeof(struct QueueNode)）；

q->next=NULL;

q->;

printf（“输入阻塞进程%d的pid和cpu_time:”，i+1）；

scanf(“%d%d”，&q->;q->)；

block_tail->next=q;

block_tail=q;

printf（“n处于就绪状态的进程有:n”）；

p=ready_head->next;

i=1;

while(p)

{printf(“进程%d的pid和cpu_time:%5d%5d%5dn“，i,p->;;)；

p=p->next;

i++；

} } void dispath()

//模拟调度 {

int x=0,t;

use_cpu=0;

unuse_cpu=0;

printf（”输入t:“）；

scanf（”%d“，&t）；

printf（”开始调度n“）；

while(ready_head!=ready_tail||block_head!=block_tail)

struct QueueNode *p,*q;

if(ready_head!=ready_tail)

p=ready_head->next;

ready_head->next=p->next;

p->next=NULL;

if(ready_head->next==NULL)

ready_tail=ready_head;

p->;

printf(”进程%d调度t“，p->)；

state和

use_cpu++；

x++；

p->;

if(p->)

ready_tail->next=p;

ready_tail=p;

else

printf(”进程%d完成t“，p->)；

free(p)；

else

unuse_cpu++；

x++；

printf（”空闲一个时间片t“）；

if(x==t&&block_head!=block_tail)

q=block_head->next;

block_head->next=q->next;

q->next=NULL;

if(block_head->next==NULL)

block_tail=block_head;

ready_tail->next=q;

ready_tail=q;

x=0;

} } void calculate()

//计算CPU利用率 { printf（”ncpu的利用率%。2fn“，（float）use_cpu/(use_cpu+unuse_cpu)）；

} void main（) {start_state(）；

dispath()；

calculate()； } 6运行结果：

7实验总结：

实验帮我复习了数据结构和C语言，且巩固课本知识，知道了如何定义结构体，如何在链接队列中增删节点。模拟进程调度帮我们巩固了进程三状态之间的变迁。懂得调式的重要性。总之，我们明白了理论联系实际。多看书，多上机。

实验三

可变分区存储管理

1．目的和要求

通过这次实验，加深对内存管理的认识，进一步掌握内存的分配、回收算法的思想。

2．实验内容

阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。 编写程序模拟实现内存的动态分区法存储管理。内存空闲区使用自由链管理，采用最坏适应算法从自由链中寻找空闲区进行分配，内存回收时假定不做与相邻空闲区的合并。

假定系统的内存共640K，初始状态为操作系统本身占用64K。在t1时间之后，有作业A、B、C、D分别请求8K、16K、64K、124K的内存空间；在t2时间之后，作业C完成；在t3时间之后，作业E请求50K的内存空间；在t4时间之后，作业D完成。要求编程序分别输出t1、t2、t3、t4时刻内存的空闲区的状态。

3．实验环境

Windows操作系统、VC++ C语言

4、设计思想

模拟内存分配和回收，要设置两个链队列，一个空闲区链和一个占用区链，空闲区链节点有起始地址，大小和指向下一节点的指针等数据域，占用区链节点有起始地址，大小，作业名和指向下一节点的指针等数据域，本实验用最坏适应算法，每次作业申请内存都是从空闲链队头节点分配，如果相等，就删除空闲头结点，如果小于申请的，就不分配，否则就划分内存给作业，剩下的内存大小，重新插入空闲链队，按从大到小，接着把作业占用的内存放到占用区链节点的末尾。每次作业运行完，就要回收其占用的内存大小，把作业节点按从大到小插入到空闲链队中。 5.源代码：

#include#includestruct freelinkNode{ int len; int address;

struct freelinkNode *next; }； struct busylinkNode{ char name;

int len; int address; struct busylinkNode *next; }； struct freelinkNode *free_head=NULL;

//自由链队列（带头结点）队首指针

struct busylinkNode *busy_head=NULL;

//占用区队列队（带头结点）首指针

struct busylinkNode *busy_tail=NULL;

//占用区队列队尾指针 void start(void) /* 设置系统初始状态*/ { struct freelinkNode *p;

struct busylinkNode *q;

free_head=（struct freelinkNode*）malloc（sizeof(struct freelinkNode)）；

free_head->next=NULL; // 创建自由链头结点

busy_head=busy_tail=（struct busylinkNode*）malloc（sizeof(struct busylinkNode)）；

busy_head->next=NULL; // 创建占用链头结点

p=（struct freelinkNode *）malloc（sizeof(struct freelinkNode)）；

p->address=64;

p->len=640-64;//OS占用了64K

p->next=NULL;

free_head->next=p;

q=（struct busylinkNode *）malloc（sizeof(struct busylinkNode)）；

q->name=\'S\'； /* S表示操作系统占用

q->len=64; q->address=0; q->next=NULL;

busy_head->next=q; busy_tail=q; } void requireMemo(char name, int require) /*模拟内存分配*/ { freelinkNode *w,*u,*v; busylinkNode *p; if(free_head->next->len>=require) {

p=（struct busylinkNode*）malloc（sizeof(struct busylinkNode)）；

p->name=name;

p->address=free_head->next->address;

p->len=require;

p->next=NULL;

busy_tail->next=p;

busy_tail=p; } else

printf（”Can\'t allocate“）；

w=free_head->next;

free_head->next=w->next;

if(w->len==require)

free(w)； } else {

w->address=w->address+require;

w->len=w->len-require; }

u=free_head;

v=free_head->next;

while（(v!=NULL）&&(v->len>w->len)) {

u=v;

v=v->next; }

u->next=w;

w->next=v; } void freeMemo(char name) /* 模拟内存回收*/ { int len;

int address; busylinkNode *q,*p; freelinkNode *w,*u,*v; q=busy_head;

p=busy_head->next;

while（(p!=NULL）&&(p->name!=name))

q=p;

p=p->next; }

if (p==NULL) {

printf（”%c is not exist“，name）； } else

if(p==busy_tail)

busy_tail=q;

else

q->next=p->next;

len=p->len;

address=p->address;

free(p)；

w=（struct freelinkNode*）malloc（sizeof(struct freelinkNode)）；

w->len=len;

w->address=address;

u=free_head;

v=free_head->next;

while（(v!=NULL）&&(v->len>len))

{ u=v; v=v->next;

u->next=w;

w->next=v;

} } } void past（int time) /* 模拟系统过了time 时间*/ { printf（”过了时间%d后:n“，time）； } void printlink(） /* 输出内存空闲情况（自由链的结点） */ {

freelinkNode *p;

printf（”内存的空闲情况为:n“）；

p=（struct freelinkNode *）malloc（sizeof(struct freelinkNode)）；

p=free_head->next;

while(p!=NULL)

printf(”内存的起始地址和内存的大小%5dt%5d:n^，p->address,p->len)；

p=p->next;

} }

void main() {

int t1=1,t2=2,t3=3,t4=4;

start()；

past(t1)；

requireMemo（\'A\'，8）；

requireMemo（\'B\'，16）；

requireMemo（\'C\'，64）；

requireMemo（\'D\'，124）；

printlink()；

past(t2)；

freeMemo（\'C\'）；

printlink()；

past(t3)；

requireMemo（\'E\'，50）；

printlink()；

past(t4)；

freeMemo（\'D\' ）；

printlink()； } 6.运行结果：

7、实验总结：

巩固编程能力，和调式能力，复习课本知识，明白理论联系实际的重要性，动手能力非常重要，多看书，多独立思考，品味痛苦的过程，享受成功的喜悦。

操作系统实验报告

院系：数计学院

班级：大类6班 学号：100511624 姓名：明章辉

指导教师：徐军利

操作系统报告 篇7

实验项目二 进程管理

一、 实验目的

1、 理解进程的概念，掌握父、子进程创建的方法。

2、 认识和了解并发执行的实质，掌握进程的并发及同步操作。

二、 实验内容

1、 编写一C语言程序，实现在程序运行时通过系统调用fork( )创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“I am father”，儿子进程执行时屏幕显示“I am son”，女儿进程执行时屏幕显示“I am daughter”。

2、 多次连续反复运行这个程序，观察屏幕显示结果的顺序，直至出现不一样的情况为止。记下这种情况，试简单分析其原因。

3、 修改程序，在父、子进程中分别使用wait（)、exit(）等系统调用“实现”其同步推进，并获取子进程的ID号及结束状态值。多次反复运行改进后的程序，观察并记录运行结果。

三、 源程序及运行结果

源程序1：

#include#include #includeint main（int argc, char ** argv ） { int pid=fork()； if(pid<0)

printf（“error!”）；

else if（ pid == 0 ）

printf（“I am son!n”）；

else

int pid=fork()；

if (pid<0)

printf（“error!”）；

else if（ pid == 0 ）

printf（“I am daughter! n“）；

else

printf（”I am father!n“）；

} sleep(1)； return 0; }

运行结果：

源程序2：

#include#include #includeint main（int argc, char ** argv ） { char *message; int n;

int pid=fork()； if(pid<0)

printf（”error!“）；

else if（ pid == 0 ）

message=”I am daughter!“；

pid=getpid()；

n=3;

else

int pid=fork()；

if (pid<0)

printf（”error!“）；

else if（ pid == 0 ）

message=”I am son!“；

pid=getpid()；

n=3;

else

message=”I am father!^；

n=3;

for(；n>0;n--) { puts(message)； sleep(1)； }

return 0; }

运行结果：

四、 实验分析与总结

1、 实验内容1运行结果为什么无固定顺序，fork()函数创建进程是如何并发执行的。

答：因为进程是并发执行的，fork()函数创建的三个进程抢占

cpu不同，从而导致三个程序被cpu 调度顺序不同，所以实验一结果无固定顺序。Fork（)函数调用成功后，子进程与父进程并发执行的代码相同，但由于子进程也继承父进程的程序指针，所以子进程是从fork(）后执行的，另外fork在子进程和父进程中返回值是不同的。在父进程中返回子进程的pid，而在子进程中返回0，使父进程和子进程执行不同的分支。

2、 实验内容3是如何实现父子进程的同步执行的。

答：wait（）会暂时停止目前进程的执行，直到有信号来到或子进程结束。程序段主要使用了函数wait（）和，exit（）这是因为父进程必须等待两个子进程终止后才终。在父进程中调用wait（)函数，则父进程被阻塞，进入等待队列，等待子进程结束。子进程终止时执行exit（）向父进程发终止信号，当接到信号后，父进提取子进程的结束状态值，从wait(）返回继续执行原程序，从而实现了父、子进程的同步推进。

总结：通过进程管理实验，了解fork（)函数创建进程是并发执行的，wait（）进程表示会暂时停止目前进程的执行，可以灵活运用fork（）和wait（）进程解决有关问题。在实验中遇到许多问题，如：实验中调用fork(）进程失败，可能的原因有系统中有太多的进程或者实际用户ID的进程总数超过了系统的限制。刚接触VMware这个系统，操作不熟悉，多次操作后，了解这个系统有关操作，实验做起来就比较简单了。对实验代码也不熟悉，最后通过请教老师和同学，终于实验理解透彻，并成功运行了。不仅上课要认真听课，要想真正学会，课下也要付出努力。

操作系统报告 篇8

对于此次课程设计，我早在寒假就借了linux相关书籍参看，但上面讲的主要是有关linux操作方面的内容，编程方面讲得很少，而且在假期中也并不知道课设的题目是什么，因此此次课设基本上都是在开学后的这两周内完成的。

以前做过的软件方面的课设如c语言课设、数据结构课设都是在假期完成的，由于自己是一个十分追求完美的人，因此几乎每次都花了将近大半个假期的时间来做，如c语言就花了一个多月的时间来做，分数当然也较高，有90来分。对于课程设计，我历来都是相当认真的，此次操作系统的课程设计当然也不例外。可是linux以前没怎么接触过，学校也没怎么系统地讲过，在刚接到题目时除了知道如何用gcc编译等等，几乎可以算作处于一无所知的状态。时间紧任务重，要从对linux一无所知的状态到独立出色地完成课设，不下点苦功夫是不成的。那两周里我除了吃饭睡觉几乎就没离开电脑过，有时时间晚了食堂关门饭都没得吃了。终于，在这样近乎玩命地学习工作下，身体撑不住了，在第二周周三晚上我发烧了。但是眼看就要到检查的日期了，而我的课设也就快完工了。我不想因为看病而耽误下去弄得前功尽弃，因此只买了点药，继续在电脑前拼命……最后，总算赶在周五检查前做出了较满意的作品。然而这几天一直高烧不退，周五回家后就直接倒床昏睡过去，周六早上一量居然还有39°。于是赶紧去附近一家医院看病，连打了两天吊针才算好转过来。而看病用的几百块钱由于不是在校医院看的也无法报销，只好自掏腰包了。

在周五检查那天，老师看了我第4题后，又抽查了一下我的第3题，其实也只是要我把第3题运行一下而已罢了。若放在平时，这绝对是小菜一碟，但当时正在发烧，加上一点紧张，居然把模块加载命令insmod fdev。o错打成insmod fdev。c了，由于这个低级失误造成心中慌乱，于是后面的一条生成设备文件命令mknod干脆就照着参考资料打上去了。于是老师认为我不熟，在那题上打了个半钩。当时心里确实感到十分地遗憾和沮丧，心想所谓“台上一分钟，台下十年功”，一分钟若把握不好，也同样尽毁十年功啊！

感谢老师，感谢此次课程设计。虽然在其中吃了不少苦头，但我毫不后悔，因为我满载而归。

操作系统报告 篇9

1.实习目的

(一).通过综合实训进一步巩固、深化和扩展学生的专业技能。

1.熟练掌握Linux操作系统的安装及基本配置。

2.熟练掌握Linux系统管理。

3.掌握Linux下用户和组的管理。

4.掌握Linux下FTP服务器的管理。

(三)培养学生运用所学的知识和技能解决Linux使用、管理过程中所遇到的实际问题的能力及其基本工作素质。

(四)培养学生理论联系实际的工作作风、严肃认真的科学态度以及独立工作的能力，树立自信心。

(五)训练和培养学上的团队协作精神与合作能力。

2 实习概况

实习要求

具体来讲，《linux操作系统》课程包括以下实习内容：

(一)独立完成实训。

(二)要求熟练掌握Linux操作系统的安装与基本配置。

(三)熟练掌握Linux系统管理基本方法。

(四)掌握Linux下用户和组的管理。。

(五)掌握Linux下的FTP服务器的管理。

实习时间

20XX年12月16日至20XX年12月20日

实习基本情况

实习地点：四教学楼 4112、4212、4312、4412

实习环境 :RedHat9软件

实习内容:掌握linux操作系统

硬件环境

3 实习内容

linux安装 Linux是一类Unix计算机操作系统的统称。Linux 是以Unix 操作系统为原型的多任务、多用户的系统。可运行于多种硬件平台：PC、Alpha、SPARC、

POWER PC。 今天实习的主要内容是学习了解Linux的安装过程;Linux登录和退出 ，熟悉Linux操作系统的图形界面

(一)Linux的安装过程

1)VMware软件的安装

因为我用的是机房的电脑，所以不用安装VMware软件。如果要安装，过程十分简单，下载完毕，直接“Next”即可完成安装。

2)虚拟机的安装。打开VMware软件，单击“新建虚拟机”命令根据提示选择一种要安装的操作系统，一般选择典型设置，然后直接按“下一步”即可。需要注意的就是在分区的时候需按要求建立合适的分区，如下图所示。

图3-1-1 选择分区

3)Red Hat Linux 安装

操作系统报告 篇10

每一次课程设计度让我学到了在平时课堂不可能学到的东西。所以我对每一次课程设计的机会都非常珍惜。不一定我的课程设计能够完成得有多么完美，但是我总是很投入的去研究去学习。所以在这两周的课设中，熬了2个通宵，生物钟也严重错乱了。但是每完成一个任务我都兴奋不已。一开始任务是任务，到后面任务就成了自己的作品了。总体而言我的课设算是达到了老师的基本要求。总结一下有以下的体会。

2、同学间的讨论，这是很重要的。老师毕竟比较忙。对于课程设计最大的讨论伴侣应该是同学了。能和学长学姐讨论当然再好不过了，没有这个机会的话，和自己班上同学讨论也是能够受益匪浅的。大家都在研究同样的问题，讨论起来，更能够把思路理清楚，相互帮助，可以大大提高效率。

3、敢于攻坚，越是难的问题，越是要有挑战的心理。这样就能够达到废寝忘食的境界。当然这也是不提倡熬夜的，毕竟有了精力才能够打持久战。但是做课设一定要有状态，能够在吃饭，睡觉，上厕所都想着要解决的问题，这样你不成功都难。

4、最好在做课设的过程中能够有记录的习惯，这样在写实验报告时能够比较完整的回忆起中间遇到的各种问题。比如当时我遇到我以前从未遇到的`段错误的问题，让我都不知道从何下手。在经过大量的资料查阅之后，我对段错误有了一定的了解，并且能够用相应的办法来解决。

在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的

1)访问系统数据区，尤其是往系统保护的内存地址写数据，最常见就是给一个指针以0地址

2)内存越界(数组越界，变量类型不一致等) 访问到不属于你的内存区域

3）其他

例如：

<1>定义了指针后记得初始化，在使用的时候记得判断是否为null

<2>在使用数组的时候是否被初始化，数组下标是否越界，数组元素是否存在等

<3>在变量处理的时候变量的格式控制是否合理等

解决方法

1.利用gdb逐步查找段错误:

2.分析core文件

3.段错误时启动调试:

4.利用backtrace和objdump进行分析:

总而言之，对待课设要像对待自己的作品一样，不要当作任务来完成。

操作系统报告 篇11

问题：什么是操作系统？操作系统是什么意思？

操作系统(OperatingSystem，简称OS)传统上是负责对计算机硬件直接控制及管理的系统软件，操作系统的功能一般包括处理器管理、存储管理、文件管理、设备管理和作业管理等，

一个操作系统可以在概念上分割成两部分：内核(Kernel)以及壳(shell)。一个壳程序包裹了与硬件直接交流的内核：硬件内核壳应用程序。但有些操作系统上内核与壳完全分开(例如Unix、Linux等)，这样用户就可以在一个内核上使用不同的壳；而另一些的内核与壳关系紧密(例如MicrosoftWindows)，内核及壳只是操作层次上不同而已。

,投资者入门的好帮手

操作系统报告 篇12

电脑使用一段时间后机箱里会存积大量的灰尘，这些灰尘会影响硬件的散热，尤其会影响cpu的散热。具体的表现是主机工作时噪声变大，经常出现操作反映迟缓等现象（有时候病毒、木马和垃圾文件过多也是此现象，所以要具体情况具体对待）。那么多长时间清扫一次合适呢？这要看你的机器所处的环境的浮尘量了，一般在自己家里一个季度到半年清扫一次就可以了（新买的电脑建议在过了保修期以后再清扫，因为一旦打开机箱即保修自动终止），因为对于新手来说过于频繁的清扫反而会增大硬件意外损坏的风险。清扫时将机箱盖打开，用软毛刷子轻轻扫去附着在主板各硬件表面的灰尘，然后将cpu风扇拆下（散热片不要从主板上拆下来），仔细扫去风扇叶片和散热片缝隙里的灰尘。然后拔掉内存，将内存插槽和内存条上的触点用潮湿的软布轻轻的擦干净。最后将所有部件装回原位就可以了。

[操作系统维护]

1、对于新手要尽量安装一键还原工具。一些品牌机都会带有一键还原工具，如果是组装的机器或是没有预装操作系统的品牌机，都是没有此类软件的，建议你在安装完操作系统后的第一时间安装这些软件并备份系统盘。

2、重装或更换操作系统前把一键还原工具卸载掉。因为这些软件很多都会保护引导区（mbr），所以在安装了这类软件后无法完成系统的重装。（所以我现在是不用一键还原的）

3、不要把“我的文档”放在系统盘。因为在“我的文档”中往往会保存一些比较大的文件，如果在系统盘，会占用本来就有限的系统盘空间，而且在一键还原或重装系统后系统盘的数据会被全部重写，原来的文件都将不复存在。

5、尽量安装功能多的软件。这样可以减少系统中软件的数量，从而节省磁盘空间，但也不要过于求大求全，够用即可。

6、对于有经验的人来说可以关闭自动更新和系统还原，这样可以让系统运行更顺畅。

7、软件能用原版就用原版。很多软件都有破解版、汉化版、简化版、增强版等版本，这些版本很多都存在问题，有的还有病毒，所以软件还是原版好。

8、系统优化要慎重。我曾经因优化后系统不能正常工作而重装。

9、卸载软件后要及时删除其安装目录。很多软件在卸载后会在其安装目录里保留一些文件，虽然一般都不是很大，但系统用的时间长了难免会留下大量这类垃圾文件。所以在卸载完一个软件后要查看其安装目录是否依然存在，如果存在就将其删除，无法删除的可以在安全模式下删除。

10、尽量避免强行终止进程。这样可以减少垃圾文件的产生，有时候被强行终止后的程序还会工作不正常，甚至彻底不能用了。

操作系统报告 篇13

许昌学院

《操作系统》实验报告书

学号：姓名：闫金科班级：成绩:

5006140057

一、实验目的

1、 熟悉Linux系统的基本概念，比如Linux发行版、宏内核、微内核等。 2. 掌握Linux系统的安装和配置过程，初步掌握Linux系统的启动和退出方法。 3. 熟悉Linux系统的文件系统结构，了解Linux常用文件夹的作用。

二、实验内容

4、 在VMware中利用第二个镜像文件完成第二个Linux的安装，并通过LILO或者GRUB解决两个操作系统选择启动的问题。

5、 启动Linux系统，打开文件浏览器查看Linux系统的文件结构，并列举出Linux常用目录的作用。

三、 实验过程及结果

操作系统报告 篇14

操作 系统 实验报告

实验名称：

线程 控制实验

计算机科学与技术学院

一、实验目的和要求 2 二、实验内容 2 三、实验步骤 2 四、实验结果与分析 3 1．单线程 3 2．单线程（睡眠 4s） 3 3．多线程 4 4．多线程（每个子线程睡眠 1s） 4 5．单线程与多线程对比 5 五、程序源代码 5 1．单线程实验代码 5 2．单线程实验代码 6 六、实验体会 7

一、实验目的和要求

通过本实验掌握在 Linux 操作系统中遵循 Posix线程标准接口进行多线程程序编程，熟练掌握线程的创建 pthread_create（)，线程的终止 pthread_exit（），等待线程合并 pthread_join(）等线程控制操作，利用信号量或者互斥锁实现线程建的同步。

二、实验内容

问题：求 1000000 个浮点数（精确到小数点后 4 位）的平均值（和，最大值，最小值），具体的问题描述流程图如下图图 1 所示：

三 、实验 步骤

1、随机生成1000000个浮点数； 2、创建 4个子线程，分别求 250000个浮点数之和； 3、完成 1000000 个浮点数之和并打印结果； 4、统计多线程并发执行完成计算的时间； 5、写一个单线程程序，同样完成 1000000 个随机数求和的计算，统计计算时间，并和前面结果进行对比； 6、让单线程程序睡眠四秒钟、多线程程序各子程序睡一秒的条件下（两个程序总的睡眠时间相同），对比执行结果； 7、分析两次对比结果的差异，写出自己的见解。

四、实验结果与分析1、单线程完成 1000000 个浮点数的求和运算所用的时间情况如下图图 2 所示：

图 图 2 单线程计算 时间

分析：实验中每次随机产生一个 0 到 1 之间的浮点数，1000000 个这样的数相加的话的平总和大概就在 500000 左右（按照随机数的平均值原理），实验中 sum=，显然结果正确，整个计算运行时间为。

2、单线程完成1000000 个浮点数的求和运算，单线程中睡眠 4 秒钟，所用的时间情况如下图图3 所示：

图 图 3 单线程计算 时间（ 睡眠 4 秒） 分析：根据上一次单线程的执行情况来看，这一次让单线程睡眠 4 秒钟，最后执行时间刚好就是4 秒加上计算时间。也就是说计算 1000000 个浮点数的总和平均时间约为。

3、四个子线程共同完成1000000 个浮点数的求和计算所用时间情况如下图图 4所示：

图 图 4 多线程计算时间

分析：因为这次是 4 个子线程并发运行，每个子线程只需计算 250000个浮点数的总和，理想情况下这时候的运行时间应该是这单线程中计算时间的四分之一。从图中可以看到执行时间是，很显然这个时间约为单线程求 1000000 个浮点数之和的时间（）的四分之一，符合预期的结果。

4、四个子线程共同完成1000000 个浮点数的求和计算，其中每个子线程睡眠 1 秒钟，最终所用时间情况如下图图 5所示：

图 图 5 多线程计算时间（ 每个 子线程眠 睡眠 1 秒）

分析：这里四个子线程每个子线程睡眠一秒，但由于四个子线程并发同步的在执行，当一个子线程在睡眠时，另外一个子线程却仍然在继续求和计算，因此他们一起合作同步完成1000000个浮点数的计算所需的时间就是 1 秒加上上图中不睡眠的时候的计算时间。从图中可以

看到≈1s+，所以最终的结果符合预期值。

5、单线程计算时间（睡眠4s）与多线程计算时间（每个子线程睡眠 1s）对比效果如下图图 6 所示:

图 图 6 单线程 （ 睡眠 4s）与 与 多线程 （ 每个眠 子线程睡眠 1s） 计算时间 对比图 五、程序源代码 /************************* *FileName：

*Author：

*Date：2013/11/22 ***************************/ #include<>#include<>#include<>#include<>#include#define LOOP 1000000 float SUM=0; void *ADD() {

int i;

srand（time(NULL)）；

for(i=0;i

{

SUM += （float)(rand（）/(float）RAND_MAX)；

sleep（4)； } int main(） {

pthread_t p;

int result;

float time;

struct timeval start;

struct timeval end;

gettimeofday（&start,NULL）；

result=pthread_create（&p,NULL,ADD,NULL）；

if(result!=0)

printf（“Create Thread of ADD Failuren”）；

exit(-1)；

pthread_join(p,NULL)；

gettimeofday（&end,NULL）；

time = （(float） - *1000000+(float)

- )/1000000;

printf（“Signal_Thread_Sum:%。4fn”，SUM）；

printf（“Signal_Thread_Execution_Time:%。4fs(sleep 4 sec）n”，time)；

return 0; }

/************************* *FileName：

*Author：wangtao *Date：2013/11/22 ***************************/ #include<>#include<>#include<>#include<>#include#define LOOP 25000 pthread_mutex_t mutex; float SUM=0; void ADD(int * k) {

int i;

srand（time(NULL)）；

for(i=0;i

{

pthread_mutex_lock（&mutex）；

SUM += （float)（(float）rand（）/RAND_MAX）；

pthread_mutex_unlock（&mutex）；

printf（“pthread%d:%。4fn”，*k,SUM）；

sleep(1)； } int main(void) {

pthread_t p1,p2,p3,p4;

int result1,result2,result3,result4;

int k1=1,k2=2,k3=3,k4=4;

struct timeval start;

struct timeval end;

float time;

gettimeofday（&start,NULL）；

pthread_mutex_init（&mutex,NULL）；

result1=pthread_create（&p1,NULL,(void*）ADD,&k1)；

result2=pthread_create（&p2,NULL,(void*）ADD,&k2)；

result3=pthread_create（&p3,NULL,(void*）ADD,&k3)；

result4=pthread_create（&p4,NULL,(void*）ADD,&k4)；

if(result1!=0||result2!=0||result3!=0||result4!=0)

printf(“Create Child

Thread

Failure!n”)；

exit(1)；

pthread_join(p1,NULL)；

pthread_join(p2,NULL)；

pthread_join(p3,NULL)；

pthread_join(p4,NULL)；

gettimeofday（&end,NULL）；

time = （（float） - *1000000 + (float) - ）/1000000;

printf（“SUM = %。4fn”，SUM）；

printf（“Multi_thread_time = %。4fs(Each child thread sleep 1 sec）n”，time)；

return 0; } 六、实验体会

这是第一次使用多线程编程编写代码，第一次直观感受到这种多线程编程对程序的执行速率的影响。虽然说操作系统课程已经上了好几个星期了，课堂上一直在学习多线程编程的算法思想，但是那只是书面上的讲授，真正直观的感受和体会还是得依靠实验来了解。

因为之前就接触过 linux 系统，所以对于程序的编译执行方面还是问题不大，最主要的就是代码的编写问题。一开始到实验室完全不知道要做什么，因为根本连实验内容都不知道，直到助教在大屏幕上显示这个实验题目，我才开始了解实验的题目和要求。这里我就是想建议一下老师您可以应该给我们实验题目，让我们在实验前就了解一下实验内容，不然到了实验室都不知道到底要干嘛。读懂了解题意之后，我就开始参考所给的一些线程创建函数说明来编写多线程同步完成1000000个浮点数的求和运算。因为对这些线程函数不是很了解，在使用 pthread_create（)函数创建线程时，老是传入函数参数不对，后来百度之后了解到传入的子线程函数的类型应该为 void * (*start_thread）(void)形式。最后运行试验与单线程的进行比较，强烈感受到多线程的并发同步运行的特点。

总之，这次试验使我对课堂知识有了更深的体会和巩固，为以后的课程学习打下了基础。

操作系统报告 篇15

这学期有幸学习了《嵌入式系统设计》这门课，在胡佳文老师的教导下深入了解了有关于嵌入式系统，ARM9，Linux系统等很多方面的知识，获益良多，在学习过程中自己也遇到了很多问题，同时受到了很大的启发，现在就本学期的学习谈谈自己的学习心得体会。

眼看这个学期Linux的课程已经告一段落了，在这段时间的学习如果要问我在这门课中学到了什么，我觉得是一种为学的方法，使我受益非浅。

再者，正如学得会不如学得牢，熟读熟写基础知识是相当必要的。一个朋友曾经告诉我学习的方法就是：看书、思考、写笔记、做实验、再思考、再写笔记。我觉得说的很对，对于新手来说就要这样，不断的去努力奋斗，最后一定能得到自己想要的成果。

同时在我们自己的学习中，要尽自己的能力去帮助他人，在帮助他人的同时自己会深刻巩固知识 。正所谓实践出真知，这学期的学习发现从理论到实践其实很遥远，书本上得到的知识是远远不够的。

最后要永远保持虚心的学习态度 我想大家都知道一遍天外有天，人外有人的道理！保持虚心的学习态度不仅能让你学到更多知识，而且会让你受人尊重。。