华中科技大学计算机操作系统实验报告
华科操作系统实验
华科操作系统实验 Corporation standardization office #QS8QHH-HHGX8Q8-GNHHJ8课程实验报告课程名称：操作系统课程设计专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院目录实验1：进程并发实验1.1 实验概述通过本次进程并发实验，让同学更加熟悉和理解Linux编程环境。
1.2 实验内容本次实验的内容主要分为两个任务：1.编写一个C程序，用read、write等系统调用实现文件拷贝功能。
命令形式：copy <源文件名> <目标文件名>2. 编写一个C程序，使用图形编程库 (QT/GTK)分窗口显示三个并发进程的运行(一个窗口实时显示当前系统时间，一个窗口循环显示0到9，一个窗口做1到1000的累加求和，刷新周期均为1秒)。
1.3 实验设计任务1：实验1的第一个阶段需要实现一个简单的C语言程序，首先需要有一个复制的源文件，同时需要创建一个存放复制内容的复制文件，文件复制传输的中间站可以设置一个缓冲数组，此次试验设计了一个大小为10个字节的数组。
打开复制源文件，返回一个INT标识，使用readbuf（）函数，每次读取10个字节的内容，将内容存放到缓冲区数组，使用writebuf（）函数将缓冲区的10个字节写到复制文件中，重复上述过程直到将整个复制过程完成。
任务2：实验的第二个阶段是实现进程的同步，实现的工具是QT。
主要实现3个进程的同步，3个进程分别为：实时显示系统时间、循环显示0-9、显示1-1000的累加和。
以上程序的刷新时间设置为1秒钟。
使用的是c++编程语言。
为了实现3个进程。
需要为这3个进程分别创建3个不同的类，这3个不用的类具有不同的成员函数，使用成员函数来实现进程的所代表的具体细节。
为了实现进程的结果能实时更新，需要调用connect（）函数，该函数的功能是每当其中的timer每次发生变化时，就回调用该类的成员函数，也就是进程的具体实现，从而实时显示进程的细节内容。
操作系统实验报告--华科
实验一哲学家就餐问题一、实验目的1、熟练使用VC++6.0编译环境，调试并正确运行程序。
2、理解哲学家就餐问题中出现的问题，进而掌握死锁的必要条件。
3、理解源程序中产生和防止死锁的算法，及相关窗口操作。
4、熟悉哲学家就餐问题流程。
5、在VC++6.0环境下编译哲学家就餐问题演示程序，考虑其他解决死锁方法.二、实验原理1、问题描述有五个哲学家围坐在一圆桌旁，桌中央有一盘通心粉，每人面前有一只空盘子，每两人之间放一只筷子。
每个哲学家的行为是思考，感到饥饿，然后吃通心粉。
为了吃通心粉，每个哲学家必须拿到两只筷子，并且每个人只能直接从自己的左边或右边去取筷子。
2、分配方式方式一（不会进入死锁）仅当一个哲学家左右两边的筷子都可用时，才允许他拿筷子。
这样要么一次占有两只筷子（所有线程需要的资源）进行下一步的吃通心粉，然后释放所有的资源；要么不占用资源，这样就不可能产生死锁了。
方式二（会进入死锁）当筷子（资源）可用时，先分配左边的筷子，等待一会后再分配右边的筷子，由于这个过程中，左边的筷子一直没有释放，就有可能产生死锁了。
3、程序运行说明程序运行过程中会弹出一个MessageBox提示操作者操作：1）第一个对话框用于选择运行模式a．选择yes 表示采用的是运行的防止死锁的方式，这样的话整个程序可以一直运行下去，不会产生死锁。
b．选择no 表示运行产生死锁的方式会弹出第二个对话框。
2）第二个对话框用于选择运行时，线程运行的时间a. 选择res 线程时间比较短，很快就可以死锁b．选择no 线程时间跟选择yes 时候的时间差不多，产生死锁的时间稍微长一点。
三、实验过程及分析1、伪代码：1) 不发生死锁的方式（要么一下占用两支筷子，要么不占用）var mutexleftchopstick,mutexrightchopstick;beging:resting;waiting;p(mutexleftchopstick); //先改变左手筷子信号量p(mutexrightchopstick); //马上改变右手筷子信号量GetResource(leftchopstick,rightchopstick);eating;v(mutexleftchopstick);v(mutexrightchopstick);end2) 发生死锁的方式（一旦可以占用筷子，就马上占用）var mutexleftchopstick,mutexrightchopstick;beging:resting;waiting;p(mutexleftchopstick); //改变左手筷子信号量GetResource(leftchopstick); //获取左手筷子p(mutexrightchopstick); //改变右手筷子信号量GetResource(rightchopstick); //获取右手筷子eating;v(mutexleftchopstick);v(mutexrightchopstick);end2、代码分析：1）不发生死锁的方式：先确定两只筷子均没被占用才获取筷子，这样就打破了死锁的必要条件。
操作系统实验实验报告
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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 等进行文件的创建、读取和写入操作。
计算机操作系统实验报告
中南大学计算机操作系统实验报告................................................................................................................................................................................................................1、增强学生对计算机操作系统基本原理、基本理论、基本算法的理解；2、提高和培养学生的动手能力。
1、每人至少选作1 题，多做不限；2、每人单独完成，可以讨论，但每人的设计内容不得彻底相同，抄袭或者有2 人/多人设计彻底一样者，不能通过；3、设计完成后，应上交课程设计文档，文档格式应是学校课程设计的标准格式，所有学生的封面大小、格式也必须一样；4、同时上交设计的软盘(或者以班刻录光盘)。
调度算法的摹拟：摹拟各种调度算法，并进行调度性能分析。
摹拟了一个作业调度算法，其中用到了先来先服务算法(FCFS)、短作业优先算法(SJF)、最高响应比优先算法(HRN)三种算法。
如下，分别为三种算法的程序流程图。
图1 - 开始界面图 2 –输入作业的信息(名字、提交时间、运行时间) 图3 –选择算法(FCFS 、SJF、HRN)图4、5 –选择FCFS 算法后输出结果图6、7 –选择SJF 算法后输出结果图8、9 –选择HRN 算法后输出结果能体现公平性；一旦一个较长的作业进入系统后就会长期的占用系统的资源，这样如果有优先级较高的短作业需要执行的话需要等待很长期。
比前者改善了平均周转时间和平均带权周转时间，缩短作业的等待时间，提高系统的吞吐量；对长作业非常不利，可能长期得不到执行，未能一句作业的紧迫程度来划分执行的优先级，难以准确估计作业的执行时间，从而影响调度性能。
这种算法是对FCFS 方式和SJF 方式的一种综合平衡。
操作系统实验报告6
操作系统实验报告6一、实验目的本次操作系统实验的主要目的是深入了解和掌握操作系统中进程管理、内存管理、文件系统等核心概念和相关技术，通过实际操作和观察，增强对操作系统工作原理的理解，并提高解决实际问题的能力。
二、实验环境本次实验使用的操作系统为 Windows 10，实验工具包括 Visual Studio 2019 等。
三、实验内容（一）进程管理实验1、创建多个进程，并观察它们的运行状态和资源占用情况。
通过编写简单的C+＋程序，使用Windows API 函数创建多个进程。
在程序中，设置不同的进程优先级和执行时间，观察操作系统如何调度这些进程，以及它们对 CPU 使用率和内存的影响。
2、进程间通信实现了进程间的管道通信和消息传递。
通过创建管道，让两个进程能够相互交换数据。
同时，还使用了 Windows 的消息机制，使进程之间能够发送和接收特定的消息。
（二）内存管理实验1、内存分配与释放使用 C+＋的动态内存分配函数（如｀malloc` 和｀free`），在程序运行时动态申请和释放内存。
观察内存使用情况，了解内存碎片的产生和处理。
2、虚拟内存管理研究了 Windows 操作系统的虚拟内存机制，通过查看系统的性能监视器，观察虚拟内存的使用情况，包括页面文件的大小和读写次数。
（三）文件系统实验1、文件操作进行了文件的创建、读取、写入、删除等基本操作。
通过编写程序，对不同类型的文件（如文本文件、二进制文件）进行处理，了解文件系统的工作原理。
2、目录操作实现了目录的创建、删除、遍历等功能。
了解了目录结构在文件系统中的组织方式和管理方法。
四、实验步骤（一）进程管理实验步骤1、打开 Visual Studio 2019，创建一个新的 C+＋控制台项目。
2、在项目中编写代码，使用｀CreateProcess` 函数创建多个进程，并设置它们的优先级和执行时间。
3、编译并运行程序，通过任务管理器观察进程的运行状态和资源占用情况。
华科操作系统实验
课程实验报告课程名称：操作系统课程设计专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院目录实验1：进程并发实验 (1)实验概述 (1)实验内容 (1)实验设计 (1)实验过程 (2)实验结果 (6)实验小结 (7)实验2：添加系统功能调用 (8)实验概述 (8)实验内容 (8)阶段1 添加源代码 (8)阶段2 连接新的系统功能调用 (9)阶段3 重建内核 (10)阶段4 修改grub文件 (13)实验小结 (14)实验3：添加设备驱动程序 (15)实验概述 (15)实验内容 (15)阶段1 编写设备驱动程序 (15)阶段2 编译设备驱动模块 (16)阶段3 加载设备驱动模块 (17)阶段4 生成设备文件 (18)阶段5 编写应用程序测试 (18)实验小结 (19)实验总结 (20)实验1：进程并发实验实验概述通过本次进程并发实验，让同学更加熟悉和理解Linux编程环境。
实验内容本次实验的内容主要分为两个任务：1.编写一个C程序，用read、write等系统调用实现文件拷贝功能。
命令形式：copy <源文件名> <目标文件名>2.编写一个C程序，使用图形编程库 (QT/GTK)分窗口显示三个并发进程的运行(一个窗口实时显示当前系统时间，一个窗口循环显示0到9，一个窗口做1到1000的累加求和，刷新周期均为1秒)。
实验设计任务1：实验1的第一个阶段需要实现一个简单的C语言程序，首先需要有一个复制的源文件，同时需要创建一个存放复制内容的复制文件，文件复制传输的中间站可以设置一个缓冲数组，此次试验设计了一个大小为10个字节的数组。
打开复制源文件，返回一个INT标识，使用readbuf（）函数，每次读取10个字节的内容，将内容存放到缓冲区数组，使用writebuf（）函数将缓冲区的10个字节写到复制文件中，重复上述过程直到将整个复制过程完成。
任务2：实验的第二个阶段是实现进程的同步，实现的工具是QT。
计算机操作系统实验报告
计算机操作系统实验报告一、实验目的本次计算机操作系统实验的主要目的是深入了解操作系统的工作原理和功能，通过实际操作和观察，增强对操作系统概念的理解，提高解决实际问题的能力。
二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio 20193、编程语言：C+＋三、实验内容1、进程管理实验创建多个进程，并观察它们的执行顺序和资源占用情况。
使用进程控制块（PCB）来跟踪进程的状态变化，如就绪、运行、阻塞等。
2、内存管理实验模拟内存分配和回收算法，如首次适应算法、最佳适应算法和最坏适应算法。
观察不同算法在内存利用率和分配效率方面的表现。
3、文件系统实验创建、读取、写入和删除文件，了解文件的操作流程。
研究文件的存储结构和目录管理方式。
4、线程同步与互斥实验使用互斥锁和信号量来实现线程之间的同步和互斥操作。
观察在多线程环境下资源竞争和同步的效果。
四、实验步骤1、进程管理实验步骤编写 C+＋程序，使用系统调用创建多个进程。
在每个进程中输出进程的标识符和当前执行时间。
通过观察控制台输出，分析进程的执行顺序和资源占用情况。
2、内存管理实验步骤实现不同的内存分配算法，并在程序中模拟内存请求和释放的过程。
记录每次内存分配和回收的结果，计算内存利用率和分配时间。
3、文件系统实验步骤使用文件操作函数创建文件，并写入一些数据。
读取文件中的数据，并将其输出到控制台。
删除文件，观察文件系统的变化。
4、线程同步与互斥实验步骤创建多个线程，共享一些公共资源。
在访问公共资源的代码段前使用互斥锁或信号量进行同步控制。
观察线程的执行结果，确保资源的正确访问和修改。
五、实验结果与分析1、进程管理实验结果与分析实验结果显示，进程的执行顺序是不确定的，取决于操作系统的调度策略和进程的优先级。
资源占用情况也因进程的不同而有所差异，一些进程可能占用较多的 CPU 时间和内存，而另一些则相对较少。
2、内存管理实验结果与分析首次适应算法在分配速度上较快，但容易产生内存碎片。
华科操作系统实验报告
华科操作系统实验报告一、实验目的操作系统是计算机系统的核心组成部分，对于理解计算机的工作原理和提高计算机应用能力具有重要意义。
本次华科操作系统实验的主要目的是通过实际操作和实践，深入理解操作系统的基本概念、原理和功能，掌握操作系统的核心技术和应用方法，提高我们的实践能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 2004），开发工具包括 Visual Studio Code、GCC 编译器等。
实验硬件环境为个人计算机，配置为英特尔酷睿 i7 处理器、16GB 内存、512GB 固态硬盘。
三、实验内容1、进程管理进程创建与销毁进程调度算法模拟进程同步与互斥2、内存管理内存分配与回收算法实现虚拟内存管理3、文件系统文件操作与管理文件系统的实现与优化4、设备管理设备驱动程序编写设备分配与回收四、实验步骤及结果1、进程管理实验进程创建与销毁首先，使用 C 语言编写程序，通过系统调用创建新的进程。
在程序中，使用 fork(）函数创建子进程，并在子进程和父进程中分别输出不同的信息，以验证进程的创建和执行。
实验结果表明，子进程和父进程能够独立运行，并输出相应的信息。
进程调度算法模拟实现了先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）三种进程调度算法。
通过模拟多个进程的到达时间、服务时间和优先级等参数，计算不同调度算法下的平均周转时间和平均等待时间。
实验结果显示，SJF 算法在平均周转时间和平均等待时间方面表现较好，而 RR 算法能够提供较好的响应时间和公平性。
进程同步与互斥使用信号量和互斥锁实现了进程的同步与互斥。
编写了生产者消费者问题的程序，通过信号量控制生产者和消费者对缓冲区的访问，避免了数据竞争和不一致的情况。
实验结果表明，信号量和互斥锁能够有效地实现进程间的同步与互斥，保证程序的正确性。
2、内存管理实验内存分配与回收算法实现实现了首次适应（First Fit）、最佳适应（Best Fit）和最坏适应（Worst Fit）三种内存分配算法。
华科操作系统实验报告
课程实验报告课程名称：操作系统课程设计专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院课程设计任务书一．课设目的1.掌握Linux操作系统的使用方法；2.了解Linux系统核代码结构；3.掌握实例操作系统的实现方法。
二．课设容1.掌握Linux操作系统的使用方法，包括键盘命令、系统调用；掌握在Linux下的编程环境。
（一）编一个C程序，其容为实现文件拷贝的功能；（二）编一个C程序，其容为分窗口同时显示三个并发进程的运行结果。
要求用到Linux下的图形库。
gtk/qt2.掌握系统调用的实现过程，通过编译核方法，增加一个新的系统调用。
另编写一个应用程序，调用新增加的系统调用（实现的功能为文件拷贝）。
3.掌握增加设备驱动程序的方法。
通过模块方法，增加一个新的设备驱动程序，其功能可以简单（实现字符设备的驱动）。
4.了解和掌握/proc文件系统的特点和使用方法（选做）（一）了解/proc文件的特点和使用方法（二）监控系统状态，显示系统中若干部件使用情况（三）用图形界面实现系统监控状态。
5.设计并实现一个模拟的文件系统（选做）多用户的多级目录的文件系统设计。
多用户、多级目录、login (用户登录)、系统初始化（建文件卷、提供登录模块）、文件的创建、文件的打开、文件的读、文件的写、文件关闭、删除文件、创建目录（建立子目录）、改变当前目录、列出文件目录、退出。
三．课设说明Linux系统版本：Fedora 5.0 6.0 …ubuntu 10.04 11.10核版本：linux-2.6.x四．考核要求1．必须独立完成课程设计容，不分小组，不能有相同的拷贝。
2．上机考试：学生根据老师提出的要求，演示所完成的系统；并回答老师的问题。
3．第三周五下午2:00全体到实验室做中期检查，只检查1、2题；第四周周五下午2:00：最后检查。
按学号次序逐个检查。
4．评分方法：完成1、2题，得60-65分；完成1、2、3题，得65-75分；完成1、2、3、4（5）题，得80--100分；报告：10分(倒扣分)上交：课程设计报告(打印/电子档)，容包括调试记录和程序清单(附注释)。
《操作系统》课程实验报告
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境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）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。
计算机操作系统实验报告
实验名称：操作系统原理与实现实验日期：2021年10月15日实验班级：计算机科学与技术1班实验目的：1. 理解操作系统的基本概念和功能。
2. 掌握操作系统的基本原理和实现方法。
3. 通过实验加深对操作系统核心功能的理解。
实验内容：一、实验背景操作系统是计算机系统中最重要的系统软件之一，它负责管理和控制计算机硬件与软件资源，为用户提供一个良好的工作环境。
本次实验旨在通过实践操作系统的基本原理和实现方法，加深对操作系统核心功能的理解。
二、实验环境1. 操作系统：Windows 102. 开发环境：Visual Studio 20193. 实验工具：C++语言三、实验步骤1. 创建一个简单的进程管理器（1）定义进程结构体```cppstruct Process {int pid; // 进程IDint priority; // 进程优先级int status; // 进程状态（0：就绪，1：运行，2：阻塞，3：结束）// ... 其他进程信息};```（2）初始化进程表```cppconst int MAX_PROCESS = 10; // 最大进程数Process process[MAX_PROCESS]; // 进程表```（3）实现进程调度算法```cpp// 实现先来先服务（FCFS）调度算法void fcfsSchedule() {for (int i = 0; i < MAX_PROCESS; i++) {if (process[i].status == 0) { // 就绪状态 process[i].status = 1; // 运行状态// ... 执行进程process[i].status = 3; // 结束状态}}}```（4）实现进程创建、销毁和阻塞```cpp// 创建进程void createProcess(int pid, int priority) {for (int i = 0; i < MAX_PROCESS; i++) {if (process[i].pid == 0) { // 找到空闲进程 process[i].pid = pid;process[i].priority = priority;process[i].status = 0;break;}}}// 销毁进程void destroyProcess(int pid) {for (int i = 0; i < MAX_PROCESS; i++) {if (process[i].pid == pid) {process[i].pid = 0;process[i].priority = 0;process[i].status = 0;break;}}}// 阻塞进程void blockProcess(int pid) {for (int i = 0; i < MAX_PROCESS; i++) {if (process[i].pid == pid) {process[i].status = 2; // 阻塞状态 break;}}}```2. 创建一个简单的文件系统（1）定义文件结构体```cppstruct File {int fileID; // 文件IDchar fileName[50]; // 文件名int fileSize; // 文件大小// ... 其他文件信息};```（2）初始化文件表```cppconst int MAX_FILE = 10; // 最大文件数File file[MAX_FILE]; // 文件表（3）实现文件操作```cpp// 创建文件void createFile(int fileID, const char fileName, int fileSize) { for (int i = 0; i < MAX_FILE; i++) {if (file[i].fileID == 0) { // 找到空闲文件file[i].fileID = fileID;strcpy(file[i].fileName, fileName);file[i].fileSize = fileSize;break;}}}// 删除文件void deleteFile(int fileID) {for (int i = 0; i < MAX_FILE; i++) {if (file[i].fileID == fileID) {file[i].fileID = 0;file[i].fileSize = 0;break;}}// 打开文件void openFile(int fileID) {// ... 打开文件操作}// 关闭文件void closeFile(int fileID) {// ... 关闭文件操作}```四、实验结果与分析通过本次实验，我们成功实现了进程管理器和文件系统的基本功能。
华科操作系统实验报告
课程实验报告课程名称：操作系统原理专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院目录目录 (2)实验一：线程的同步 (3)一、实验目的 (3)二、实验内容 (3)三、实验心得 (6)实验二：誊抄实验的进程实现 (7)一、实验目的 (7)二、实验内容 (7)三、实验心得 (10)实验三：Linux文件目录操作 (12)一、实验目的 (12)二、实验内容 (12)三、实验心得 (14)实验一：线程的同步一、实验目的1、掌握Linux系统用户界面中键盘命令的使用。
2、学会一种Linux下的编程环境。
3、掌握Linux下进（线）程的概念。
4、了解Linux进程同步与通信的主要机制，并通过信号灯操作实现进程间的同步与互斥。
二、实验内容1、程序要求两个线程,共享公共变量a线程1负责计算(+1)线程2负责打印2、运行环境软件配置（含操作系统版本）：ubuntu - 14.10硬件：PC3、源程序源程序：#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <sys/types.h>#include <sys/sem.h>#include <sys/ipc.h>int semid;int a=0;typedef union senum{int val;struct semid_ds *buf;unsigned short *array;struct seminfo *_buf;}SEM_CTL_UN;void P(int semid,int index){struct sembuf sem; sem.sem_num = index; sem.sem_op = -1;//P sem.sem_flg = 0;//biaoji semop(semid,&sem,1); }void V(int semid,int index) {struct sembuf sem; sem.sem_num = index; sem.sem_op = 1; sem.sem_flg = 0; semop(semid,&sem,1); }void* thread1(void *arg) {int i=0;for(i;i<8;i++){P(semid,0);printf("add:\n");a=a+1;printf("a=%d\n",a);V(semid,1);}}void* thread2(void *arg) {int i=0;for(i;i<8;i++){P(semid,1);printf("print:\n");printf("a=%d\n",a);V(semid,0);}}int main(){pthread_t id1,id2;int ret1,ret2;key_t key;SEM_CTL_UN semctlarg1;SEM_CTL_UN semctlarg2;key=1;semid=semget(key,2,IPC_CREAT|0666);//创建semctlarg1.val=1;semctlarg2.val=0;semctl(semid,0,SETV AL,semctlarg1);//初始化semctl(semid,1,SETV AL,semctlarg2);ret1=pthread_create(&id1,NULL,thread1,NULL);ret2=pthread_create(&id2,NULL,thread2,NULL);pthread_join(id1,NULL);pthread_join(id2,NULL);}4、实验结果实验结果截图如下：图1-1 线程同步三、实验心得通过本次实验，我掌握了Linux系统用户界面中键盘命令的使用，熟悉了Linux下的编程环境，进一步理解并掌握了线程的概念，了解了线程同步与通信的主要机制，并能通过信号灯操作实现线程间的同步和互斥。
操作系统实验报告三
操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能，通过实际操作和观察，增强对操作系统原理的理解和掌握，提高解决实际问题的能力。
二、实验环境本次实验在 Windows 10 操作系统环境下进行，使用了 Visual Studio 2019 作为编程工具，并借助了相关的操作系统模拟软件和调试工具。
三、实验内容与步骤（一）进程管理实验1、创建多个进程使用 C+＋语言编写程序，通过调用系统函数创建多个进程。
观察每个进程的运行状态和资源占用情况。
2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
分析在不同并发情况下程序的执行结果，理解进程同步的重要性。
（二）内存管理实验1、内存分配与回收实现一个简单的内存分配算法，如首次适应算法、最佳适应算法或最坏适应算法。
模拟内存的分配和回收过程，观察内存的使用情况和碎片产生的情况。
2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制，通过查看系统性能监视器观察虚拟内存的使用情况。
编写程序来模拟虚拟内存的页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。
（三）文件系统实验1、文件操作使用 C+＋语言对文件进行创建、读写、删除等操作。
观察文件在磁盘上的存储方式和文件目录的结构。
2、文件系统性能测试对不同大小和类型的文件进行读写操作，测量文件系统的读写性能。
分析影响文件系统性能的因素，如磁盘碎片、缓存机制等。
四、实验结果与分析（一）进程管理实验结果1、创建多个进程在创建多个进程的实验中，通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。
多个进程可以并发执行，提高了系统的资源利用率。
2、进程同步与互斥在生产者消费者问题的实验中，当使用正确的信号量机制时，生产者和消费者能够协调工作，不会出现数据不一致或死锁的情况。
华中科技大学计算机系统基础实验报告
课程实验报告课程名称：计算机系统基础专业班级：学号：姓名：指导教师：报告日期：2016年5月24 日计算机科学与技术学院目录实验1： (3)实验2： (13)实验3： (28)实验总结 (37)实验1：数据表示1.1 实验概述本实验的目的是更好地熟悉和掌握计算机中整数和浮点数的二进制编码表示。
实验中,你需要解开一系列编程“难题”——使用有限类型和数量的运算操作实现一组给定功能的函数,在此过程中你将加深对数据二进制编码表示的了解。
实验语言:c; 实验环境: linux1.2 实验内容需要完成bits.c 中下列函数功能,具体分为三大类:位操作、补码运算和浮点数操作。
1.3 实验设计源码如下：/** lsbZero - set 0 to the least significant bit of x* Example: lsbZero(0x87654321) = 0x87654320* Legal ops: ! ~ & ^ | + << >>* Max ops: 5* Rating: 1*/int lsbZero(int x) {//x右移一位再左移一位实现把最低有效位置0x = x>>1;x = x<<1;return x;}/** byteNot - bit-inversion to byte n from word x* Bytes numbered from 0 (LSB) to 3 (MSB)* Examples: getByteNot(0x12345678,1) = 0x1234A978* Legal ops: ! ~ & ^ | + << >>* Max ops: 6* Rating: 2*/int byteNot(int x, int n) {//x第n个字节每位都和1异或实现取反int y = 0xff;n = n<<3;y = y<<n;x = (x^y);return x;}/** byteXor - compare the nth byte of x and y, if it is same, return 0, ifnot, return 1* example: byteXor(0x12345678, 0x87654321, 1) = 1* byteXor(0x12345678, 0x87344321, 2) = 0* Legal ops: ! ~ & ^ | + << >>* Max ops: 20* Rating: 2*/int byteXor(int x, int y, int n) {//把x和y的第n个字节取出来异或，再转换为逻辑的0和1 n = n<<3;x = x>>n;y = y>>n;x = x&(0xff);y = y&(0xff);return !!(x^y);}/** logicalAnd - x && y* Legal ops: ! ~ & ^ | + << >>* Max ops: 20* Rating: 3*/int logicalAnd(int x, int y) {//把x和y分别转化为逻辑的0和1，再相与x = (!(!x))&(!(!y));return x;}/** logicalOr - x || y* Legal ops: ! ~ & ^ | + << >>* Max ops: 20* Rating: 3*/int logicalOr(int x, int y) {//把x和y分别转化为逻辑的0和1，再相或x = (!(!x))|(!(!y));return x;}/** rotateLeft - Rotate x to the left by n* Can assume that 0 <= n <= 31* Examples: rotateLeft(0x87654321,4) = 0x76543218 * Legal ops: ~ & ^ | + << >> !* Max ops: 25* Rating: 3*/int rotateLeft(int x, int n) {//先构造低n位为1，高（32-n）位为0的数z，x左移n位后的数加上x右移（32-n）位的数&z即可int z;z = ~(((1<<31)>>31)<<n);x = ((x>>(32+(~n+1)))&z)+(x<<n);return x;}/** parityCheck - returns 1 if x contains an odd number of 1's* Examples: parityCheck(5) = 0, parityCheck(7) = 1* Legal ops: ! ~ & ^ | + << >>* Max ops: 20* Rating: 4*/int parityCheck(int x) {//每次将数的低半数位与高半数位比较，再把y右移31位，最后把y转化为逻辑的0和1int y;y = x<<16;y = y^x;y = y^(y<<8);y = y^(y<<4);y = y^(y<<2);y = y^(y<<1);y = y>>31;return !(!y);}/** mul2OK - Determine if can compute 2*x without overflow * Examples: mul2OK(0x30000000) = 1* mul2OK(0x40000000) = 0** Legal ops: ~ & ^ | + << >>* Max ops: 20* Rating: 2*/int mul2OK(int x) {//把x第31位和30位分别和1做按位与，再异或，再和1异或int m;m = ((x>>31)&0x1)^((x>>30)&0x1);return m^0x1;}/** mult3div2 - multiplies by 3/2 rounding toward 0,* Should exactly duplicate effect of C expression (x*3/2),* including overflow behavior.* Examples: mult3div2(11) = 16* mult3div2(-9) = -13* mult3div2(1073741824) = -536870912(overflow)* Legal ops: ! ~ & ^ | + << >>* Max ops: 12* Rating: 2*/int mult3div2(int x) {//左移一位再+x即x*3,右移一位的时候，当y的最高位和最低位都为0时还要+1int y = (x<<1)+x;y = (y>>1)+(((y>>31)&1)&(((y<<31)>>31)&1));return y;}/** subOK - Determine if can compute x-y without overflow* Example: subOK(0x80000000,0x80000000) = 1,* subOK(0x80000000,0x70000000) = 0,* Legal ops: ! ~ & ^ | + << >>* Max ops: 20* Rating: 3*/int subOK(int x, int y) {//x的最高有效位和y的最高有效位不同且x和（x-y）的最高位不同才能判断溢出int m = (x>>31)&1;int n = (y>>31)&1;x = (m^n)&(m^(((x+(~y+1))>>31)&1));return (!x);}/** absVal - absolute value of x* Example: absVal(-1) = 1.* You may assume -TMax <= x <= TMax* Legal ops: ! ~ & ^ | + << >>* Max ops: 10* Rating: 4*/int absVal(int x) {//x最高位为0时就是x，最高位为1时是～x+1int y = x>>31;x = (y&(~x+1))+((~y)&x);return x;}/** float_abs - Return bit-level equivalent of absolute value of f for* floating point argument f.* Both the argument and result are passed as unsigned int's, but* they are to be interpreted as the bit-level representations of* single-precision floating point values.* When argument is NaN, return argument..* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while * Max ops: 10* Rating: 2*/unsigned float_abs(unsigned uf) {int x=uf&(~(1<<31));if(x>0x7f800000){return uf;else return x;}/** float_f2i - Return bit-level equivalent of expression (int) f* for floating point argument f.* Argument is passed as unsigned int, but* it is to be interpreted as the bit-level representation of a* single-precision floating point value.* Anything out of range (including NaN and infinity) should return * 0x80000000u.* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while * Max ops: 30* Rating: 4*/int float_f2i(unsigned uf) {unsigned num=0x80000000;int x=(uf&0x007fffff)^0x00800000;int order=0;order=(uf&0x7f800000)>>23;if(order>158){return num;if(order<127) return 0;else if(((uf>>31)&1)==1){if(order>150){return ~(x<<(order-150))+1;}else return ~(x>>(150-order))+1;}else{if(order>150) return x<<(order-150);else return x>>(150-order);}}1.4 实验过程编写源码，运行btest，得出实验结果。
华中科技大学操作系统实验报告
华中科技大学电信学院操作系统实验报告电子信息与通信学院班级：电信1202班姓名：XX学号：U2012133XX时间：2014年11月5日实验一哲学家就餐问题一．实验目的1.熟悉哲学家就餐问题流程，编译程序，了解程序运行过程。
2.理解利用设置信号量及P、V操作解决进程间的互斥这一方法，并了解其代码实现的相关方法，提炼出代码的思想（用伪代码表示）。
3.对哲学家就餐问题提出新的解决方式，并简述其实现过程。
二．实验原理1、问题描述有五个哲学家围坐在一圆桌旁，桌中央有一盘通心粉，每人面前有一只空盘子，每两人之间放一只筷子。
每个哲学家的行为是思考，感到饥饿，然后吃通心粉。
为了吃通心粉，每个哲学家必须拿到两只筷子，并且每个人只能直接从自己的左边或右边去取筷子。
2、分配方式方式一（不会进入死锁）仅当一个哲学家左右两边的筷子都可用时，才允许他拿筷子。
这样要么一次占有两只筷子（所有线程需要的资源）进行下一步的吃通心粉，然后释放所有的资源；要么不占用资源，这样就不可能产生死锁了。
方式二（会进入死锁）当筷子（资源）可用时，先分配左边的筷子，等待一会后再分配右边的筷子，由于这个过程中，左边的筷子一直没有释放，就有可能产生死锁了。
3、程序运行说明程序运行过程中会弹出一个MessageBox提示操作者操作：1）第一个对话框用于选择运行模式a．选择yes 表示采用的是运行的防止死锁的方式，这样的话整个程序可以一直运行下去，不会产生死锁。
b．选择no 表示运行产生死锁的方式会弹出第二个对话框。
2）第二个对话框用于选择运行时，线程运行的时间a. 选择 res 线程时间比较短，很快就可以死锁b．选择no 线程时间跟选择yes 时候的时间差不多，产生死锁的时间稍微长一点。
三．实验程序流程及分析1、PhilosopherThread函数源代码DWORD WINAPI PhilosopherThread(LPVOID pVoid){HANDLE myChopsticks[2];int iPhilosopher = (int) pVoid;int iLeftChopstick = iPhilosopher;int iRightChopstick = iLeftChopstick + 1;DWORD result;if (iRightChopstick > PHILOSOPHERS-1)码分析：1）在本代码中，为了防止死锁，先确定两只筷子均没被占用才获取筷子，这样就打破了死锁的必要条件中的循环等待条件。
操作系统实验报告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 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(）函数终止指定进程。
华科操作系统课设报告
华中科技大学操作系统课程设计实验报告专业：计算机科学与技术班级：1101姓名：许阳学号：U201014241一、实验目的掌握Linux操作系统的使用方法；了解Linux系统内核代码结构；掌握实例操作系统的实现方法。
二、实验要求1、掌握Linux操作系统的使用方法，包括键盘命令、系统调用；掌握在Linux下的编程环境。
●编一个C程序，其内容为实现文件拷贝的功能；●编一个C程序，其内容为分窗口同时显示三个并发进程的运行结果。
要求用到Linux下的图形库。
2、掌握系统调用的实现过程，通过编译内核方法，增加一个新的系统调用。
另编写一个应用程序，调用新增加的系统调用。
实现的功能是：文件拷贝；3、掌握增加设备驱动程序的方法。
通过模块方法，增加一个新的设备驱动程序，其功能可以简单。
实现字符设备的驱动；4、了解和掌握/proc文件系统的特点和使用方法●了解/proc文件的特点和使用方法●监控系统状态，显示系统中若干部件使用情况●用图形界面实现系统监控状态。
5、设计并实现一个模拟的文件系统（选作）三、实验一1、编一个C程序，其内容为实现文件拷贝的功能要实现文件拷贝功能，主要用到的函数是open、write、read。
以前在windows下写C语言打开文件常用的fopen，此时不能用，因为fopen是ANSIC标准中的C语言库函数，在不同的系统中应该调用不同的内核api ；所以应该直接使用linux中的系统函数open。
主要用到的头文件：Unistd.h \\包含了许多Linux系统服务的函数原型，如:read、writeFcntl.h \\定义了很多宏和open,fcntl函数原型Stdio.h \\标准输入输出头文件sys/types.h \\此头文件包含适当时应使用的多个基本派生类型sys/stat.h \\包含了获取文件属性的一些函数errno.h \\用于调试错误代码是所需要的一些errno变量string.h \\包含了处理字符串的一些函数设计思路：由命令行参数获取2个文件名，根据其文件名和路径分别打开该2个文件，设置一个循环，从源文件复制N个字节到目的文件，直到源文件指针到文件尾，最后关闭2个文件。
华科操作系统实验
课程实验报告课程名称：操作系统课程设计专业班级：学号：姓名：指导教师：报告日期：计算机科学与技术学院目录实验1：进程并发实验 (1)1.1 实验概述 (1)1.2 实验内容 (1)1.3 实验设计 (1)1.4 实验过程 (2)1.5实验结果 (6)1.6实验小结 (7)实验2：添加系统功能调用 (8)2.1 实验概述 (8)2.2 实验内容 (8)2.2.1 阶段1 添加源代码 (8)2.2.2 阶段2 连接新的系统功能调用 (9)2.2.3 阶段3 重建内核 (10)2.2.4阶段4 修改grub文件 (13)2.3 实验小结 (14)实验3：添加设备驱动程序 (15)3.1 实验概述 (15)3.2 实验内容 (15)3.2.1 阶段1 编写设备驱动程序 (15)3.2.2 阶段2 编译设备驱动模块 (16)3.2.3 阶段3 加载设备驱动模块 (17)3.2.4 阶段4 生成设备文件 (18)3.2.4 阶段5 编写应用程序测试 (18)3.3实验小结 (19)实验总结 (20)实验1：进程并发实验1.1 实验概述通过本次进程并发实验，让同学更加熟悉和理解Linux编程环境。
1.2 实验内容本次实验的内容主要分为两个任务：1.编写一个C程序，用read、write等系统调用实现文件拷贝功能。
命令形式：copy <源文件名> <目标文件名>2.编写一个C程序，使用图形编程库 (QT/GTK)分窗口显示三个并发进程的运行(一个窗口实时显示当前系统时间，一个窗口循环显示0到9，一个窗口做1到1000的累加求和，刷新周期均为1秒)。
1.3 实验设计任务1：实验1的第一个阶段需要实现一个简单的C语言程序，首先需要有一个复制的源文件，同时需要创建一个存放复制内容的复制文件，文件复制传输的中间站可以设置一个缓冲数组，此次试验设计了一个大小为10个字节的数组。
打开复制源文件，返回一个INT标识，使用readbuf（）函数，每次读取10个字节的内容，将内容存放到缓冲区数组，使用writebuf（）函数将缓冲区的10个字节写到复制文件中，重复上述过程直到将整个复制过程完成。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验目的掌握Linux操作系统的使用方法；了解Linux系统内核代码结构；掌握实例操作系统的实现方法。
一、实验要求1、掌握Linux操作系统的使用方法，包括键盘命令、系统调用；掌握在Linux下的编程环境。
●编一个C程序，其内容为实现文件拷贝的功能；●编一个C程序，其内容为分窗口同时显示三个并发进程的运行结果。
要求用到Linux下的图形库。
2、掌握系统调用的实现过程，通过编译内核方法，增加一个新的系统调用。
另编写一个应用程序，调用新增加的系统调用。
实现的功能是：文件拷贝；3、掌握增加设备驱动程序的方法。
通过模块方法，增加一个新的设备驱动程序，其功能可以简单。
实现字符设备的驱动；4、了解和掌握/proc文件系统的特点和使用方法●了解/proc文件的特点和使用方法●监控系统状态，显示系统中若干部件使用情况●用图形界面实现系统监控状态。
5、设计并实现一个模拟的文件系统（选作）二、实验一1、编一个C程序，其内容为实现文件拷贝的功能要实现文件拷贝功能，主要用到的函数是fopen、fputc、fgetc。
主要用到的头文件：#include <stdio.h>#include <stdlib.h>设计思路：由scanf函数获取2个文件名，根据其文件名和路径分别打开该2个文件，设置一个循环，从源文件复制1个字节到目的文件，直到源文件指针到文件尾，最后关闭2个文件。
在可能出错的地方需要加上相应的报错代码，并输出错误信息，以方便调试。
理清楚设计思路后，首先搭建linux下编程环境。
安装gcc：sudo apt-get install build-essential安装codeblocks：sudo apt-get install codeblocks在集成开发环境Code::Blocks IDE下根据需求写出相应的源代码copy.c，将程序编译并生成exe可执行文件。
然后手动创建一个测试文件test.txt ，运行copy.exe文件，并输入text.txt与target.txt。
这样就能将源文件test.txt复制到目标文件target.txt程序源代码copy.c：#include <stdio.h>#include <stdlib.h>int main(){char a[20],b[20];scanf("%s",a);getchar();scanf("%s",b);FILE *p=NULL,*q=NULL;p=fopen(a,"rb");if(p==NULL){printf("%s default",a);return 0;}q=fopen(b,"wb+");char c;while((c=fgetc(p))!=EOF){fputc(c,q);}printf("copy success");return 0;}2、编一个C程序，其内容为分窗口同时显示三个并发进程的运行结果。
要求用到Linux下的图形库。
安装Linux下的GTK+：sudo apt-get install build-essential这将安装gcc/g++/gdb/make 等基本编程工具sudo apt-get install gnome-core-devel这将安装 libgtk2.0-dev libglib2.0-dev 等开发相关的库文件sudo apt-get install pkg-config用于在编译GTK程序时自动找出头文件及库文件位置sudo apt-get install devhelp这将安装 devhelp GTK文档查看程序sudo apt-get install libglib2.0-doc libgtk2.0-doc这将安装 gtk/glib 的API参考手册及其它帮助文档sudo apt-get install glade libglade2-dev这将安装基于GTK的界面GTK是开发Gnome窗口的c/c++语言图形库sudo apt-get install libgtk2.0*, gtk+2.0所需的所有文件统通下载安装完毕编写一个GTK+程序的基本步骤如下：●初始化Gtk●建立控件●登记消息与消息处理函数●执行消息循环函数gtk_main()初始化主要使用的函数有gtk_init(&argc,&argv); //启动GTKgtk_window_new(GTK_WINDOW_TOPLEVEL); //创建窗口gtk_window_set_title(GTK_WINDOW(window),"标题名"); //设置窗口标题名gtk_widget_set_usize(window, 200, 200); //设置窗口大小gtk_widget_show(window); //显示窗口建立控件的一般流程/*创建表格准备封装*/gtk_table_new ( //创建多少列gint rows, //创建多少栏gint columns, //用来决定表格如何来定大小gint homogeneous);/*这个函数是将表格table，结合到窗口window里*/gtk_container_add(GTK_CONTAINER(window),table);gtk_widget_show(table); // 显示该表格/*要把物件放进box中，可用以下函数*/void gtk_table_attach_defaults (GtkTable*table, //参数("table")是选定某表格GtkWidget*widget, //("child")是想放进去的物件gintleft_attach, //以下参数是指定把物件放在哪里, 及用多少个boxesgintright_attach,ginttop_attach,gintbottom_attach);在Code::Blocks IDE创建GTK+工程如下流程：首先在codeblocks选中File，然后选择New，最后Project。
出现如上图所示界面。
在该界面中选中GTK+Project然后Go进入下一步。
继续Next，直到如下图输入工程名称与路径。
然后Next->Finish这样，就创建了一个GTK+工程。
直接运行刚才创建的GTK+工程中的默认程序，得到一个包含2个按钮的窗口界面应用，如下图所示：此时，可以按此模板修改源代码，也可以删除重写。
并发进程：创建3个如上GTK+工程，生成3个不同的exe文件。
if ((p1=fork()) == 0){execv("../1",NULL);}else if ((p2=fork())==0){execv("../2",NULL);}else if ((p3=fork()==0)){execv("../3",NULL);}wait();实验截图：实验源代码：gtk.c:#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <linux/sem.h>#include <linux/shm.h>int main (){pid_t p1,p2,p3;if ((p1=fork()) == 0){execv("/home/linux/Desktop/1/bin/Debug/1",NULL);}else if ((p2=fork())==0){execv("/home/linux/Desktop/2/bin/Debug/2",NULL);}else if ((p3=fork()==0)){execv("/home/linux/Desktop/3/bin/Debug/3",NULL);}wait();return 0;}#include <stdlib.h>#include <gtk/gtk.h>static void helloWorld (GtkWidget *wid, GtkWidget *win){GtkWidget *dialog = NULL;dialog = gtk_message_dialog_new (GTK_WINDOW (win), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "1");gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);gtk_dialog_run (GTK_DIALOG (dialog));gtk_widget_destroy (dialog);}int main (int argc, char *argv[]){GtkWidget *button = NULL;GtkWidget *win = NULL;GtkWidget *vbox = NULL;/* Initialize GTK+ */g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);gtk_init (&argc, &argv);g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);/* Create the main window */win = gtk_window_new (GTK_WINDOW_TOPLEVEL);gtk_container_set_border_width (GTK_CONTAINER (win), 8);gtk_window_set_title (GTK_WINDOW (win), "Hello World");gtk_window_move (GTK_WINDOW (win), 450,320);gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER); gtk_widget_realize (win);g_signal_connect (win, "destroy", gtk_main_quit, NULL);/* Create a vertical box with buttons */vbox = gtk_vbox_new (TRUE, 6);gtk_container_add (GTK_CONTAINER (win), vbox);button = gtk_button_new_from_stock (GTK_STOCK_DIALOG_INFO);g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (helloWorld), (gpointer) win);gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);g_signal_connect (button, "clicked", gtk_main_quit, NULL);gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);/* Enter the main loop */gtk_widget_show_all (win);gtk_main ();return 0;}三、实验二Linux内核，简单来说就是一套用来控制计算机最底层的硬件设备，如处理器、内存、硬盘等的一种软件，一般称为操作系统，在Linux术语中称为内核。