西北工业大学-操作系统实验报告-实验四
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。
实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。
三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。
在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。
通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。
2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。
通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。
在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。
（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。
通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。
2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。
在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。
（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。
《操作系统》实验报告
《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。
二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。
在这个实验中，我们使用C+＋编写程序来创建和管理进程。
通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。
首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。
然后，使用等待函数来等待子进程的结束，并获取其返回值。
在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。
2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。
在这个实验中，我们研究了动态内存分配和释放的机制。
使用 C+＋中的 new 和 delete 操作符来分配和释放内存。
通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。
同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。
通过模拟内存访问过程，理解了页表的作用和地址转换的过程。
3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。
在这个实验中，我们对文件的创建、读写和删除进行了操作。
使用 C+＋的文件流操作来实现对文件的读写。
通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。
此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。
4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。
西北工业大学操作系统实验_OS1（5）
西北⼯业⼤学操作系统实验_OS1（5）班级：10011007 学号：2010302541 姓名：陈⼀凡实验⼀Linux操作系统的安装及使⽤1. 实验⽬的学习Linux操作系统的安装，体会操作系统为了⽅便⽤户，不断改进的安装过程；熟悉Linux系统的登录和退出，并熟悉它常⽤命令的操作使⽤⽅法。
2. 实验内容1）Linux操作系统的安装(1) 收集硬件配置资料（硬盘空间⼤⼩、显卡类型、显存⼤⼩、⽹卡类型等基本信息）；(2) 对于要安装Linux⽽⼜没有预留出⾃由空间，可利⽤Linux光盘⾃带的分区⼯具来拆分基本分区；也可以利⽤DOS下的调整分区程序PQMagic来拆分基本分区或逻辑分区，并将PQMagic安装在另⼀个分区中；(3) Linux对不同介质的安装⽅法（直接从光盘引导完成安装，要求CMOS和光盘都能⽀持光盘引导；从硬盘完成安装，可事先将Linux软件包拷⼊硬盘的⼀个分区，将Linux安装到硬盘的另⼀个分区；⽹络安装，通过⽹络⽂件系统NFS或FTP 并安装到硬盘。
）；(4) 使⽤FDISK添加Linux主分区和交换分区（swap）；(5) 格式化分区；(6) 选择安装内容；(7) 设置root⽤户的⼝令；(8) 设置⽹卡的中断向量号、I/O地址、DNS和⽹络的⼦⽹掩码等；(9) 安装LILO，实现操作系统的双引导。
2）Linux操作系统的使⽤(1) 登录、退出和关闭系统；(2) man命令的使⽤；(3) –help命令的使⽤；(4) dir（ls）命令的使⽤；(5) less（more）分页浏览⽂件命令的使⽤；(6) touch命令的使⽤；(7) whatis命令的使⽤；(8) apropos命令的使⽤；(9) locate命令的使⽤；(10) whereis命令的使⽤；(11) find命令的使⽤；(12) sort命令的使⽤；(13) tar命令的使⽤；(14) 解压缩归档⽂件命令的使⽤；(15) mc程序的使⽤；(16)cd改变⽬录；(17)pwd查看当前⽬录；(18)mkdir创建新⽬录；(19)cp⽂件拷贝；(20)cat在屏幕上显⽰⽂件内容3）C语⾔程序的编译Linux环境下C语⾔使⽤gcc编译器对程序进⾏编译。
计算机操作系统实验-运行用户态程序
计算机操作系统实验-运行用户态程序(总13页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--西北工业大学操作系统实验实验报告一、实验目的掌握在GeekOS系统用户态模式下加载并运行可执行程序的方法。
二、实验要求1. 按照实验讲义P127页中的设计要求，实现在用户态模式下加载并运行可执行程序的代码，给出关键函数的代码以及实验结果。
三、实验过程及结果答：核心函数代码如下：================== ===============*/Set_Kernel_Stack_Pointer(esp0);ffsetInFile=proHeader->offset;exeFormat->segmentList[i].lengthInFile=proHeader->fileSize;exeFormat->segmentList[i].startAddress=proHeader->vaddr;exeFormat->segmentList[i].sizeInMemory=proHeader->memSize;exeFormat->segmentList[i].protFlags=proHeader->flags;proHeader++;}return 0;}=================== ===================//需在此文件各函数前增加一个函数，此函数的功能是按给定的大小创建一个用户级进程上下文，具体实现如下：//函数功能:按给定的大小创建一个用户级进程上下文static struct User_Context* Create_User_Context(ulong_t size){struct User_Context * UserContext;size = Round_Up_To_Page(size);UserContext = (struct User_Context *)Malloc(sizeof(struct User_Context)); if (UserContext != 0)UserContext->memory = Malloc(size);//为核心态进程elsegoto fail;//内存为空if (0 == UserContext->memory)goto fail;memset(UserContext->memory, '\0', size);UserContext->size = size;//以下为用户态进程创建LDT(段描述符表)//新建一个LDT描述符UserContext->ldtDescriptor = Allocate_Segment_Descriptor();if (0 == UserContext->ldtDescriptor)goto fail;//初始化段描述符Init_LDT_Descriptor(UserContext->ldtDescriptor, UserContext->ldt, NUM_USER_LDT_ENTRIES);//新建一个LDT选择子UserContext->ldtSelector = Selector(KERNEL_PRIVILEGE, true,Get_Descriptor_Index(UserContext->ldtDescriptor));//新建一个文本段描述符Init_Code_Segment_Descriptor(&UserContext->ldt[0],(ulong_t) UserContext->memory,size / PAGE_SIZE,USER_PRIVILEGE);//新建一个数据段Init_Data_Segment_Descriptor(&UserContext->ldt[1],(ulong_t) UserContext->memory,size / PAGE_SIZE,USER_PRIVILEGE);//新建数据段和文本段选择子UserContext->csSelector = Selector(USER_PRIVILEGE, false, 0);UserContext->dsSelector = Selector(USER_PRIVILEGE, false, 1);//将引用数清0UserContext->refCount = 0;return UserContext;fail:if (UserContext != 0){if (UserContext->memory != 0){Free(UserContext->memory);}Free(UserContext);}return 0;}--------------------------------------------//摧毁用户上下文void Destroy_User_Context(struct User_Context* userContext) {//TODO("Destroy a User_Context");//释放占用的LDTFree_Segment_Descriptor(userContext->ldtDescriptor);userContext->ldtDescriptor=0;//释放内存空间Free(userContext->memory);userContext->memory=0;//释放userContext本身占用的内存Free(userContext);userContext=0;}----------------------------------------------int Load_User_Program(char *exeFileData,ulong_t exeFileLength,struct Exe_Format *exeFormat,const char *command,struct User_Context**pUserContext){//TODO("Load a user executable into a user memory space using segmentation");int i;ulong_t maxva = 0;//要分配的最大内存空间unsigned numArgs;//进程数目ulong_t argBlockSize;//参数块的大小ulong_t size, argBlockAddr;//参数块地址struct User_Context *userContext = 0;//计算用户态进程所需的最大内存空间for (i = 0; i < exeFormat->numSegments; ++i) {//struct Exe_Segment *segment = &exeFormat->segmentList[i];ulong_t topva = segment->startAddress + segment->sizeInMemory; /* FIXME: range check */if (topva > maxva)maxva = topva;}Get_Argument_Block_Size(command, &numArgs, &argBlockSize);//获取参数块信息size = Round_Up_To_Page(maxva) + DEFAULT_USER_STACK_SIZE;argBlockAddr = size;size += argBlockSize;userContext = Create_User_Context(size);//按相应大小创建一个进程if (userContext == 0)//如果为核心态进程return -1;for (i = 0; i < exeFormat->numSegments; ++i) {struct Exe_Segment *segment = &exeFormat->segmentList[i];//根据段信息将用户程序中的各段内容复制到分配的用户内存空间memcpy(userContext->memory + segment->startAddress, exeFileData + segment->offsetInFile,segment->lengthInFile);}//格式化参数块Format_Argument_Block(userContext->memory + argBlockAddr, numArgs, argBlockAddr, command);//初始化数据段，堆栈段及代码段信息userContext->entryAddr = exeFormat->entryAddr;userContext->argBlockAddr = argBlockAddr;userContext->stackPointerAddr = argBlockAddr;//将初始化完毕的User_Context赋给*pUserContext*pUserContext = userContext;return 0;//成功}----------------------------------------------//将用户态的进程复制到内核缓冲区bool Copy_From_User(void* destInKernel, ulong_t srcInUser, ulong_t bufSize) {struct User_Context * UserContext = g_currentThread->userContext;//--: check if memory if validatedif (!Validate_User_Memory(UserContext,srcInUser, bufSize))return false;memcpy(destInKernel, UserContext->memory + srcInUser, bufSize);return true;}-----------------------------------------//将内核态的进程复制到用户态bool Copy_To_User(ulong_t destInUser, void* srcInKernel, ulong_t bufSize) {struct User_Context * UserContext = g_currentThread->userContext;if (!Validate_User_Memory(UserContext, destInUser, bufSize))return false;memcpy(UserContext->memory + destInUser, srcInKernel, bufSize);return true;}----------------------------------------//切换到用户地址空间void Switch_To_Address_Space(struct User_Context *userContext){ushort_t ldtSelector= userContext->ldtSelector;/* Switch to the LDT of the new user context */__asm__ __volatile__ ("lldt %0"::"a"(ldtSelector));}================= ===============添加头文件 #include <geekos/>----------------------------------//创建一个用户进程/*static*/ void Setup_User_Thread(struct Kernel_Thread* kthread, struct User_Context* userContext){ulong_t eflags = EFLAGS_IF;unsigned csSelector=userContext->csSelector;//CS选择子unsigned dsSelector=userContext->dsSelector;//DS选择子Attach_User_Context(kthread, userContext);//初始化用户态进程堆栈，使之看上去像刚被中断运行一样//分别调用Push函数将以下数据压入堆栈Push(kthread, dsSelector); //数据选择子Push(kthread, userContext->stackPointerAddr); //堆栈指针Push(kthread, eflags); //EflagsPush(kthread, csSelector); //文本选择子Push(kthread, userContext->entryAddr); //程序计数器Push(kthread, 0); //错误代码(0)Push(kthread, 0); //中断号(0)//初始化通用寄存单元，将ESI用户传递参数块地址Push(kthread, 0); /* eax */Push(kthread, 0); /* ebx */Push(kthread, 0); /* edx */Push(kthread, 0); /* edx */Push(kthread, userContext->argBlockAddr); /* esi */Push(kthread, 0); /* edi */Push(kthread, 0); /* ebp *///初始化数据段寄存单元Push(kthread, dsSelector); /* ds */Push(kthread, dsSelector); /* es */Push(kthread, dsSelector); /* fs */Push(kthread, dsSelector); /* gs */}//开始用户进程struct Kernel_Thread* Start_User_Thread(struct User_Context* userContext, bool detached){struct Kernel_Thread* kthread = Create_Thread(PRIORITY_USER, detached);if (kthread != 0){Setup_User_Thread(kthread, userContext);Make_Runnable_Atomic(kthread);}return kthread;}================ =================//需在此文件别的函数前增加一个函数，函数名为Copy_User_String，它被函数Sys_PrintString调用，具体实现如下：static int Copy_User_String(ulong_t uaddr, ulong_t len, ulong_t maxLen, char**pStr){ int rc = 0;char *str;if (len > maxLen){ //超过最大长度return EINVALID;}str = (char*) Malloc(len+1); //为字符串分配空间if (0 == str){rc = ENOMEM;goto fail;}if (!Copy_From_User(str, uaddr, len)){ //从用户空间中复制数据rc = EINVALID;Free(str);goto fail;}str[len] = '\0';//成功*pStr = str;fail:return rc;}-----------------------------------------static int Sys_Exit(struct Interrupt_State* state){Exit(state->ebx);}-----------------------------------------static int Sys_PrintString(struct Interrupt_State* state){int rc = 0;//返回值uint_t length = state->ecx;//字符串长度uchar_t* buf = 0;if (length > 0) {if ((rc = Copy_User_String(state->ebx, length, 1023, (char**) &buf)) != 0)goto done;Put_Buf(buf, length);}done:if (buf != 0)Free(buf);return rc;}----------------------------------------------static int Sys_GetKey(struct Interrupt_State* state){return Wait_For_Key(); //返回按键码Wait_For_Key()}---------------------------------------------static int Sys_SetAttr(struct Interrupt_State* state){Set_Current_Attr((uchar_t) state->ebx);return 0;}---------------------------------------------static int Sys_GetCursor(struct Interrupt_State* state){int row, col;Get_Cursor(&row, &col);if (!Copy_To_User(state->ebx, &row, sizeof(int)) ||!Copy_To_User(state->ecx, &col, sizeof(int)))return -1;return 0;}-----------------------------------------------static int Sys_PutCursor(struct Interrupt_State* state){return Put_Cursor(state->ebx, state->ecx) 0 : -1;}-----------------------------------------------static int Sys_Spawn(struct Interrupt_State* state){int rc; //函数返回值char *program = 0; //进程名称char *command = 0; //用户命令struct Kernel_Thread *process;if ((rc = Copy_User_String(state->ebx, state->ecx, VFS_MAX_PATH_LEN, &program)) != 0){goto fail;}if(rc = Copy_User_String(state->edx, state->esi, 1023, &command)) != 0) {//从用户空间复制用户命令goto fail;}Enable_Interrupts(); //开中断rc = Spawn(program, command, &process);//得到进程名称和用户命令后便可生成一个新进程if (rc == 0) {//若成功则返回新进程ID号KASSERT(process != 0);rc = process->pid;}Disable_Interrupts();//关中断if (program != 0)Free(program);if (command != 0)Free(command);return rc;}-----------------------------------------static int Sys_Wait(struct Interrupt_State* state){ //TODO("Wait system call");int exitCode;struct Kernel_Thread *kthread = Lookup_Thread(state->ebx);if (kthread == 0)return -12;Enable_Interrupts();exitCode = Join(kthread);Disable_Interrupts();return exitCode;}---------------------------------------static int Sys_GetPID(struct Interrupt_State* state) { //TODO("GetPID system call");return g_currentThread->pid;}================= ================== static void Spawn_Init_Process(void){ //TODO("Spawn the init process");struct Kernel_Thread *pThread;Spawn("/c/","/c/",&pThread);}实验结果如图所示：原理：Geekos 提供了一个简单的shell，保存在PFAT文件系统内，所以geekos系统启动后，启动shell程序/c/运行，将/c/作为可执行文件传递给spawn函数的program参数，创建第一个用户态进程，然后由它来创建其他进程。
计算机操作系统实验_解析ELF文件
西北工业大学操作系统实验实验报告一、实验目的熟悉可执行链接文件（ELF）的结构，了解GeekOS将ELF格式的可执行程序加载到内存，建立内核线程并运行的实现技术。
二、实验要求1.修改Project1项目中的/GeekOS/elf.c文件：在函数Parse_ELF_Executable()中添加代码，分析ELF格式的可执行文件（包括分析得出ELF文件头、程序头），获取可执行文件长度、代码段、数据段等信息，并打印输出。
并且，填充Exe_Format 数据结构中的值域。
2.掌握GeekOS在核心态运行可执行程序的原理，绘制出可执行程序在内核中加载、运行的流程图（需反映关键函数的调用关系）。
3.回答实验讲义P125页的思考题。
三、实验过程及结果1、修改Project1项目中的/GeekOS/elf.c文件：在函数Parse_ELF_Executable()中添加代码，分析ELF格式的可执行文件（包括分析得出ELF文件头、程序头），获取可执行文件长度、代码段、数据段等信息，并打印输出。
并且，填充Exe_Format 数据结构中的值域。
答：修改Project1项目中的/GeekOS/elf.c文件：在函数Parse_ELF_Executable()中添加代码，如下：==============elf.c===================int Parse_ELF_Executable(char *exeFileData, ulong_t exeFileLength, struct Exe_Format *exeFormat){int i;elfHeader *head=(elfHeader*)exeFileData;programHeader *proHeader=(programHeader *)(exeFileData+head->phoff);KASSERT(exeFileData!=NULL);KASSERT(exeFileLength>head->ehsize+head->phentsize*head->phnum);KASSERT(head->entry%4==0);exeFormat->numSegments=head->phnum;exeFormat->entryAddr=head->entry;for(i=0;i<head->phnum;i++){exeFormat->segmentList[i].offsetInFile=proHeader->offset;exeFormat->segmentList[i].lengthInFile=proHeader->fileSize;exeFormat->segmentList[i].startAddress=proHeader->vaddr;exeFormat->segmentList[i].sizeInMemory=proHeader->memSize;exeFormat->segmentList[i].protFlags=proHeader->flags;proHeader++;}return 0;}==============elf.c===================运行结果如图：2、掌握GeekOS在核心态运行可执行程序的原理，绘制出可执行程序在内核中加载、运行的流程图（需反映关键函数的调用关系）。
计算机操作系统实验_操作系统引导
西北工业大学操作系统实验实验报告一、实验目的熟悉GeekOS实验环境。
二、实验要求编译运行操作系统的启动代码。
三、实验过程及结果1、编写第一个“操作系统”，代码如下：org 07c00hmov ax,csmov ds,axmov es,axcall DispStrjmp $DispStr:mov ax,BootMessagemov bp,axmov cx,16mov ax,01301hmov bx,00aehmov dl,0int 10hretBootMessage: db "hello,OS world!"times 510-($-$$) db 0dw 0xaa55结果如图：修改boot.asm，修改文字颜色，代码如下：org 07c00hmov ax,csmov ds,axmov es,axcall DispStrjmp $DispStr:mov ax,BootMessagemov bp,axmov cx,16mov ax,01301hmov bx,00aeh //在此处修改BL的值，可以修改颜色mov dl,0int 10hretBootMessage: db "hello,OS world! "times 510-($-$$) db 0dw 0xaa55结果如图：2.在bochs中运行geek OS，结果如图：四、实验分析思考：引导扇区的标志是0x55AA，为何代码中写入的却是 dw 0xAA55?答：因为存储时低位在前，高位在后，所以代码中高低位反过来写。
五、所遇问题及解决方法答：实验过程中，最大的困难就是理解geek OS的代码。
一个原因是我们没有学过有关汇编的知识，导致代码中有关汇编的部分一头雾水，难以理解；另一方面是之前自己接触的源码比较少，第一次见到geek OS这么大的工程代码，感觉理解起来很困难，不过，在老师花费了几个小时的讲解下，我最终还是勉强理解了一部分。
操作系统实验报告
操作系统实验报告实验目的本次实验的主要目的是通过自主设计和编写一个简单的操作系统内核，进一步加深对操作系统相关理论知识的理解和实践能力的锻炼。
同时，通过实际操作和调试，了解操作系统的基本功能和特性，提高对操作系统工作原理的深入认识。
实验环境在进行本次实验之前，我们需要先搭建实验环境。
以下是本次实验所需的环境配置： - 操作系统：Windows或Linux - 开发工具：gcc编译工具链、nasm汇编器、Bochs模拟器实验过程1.机器启动过程–计算机的启动过程主要包括电源启动、BIOS自检、加载操作系统等步骤。
–在本次实验中，我们需要自行编写一个简单的引导扇区程序，将其写入磁盘的MBR（Master Boot Record）位置，以完成系统的启动。
2.引导扇区编写与加载–引导扇区是计算机启动的关键部分，它的主要任务是加载操作系统的内核到内存中，并将控制权转交给内核。
–在本次实验中，我们可以使用汇编语言编写一个简单的引导扇区程序，并将其加载到MBR位置。
3.操作系统内核设计与实现–操作系统内核是整个操作系统的核心部分，它负责管理系统的资源和提供系统调度等功能。
–在本次实验中，我们可以设计和实现一个简单的操作系统内核，包括进程管理、内存管理、文件系统等功能。
4.系统调用设计与实现–系统调用是用户程序与操作系统之间的接口，用户程序通过系统调用请求操作系统提供的服务。
–在本次实验中，我们可以设计和实现一些基本的系统调用，如文件读写、进程创建等。
5.调试与测试–在进行操作系统开发的过程中，调试和测试是非常重要的环节。
–在本次实验中，我们可以使用Bochs模拟器来模拟运行我们编写的操作系统内核，并对其进行调试和测试。
实验结果与分析经过一段时间的编写和调试，我们成功地完成了一个简单的操作系统内核的设计和实现。
在实验过程中，我们深入理解了操作系统的工作原理和基本功能，提高了对操作系统相关知识的理解和应用能力。
同时，我们还进一步锻炼了编程和调试的实践能力。
《操作系统》课内实验报告
《操作系统》课内实验报告一、实验目的操作系统是计算机系统的核心组成部分，本次《操作系统》课内实验旨在通过实际操作和观察，深入理解操作系统的基本原理、功能和运行机制。
具体目的包括：1、熟悉操作系统的常用命令和操作，如文件管理、进程管理、内存管理等。
2、掌握操作系统的资源分配和调度策略，观察其对系统性能的影响。
3、培养解决操作系统相关问题的能力，提高动手实践和分析问题的能力。
二、实验环境本次实验在以下环境中进行：1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code三、实验内容及步骤（一）文件管理实验1、创建、删除和重命名文件及文件夹打开文件资源管理器，在指定目录下创建新的文件夹和文本文件。
对创建的文件和文件夹进行重命名操作，观察文件名的变化。
选择部分文件和文件夹进行删除操作，验证是否成功删除。
2、文件复制、移动和属性设置选取一些文件，将其复制到其他目录，并观察复制过程和结果。
把特定文件移动到不同的位置，检查文件是否正确迁移。
设置文件的属性，如只读、隐藏等，查看属性设置后的效果。
（二）进程管理实验1、查看系统进程打开任务管理器，观察当前正在运行的进程列表。
了解进程的名称、PID（进程标识符）、CPU 使用率、内存占用等信息。
2、进程的终止和优先级设置选择一个非关键进程，尝试终止其运行，观察系统的反应。
调整某些进程的优先级，观察其对系统资源分配和运行效率的影响。
（三）内存管理实验1、查看内存使用情况通过系统性能监视器，查看物理内存和虚拟内存的使用情况。
观察内存使用量随时间的变化趋势。
2、内存优化操作关闭一些不必要的后台程序，释放占用的内存资源。
调整虚拟内存的大小，观察对系统性能的改善效果。
四、实验结果与分析（一）文件管理实验结果1、成功创建、删除和重命名文件及文件夹，系统能够准确响应操作，文件名和文件夹名的修改即时生效。
2、文件的复制和移动操作顺利完成，数据无丢失和损坏。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。
同时，实现进程的正常终止和异常终止，并分析其对系统的影响。
2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。
通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。
（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。
2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。
（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。
观察文件在磁盘上的存储方式和文件系统的目录结构。
2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。
四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。
（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。
（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。
2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。
（2）创建多个进程，模拟对共享资源的并发访问。
（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。
（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
西北工业大学操作系统实验报告实验四
实验四进程与线程一、实验目的（1）理解进程的独立空间；（2）理解线程的相关概念。
二、实验内容与要求1、查阅资料，掌握进程创建和构造的相关知识和线程创建和构造的相关知识，了解C语言程序编写的相关知识；2、理解进程的独立空间的实验内容及步骤（1）编写一个程序，在其 main（）函数中定义一个变量 shared，对其进行循环加/减操作，并输出每次操作后的结果；（2）使用系统调用 fork（）创建子进程，观察该变量的变化；（3）修改程序把 shared变量定义到 main（）函数之外，重复第（2）步操作，观察该变量的变化。
3、理解线程的实验步骤（1）编写一个程序，在其 main（）函数中创建一个（或多个）线程，观察该线程是如何与主线程并发运行的。
输出每次操作后的结果；（2）在 main()函数外定义一个变量shared（全局变量），在main()中创建一个线程，在 main()中和新线程shared进行循环加/减操作，观察该变量的变化；（3）修改程序把shared变量定义到 main（）函数之内，重复第（2）步操作，观察该变量的变化。
4、对整个实验过程进行分析总结，给出详细步骤；(1) 观察上述进程执行结果，并分析原因；(2) 提交源程序清单，并附加流程图与注释。
三、实验过程1、进程的与线程的创建和构造(1).进程的创建和构造进程简单来说就是在操作系统中运行的程序，它是操作系统资源管理的最小单位。
但是进程是一个动态的实体，它是程序的一次执行过程。
进程和程序的区别在于：进程是动态的，程序是静态的，进程是运行中的程序，而程序是一些保存在硬盘上的可执行代码。
新的进程通过克隆旧的程序（当前进程）而建立。
fork()和clone()（对于线程）系统调用可用来建立新的进程。
（2）线程的创建和构造线程也称做轻量级进程。
就像进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。
西工大 操作系统实验报告
西工大操作系统实验报告西工大操作系统实验报告一、引言操作系统是计算机系统中最重要的软件之一，它负责管理计算机硬件和软件资源，为用户提供一个友好、高效的计算环境。
本次实验旨在通过实践操作系统的基本功能和原理，加深对操作系统的理解和掌握。
二、实验目的1. 理解操作系统的基本概念和作用；2. 学习操作系统的安装和配置；3. 掌握操作系统的文件管理和进程管理；4. 实践操作系统的调度算法和内存管理；5. 深入理解操作系统的并发控制和死锁处理。
三、实验环境本次实验使用的操作系统是Linux，具体版本为Ubuntu 20.04 LTS。
实验所需的软件和工具包括GCC编译器、Make工具、Vi编辑器等。
四、实验内容1. 操作系统的安装和配置首先，我们需要下载Ubuntu 20.04 LTS的镜像文件，并通过虚拟机软件创建一个虚拟机。
然后，按照提示进行操作系统的安装和配置，包括选择安装语言、分配磁盘空间、设置用户名和密码等。
安装完成后，我们可以登录系统，并进行一些基本设置，如修改主题、安装常用软件等。
2. 文件管理和进程管理操作系统的文件管理是指对计算机中的文件进行组织、存储和访问的过程。
我们可以使用命令行或图形界面来管理文件，包括创建文件、复制文件、删除文件等。
同时，操作系统还提供了进程管理的功能，可以管理计算机中运行的各个进程。
我们可以使用命令行或系统监视器来查看和管理进程，包括启动进程、终止进程、调整进程优先级等。
3. 调度算法和内存管理操作系统的调度算法是指决定哪个进程在何时执行的算法。
常见的调度算法包括先来先服务、短作业优先、轮转调度等。
我们可以通过修改系统的调度策略来改变进程的执行顺序。
另外，操作系统还负责管理计算机的内存资源，包括内存分配、内存回收等。
我们可以使用命令行或系统监视器来查看和管理内存，包括查看内存使用情况、释放内存空间等。
4. 并发控制和死锁处理操作系统需要保证多个进程之间的并发执行，同时又要避免出现竞争条件和死锁等问题。
操作系统实验
操作系统实验报告（一）Linux基本操作与编程（验证性 2学时）1、实验目(de)：1）熟悉Linux操作系统(de)环境和使用.2）了解LINUX系统(de)安装过程.（注：表示可选择）3）掌握Linux环境下(de)命令操作.2、实验内容：（1）完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求：结果以屏幕截图表示).1）运行pwd命令,确定你当前(de)工作目录.2）利用以下命令显示当前工作目录(de)内容： ls –l3）运行以下命令： ls –al4）使用mkdir命令建立一个子目录subdir.5）使用cd命令,将工作目录改到根目录（/）上.6）使用ls-l命令列出/dev(de)内容.7）使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8）使用命令cd ../..,你将工作目录移到什么地方（2）在LINUX下查看你(de)文件.1）利用cd命令,将工作目录改到你(de)主目录上.2）将工作目录改到你(de)子目录subdir,然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中.3）使用cat命令查看file1文件(de)内容.4）利用man命令显示date命令(de)用法： man date5）将date命令(de)用法附加到文件file1(de)后面：man date >> file16）利用cat命令显示文件file1(de)内容.7）利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8）利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9）利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10）用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.（3）编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤：1）在文本编辑器中,编写C程序如下：include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下：./a（4）编写一个程序：显示信息“Time for Play”,并能在后台运行一段时间（自定义）后,弹出信息提醒用户.要求记录所使用(de)命令及结果.（提示：使用sleep(s)函数）3、实验结果分析：（对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题）（1）进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性（2）在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行；正在运行(de)命令,使用Ctrl+z ,就挂起； jobs命令,可以现实后台,包括挂起(de)命令；使用 bg %作业号就可以把挂起(de)命令在后台执行；使用 fg %作业号就可以把后台命令调到前台（3）你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013（4）你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结：你对本次实验有什么体会或看法.操作系统实验报告（二）文件访问权限设置与输入输出重定向（2学时）一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限：在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作：chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限：chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行；其他用户和所属组用户只有读和执行(de)权限：chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道（1) 输出重定向用ls命令显示当前目录中(de)文件列表：ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中：ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令：cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向：ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别：cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.（2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤：在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论（根据实验结果回答下列问题）1. 文件(de)权限如下：-rw-r—r-- 1 root root 19274 Jul 14 11:00回答：-rw-r—r-- (de)含义是什么答：是LINUX/FTP(de)简易权限表示法：对应于本用户-所在组-其他人(de)权限,每一个用执行（x）-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答：chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答：chmod a+w,a+r 个人体会（你对本次实验有什么体会或看法）操作系统实验报告（三）文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令；2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题：1）vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2）在vi中退出时,保存并退出(de)操作步骤是Ese：wq3）用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令：cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4）请用至少两种不同(de)命令创建一个文本文件（）,在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________；用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限（数字和字母）分别是多少__-rw- r- - r- - 6 4 4______________.6）若将该文件(de)访问权限修改为：所有者有读写权限；其他用户只读；同组用户可读写,请写出命令,并记录结果.7）查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8）在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息；file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题：1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结（本次实验(de)体会或小结）操作系统实验报告（四）作业调度算法模拟（验证性2学时）1、实验目(de)：1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容：（1）作业调度算法（FCFS）编程模拟：编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1：FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}（2）作业调度算法（SJF）编程模拟：编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2：SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列：\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析：（对上述实验各题所使用(de)原始数据、调试数据与状态（包括出错）及最终结果进行记录并分析.）随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结：你对本次实验有什么体会或看法.。
操作系统实验4-4实验报告
操作系统实验4-4实验报告一、实验目的本次操作系统实验 4-4 的目的是深入了解和掌握操作系统中进程管理的相关知识和技术，通过实际操作和观察，加深对进程调度算法、进程同步与互斥等概念的理解，并提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程环境为 Visual Studio 2019。
三、实验内容1、进程调度算法的实现先来先服务（FCFS）算法短作业优先（SJF）算法时间片轮转（RR）算法优先级调度算法2、进程同步与互斥的实现使用信号量实现生产者消费者问题使用互斥锁实现哲学家进餐问题四、实验步骤1、进程调度算法的实现先来先服务（FCFS）算法设计数据结构来表示进程，包括进程ID、到达时间、服务时间等。
按照进程到达的先后顺序将它们放入就绪队列。
从就绪队列中选择第一个进程进行处理，计算其完成时间、周转时间和带权周转时间。
短作业优先（SJF）算法在设计的数据结构中增加作业长度的字段。
每次从就绪队列中选择服务时间最短的进程进行处理。
计算相关的时间指标。
时间片轮转（RR）算法设定时间片的大小。
将就绪进程按照到达时间的先后顺序放入队列。
每个进程每次获得一个时间片的执行时间，若未完成则重新放入队列末尾。
优先级调度算法为每个进程设置优先级。
按照优先级的高低从就绪队列中选择进程执行。
2、进程同步与互斥的实现生产者消费者问题创建一个共享缓冲区。
生产者进程负责向缓冲区中生产数据，消费者进程从缓冲区中消费数据。
使用信号量来控制缓冲区的满和空状态，实现进程的同步。
哲学家进餐问题模拟多个哲学家围绕一张圆桌进餐的场景。
每个哲学家需要同时获取左右两边的筷子才能进餐。
使用互斥锁来保证筷子的互斥访问，避免死锁的发生。
五、实验结果与分析1、进程调度算法的结果与分析先来先服务（FCFS）算法优点：实现简单，公平对待每个进程。
缺点：对短作业不利，平均周转时间可能较长。
短作业优先（SJF）算法优点：能有效降低平均周转时间，提高系统的吞吐量。
操作系统实验报告4
操作系统实验报告4一、实验目的本次操作系统实验的目的在于深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关操作，通过实际的实验操作，增强对操作系统原理的理解和应用能力，提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容与步骤（一）进程管理实验1、进程创建与终止使用 C+＋语言编写程序，创建多个进程，并在进程中执行不同的任务。
通过进程的标识符（PID）来监控进程的创建和终止过程。
2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
观察生产者和消费者进程在不同情况下的执行顺序和结果。
（二）内存管理实验1、内存分配与释放编写程序，使用动态内存分配函数（如｀malloc` 和｀free`）来分配和释放内存。
观察内存的使用情况和内存泄漏的检测。
2、内存页面置换算法实现几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法和最佳置换（OPT）算法。
通过模拟不同的页面访问序列，比较不同算法的性能。
（三）文件系统实验1、文件创建与读写使用 C+＋语言的文件操作函数，创建一个新文件，并向文件中写入数据。
从文件中读取数据，并进行数据的处理和显示。
2、文件目录操作实现对文件目录的创建、删除、遍历等操作。
观察文件目录结构的变化和文件的组织方式。
四、实验结果与分析（一）进程管理实验结果与分析1、进程创建与终止在实验中，成功创建了多个进程，并通过控制台输出观察到了每个进程的 PID 和执行状态。
可以看到，进程的创建和终止是按照程序的逻辑顺序进行的，操作系统能够有效地管理进程的生命周期。
2、进程同步与互斥在生产者消费者问题的实验中，通过信号量的控制，生产者和消费者进程能够正确地实现同步与互斥。
当缓冲区为空时，消费者进程等待；当缓冲区已满时，生产者进程等待。
操作系统实验报告
操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理和关键机制，包括进程管理、内存管理、文件系统以及设备管理等方面。
同时，培养我们解决实际问题的能力，提高对操作系统相关知识的综合运用水平。
二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux（Ubuntu 2004 LTS），实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容及步骤（一）进程管理实验1、进程创建与终止在 Windows 系统中，使用 C+＋语言编写程序，通过调用系统 API函数创建新的进程，并观察进程的创建和终止过程。
在 Linux 系统中，使用 C 语言编写程序，通过 fork(）系统调用创建子进程，并通过 wait(）函数等待子进程的终止。
2、进程调度观察Windows 和Linux 系统中进程的调度策略，包括时间片轮转、优先级调度等。
通过编写程序模拟进程的执行，设置不同的优先级和执行时间，观察系统的调度效果。
（二）内存管理实验1、内存分配与释放在 Windows 系统中，使用 C+＋语言的 new 和 delete 操作符进行内存的动态分配和释放，并观察内存使用情况。
在 Linux 系统中，使用 C 语言的 malloc(）和 free(）函数进行内存的分配和释放，通过查看系统的内存使用信息来验证内存管理的效果。
2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制，包括页表、地址转换等。
通过编写程序访问虚拟内存地址，观察系统的处理方式和内存映射情况。
（三）文件系统实验1、文件操作在 Windows 和 Linux 系统中，使用编程语言对文件进行创建、读取、写入、删除等操作。
观察文件的属性、权限设置以及文件在磁盘上的存储方式。
2、目录操作实现对目录的创建、删除、遍历等操作。
研究目录结构和文件路径的表示方法。
操作系统实验报告
操作系统实验报告操作系统是计算机科学中十分重要的一门课程，本次实验是关于操作系统的，通过实验，我们可以更深入地了解操作系统的相关知识和操作。
本篇文章将着重介绍本次操作系统实验的内容和实验过程中的收获。
一、实验内容本次实验内容主要涉及操作系统的进程、线程和进程同步三部分。
具体内容包括：1. 进程的创建和管理2. 线程的创建和管理3. 进程同步的实现在实验过程中，我们将分别使用C语言和Linux操作系统实现上述功能。
二、实验过程1. 进程的创建和管理在这一部分实验中，我们要创建多个进程，实现进程的调度和管理功能。
我们采用了Linux系统下的fork()函数，用于创建子进程。
在程序运行时，首先创建一个父进程，然后使用fork()函数创建四个子进程，每个子进程都有自己的进程号(pid)，并在屏幕上输出该进程号以示区分。
为了实现进程的调度功能，我们在代码中加入了sleep()函数，用于将进程挂起一段时间，然后再轮流执行其他进程。
2. 线程的创建和管理在这一部分实验中，我们使用了C语言的POSIX线程库pthread.h，实现多线程的功能。
同样地，我们采用了Linux系统下的fork()函数来创建线程。
在代码运行时，我们创建了两个线程，并在屏幕上输出线程号(tid)以示区分。
为了实现线程的调度和管理功能，我们在代码中加入了pthread_join()函数，用于等待线程的执行完成。
3. 进程同步的实现在这一部分实验中，我们使用了Linux系统下的进程同步工具——信号量(semaphore)。
在代码中，我们使用sem_init()函数创建信号量，使用sem_wait()函数阻塞进程或线程，使用sem_post()函数释放进程或线程。
为了更好地理解信号量的工作原理，我们将代码分为生产者和消费者两部分，其中生产者用于向缓冲区添加数据，消费者则用于删除数据。
在这个过程中，我们需要使用信号量控制生产者和消费者的数量，避免出现生产过多或消费过多的情况。
操作系统实验报告通用(两篇)2024
操作系统实验报告通用引言：操作系统是计算机系统中的一个重要组成部分，它主要负责管理计算机硬件和软件资源，并为用户提供一个友好的界面。
操作系统实验是计算机科学与技术专业的一门重要实践课程，通过实际操作和实验验证，可以深入理解操作系统的工作原理和实现方法。
本文将以《操作系统实验报告通用》为题，从引言概述、正文内容、总结等方面详细阐述操作系统实验的一般结构和内容。
概述：操作系统实验是计算机科学与技术专业的一门实践课程，通过实际操作和实验验证来了解操作系统的工作原理和实现方法。
在操作系统实验中，学生将学习操作系统的基本概念、运行机制和实现技术，并通过实验验证来加深对操作系统的理解。
操作系统实验通常涉及到操作系统的各个模块，如进程管理、文件系统、内存管理等，并通过实际操作来了解操作系统的具体实现。
操作系统实验通常包括实验报告、实验代码以及实验总结等部分。
正文内容：1. 实验背景和目的1.1 实验背景在操作系统实验中，学生将学习操作系统的基本概念、运行机制和实现技术，通过实验来了解操作系统的具体实现和应用。
1.2 实验目的操作系统实验的主要目的是通过实际操作和实验验证来加深对操作系统的理解，并培养学生的动手能力和解决问题的能力。
2. 实验内容2.1 实验一：进程管理进程管理是操作系统中的核心模块之一，它负责管理和调度系统中的进程。
在这个实验中，学生需实现一个简单的进程管理器，并能够模拟多个进程的并发执行和互斥访问。
2.2 实验二：文件系统文件系统是操作系统中的另一个重要模块，它负责管理和组织计算机中的文件和目录。
在这个实验中，学生需实现一个简单的文件系统，并能够进行文件的创建、打开、读写和关闭操作。
2.3 实验三：内存管理内存管理是操作系统中的关键模块之一，它负责管理系统中的内存资源。
在这个实验中，学生需实现一个简单的内存管理器，并能够进行内存的分配和释放操作。
2.4 实验四：设备管理设备管理是操作系统中的另一个重要模块，它负责管理和调度计算机中的各种设备。
操作系统课程实验报告
操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。
通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。
三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。
在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。
2、进程同步与互斥使用信号量实现进程之间的同步与互斥。
在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。
（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。
在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。
2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。
（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。
2、目录操作实现了目录的创建、删除、遍历等功能。
四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四进程与线程
一、实验目的
（1）理解进程的独立空间；
（2）理解线程的相关概念。
二、实验内容与要求
1、查阅资料，掌握进程创建和构造的相关知识和线程创建和构造的相关知识，了解C
语言程序编写的相关知识；
2、理解进程的独立空间的实验内容及步骤
（1）编写一个程序，在其 main（）函数中定义一个变量 shared，对其进行循环加/减操作，并输出每次操作后的结果；
（2）使用系统调用 fork（）创建子进程，观察该变量的变化；
（3）修改程序把 shared变量定义到 main（）函数之外，重复第（2）步操作，观察该变量的变化。
3、理解线程的实验步骤
（1）编写一个程序，在其 main（）函数中创建一个（或多个）线程，观察该线程是如何与主线程并发运行的。
输出每次操作后的结果；
（2）在 main()函数外定义一个变量shared（全局变量），在main()中创建一个线程，在 main()中和新线程shared进行循环加/减操作，观察该变量的变化；
（3）修改程序把shared变量定义到 main（）函数之内，重复第（2）步操作，观察该变量的变化。
4、对整个实验过程进行分析总结，给出详细步骤；
(1) 观察上述进程执行结果，并分析原因；
(2) 提交源程序清单，并附加流程图与注释。
三、实验过程
1、进程的与线程的创建和构造
(1).进程的创建和构造
进程简单来说就是在操作系统中运行的程序，它是操作系统资源管理的最小单位。
但是进程是一个动态的实体，它是程序的一次执行过程。
进程和程序的区别在于：进程是动态的，程序是静态的，进程是运行中的程序，而程序是一些保存在硬盘上的可执行代码。
新的进程通过克隆旧的程序（当前进程）而建立。
fork() 和clone()（对于线程）系统调用可用来建立新的进程。
（2）线程的创建和构造
线程也称做轻量级进程。
就像进程一样，线程在程序中是独立的、并发的执行路径，每个线程有它自己的堆栈、自己的程序计数器和自己的局部变量。
但是，与独立的进程相比，进程中的线程之间的独立程度要小。
它们共享内存、文件句柄和其他每个进程应有的状态。
线程的出现也并不是为了取代进程，而是对进程的功能作了扩展。
进程可以支持多个线程，它们看似同时执行，但相互之间并不同步。
一个进程中的多个线程共享相同的内存地址空间，这就意味着它们可以访问相同的变量和对象，而且它们从同一堆中分配对象。
尽管这让线程之间共享信息变得更容易，但你必须小心，确保它们不会妨碍同一进程里的其他线程。
线程与进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制，但与进程不同的是，同类的多个线程是共享同一块内存空间和一组系统资源的，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。
所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小得多，正因如此，线程也被称为轻型进程（light-weight process）。
一个进程中可以包含多个线程。
2、理解进程的独立空间
流程图如下所示：
（1）编写一个程序，在其 main（）函数中定义一个变量 shared，对其进行循环加/减操作，并输出每次操作后的结果
源程序如下所示:
#include <stdio.h>
int main()
{
int shared=1;
shared++;
printf("%d\n", shared);
shared--;
printf("%d\n", shared);
shared++;
printf("%d\n", shared);
shared--;
printf("%d\n", shared);
return 0;
}
运行结果如图所示：
（2）使用系统调用 fork（）创建子进程，观察该变量的变化
添加进程创建语句后，程序运行结果如下，子进程和父进程都执行了操作，且彼此之间对于同一个变量shared的自加操作互不影响。
代码如下图所示：
运行结果如下图所示：
（3）修改程序把 shared变量定义到 main（）函数之外，重复第（2）步操作，观察该变量的变化。
当把shared放到主函数之外时，运行结果和内部时相比，并未发生变化。
3、理解线程
流程图如下所示：
开始
开始设置全局变量shared
创建主进程
创建线程
输出Shared的值
结束
（1）编写一个程序，在其 main（）函数中创建一个（或多个）线程，观察该线程是如何与主线程并发运行的。
输出每次操作后的结果
源代码部分如下所示：
运行结果如下图所示：
原文链接：/view/21459.htm?fr=aladdin
（2）Linux开发模式与FreeBSD开发模式的比较。
（2）在 main()函数外定义一个变量shared（全局变量），在main()中创建一个线程，在 main()中和新线程shared进行循环加/减操作，观察该变量的变化
源代码如下所示：
运行结果如下图所示：
（3）修改程序把shared变量定义到 main（）函数之内，重复第（2）步操作，观察该变量的变化
部分代码截图如下：
在这种情况下，直接编译，会发生错误，截图如下：
四、实验分析与总结
1. 对于fork()语句的使用还是不够熟练和清楚，在使用的过程中过于心急，对
程序本真的内在含义理解不清楚，还要在课后认真的学习和弥补不足。
2. 实验过程中，交流很重要，不过还是要加强自己的学习能力，提高对程序的
理解能力和使用技巧。
3. 开始时不知道该如何构造线程，在查看了资料之后，开始稍微有些明白了，在
后面慢慢的实践过程中，逐步对线程的创建和使用等有了更加深入的了解。
4. 在理解线程的相关概念的实验中，应注意shared 的全局性和局部性，而且在
作为局部变量时，应注意print_thread_id()函数和pthread_create()函数的使用，因为后者的第四个参数是指针型变量，故在传递shared的值时应注意指针的使用。