西北工业大学-操作系统实验报告-实验四
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 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的值时应注意指针的使用。