查看程序的进程和线程实验报告
篇一：程序实验2：11-多线程编程---实验报告
程序实验二：11-多线程编程实验
专业班级实验日期 5.21 姓名学号实验一（p284：11-thread.c）
1、软件功能描述
创建3个线程，让3个线程重用同一个执行函数，每个线程都有5次循环，可以看成5个小任务，每次循环之间会有随即等待时间（1-10s）意义在于模拟每个任务到达的时间是随机的没有任何的特定规律。
2、程序流程设计
3．部分程序代码注释(关键函数或代码)
#include
#include
#include
#define T_NUMBER 3
#define P_NUMBER 5
#define TIME 10.0
void *thrd_func(void *arg )
{
(本文来自：https://www.doczj.com/doc/187970236.html, 小草范文网:查看程序的进程和线程实验报告) int thrd_num=(int)arg;
int delay_time =0;
int count =0;
printf("Thread %d is staraing\n",thrd_num);
for(count=0;count {
delay_time =(int)(rand()*TIME/(RAND_MAX))+1;
sleep(delay_time);
printf("\tTH%d:job%d delay =%d\n",thrd_num,count,delay_time);
}
printf("%d finished\n",thrd_num);
pthread_exit(NULL);
}
int main()
{
pthread_t thread[T_NUMBER];
int no=0,res;
void * thrd_ret;
srand(time(NULL));
for(no=0;no {
res=pthread_create(&thread[no],NULL, thrd_func,(void*)no);
if(res!=0)
{
printf("Creay th %d faild\n",no);
exit(res);
}
}
printf("success\nwaiting\n");
for(no=0;no {
res=pthread_join(thread[no],&thrd_ret);
if(!res)
{
printf("t %d joined\n",no);
}
else
{
printf("T %djoined faild\n",no);
}
}
return 0;
}
4．编译、运行方法及结果(抓屏)
5．结果分析
由运行结果可以看出，创建线程、释放资源按照顺序，而每个线程的运行和结束是独立与并行的。
实验二（p287: 11-thread_mutex.c）
1、软件功能描述
在试验1的基础上通过互斥锁，使原本独立，无序的多个线程能够按顺序进行
2、程序流程设计
3．部分程序代码注释(关键函数或代码)
#include
#include
#include
#define THREAD_NUMBER3/*线程数*/
#define REPEAT_NUMBER3 /*每个线程的小任务数*/
#define DELAY_TIME_LEVELS 10.0 /*小任务间的最大时间间隔*/
pthread_mutex_t mutex;
void *thrd_func(void *arg) //线程函数例程{
int thrd_num = (int)arg;
int delay_time = 0, count = 0;
int res;
//互斥锁上锁
res = pthread_mutex_lock(&mutex);
if(res)
{
篇二：操作系统实验报告_进程和线程
计算机科学与软件学院
操作系统上机实验报告
学生姓名：学号：班级：班实验日期： XX.4.17
实验名称：进程和线程
实验目的：理解unix/Linux下进程和线程的创建、并发执行过程。
实验内容：
1．进程的创建
2．多线程应用
实验步骤及分析：（此部分为关键内容：要求整理实验主要步骤，总结编写实验过程中遇到哪些问题，如何解决的，若未解决也应总结，回答思考题的答案）
一、进程的创建
下面这个C程序展示了UNIX系统中父进程创建子进程及各自分开活动的情况。
1、实验指导
fork( )
创建一个新进程。
系统调用格式：
pid=fork( )
参数定义：
int fork( )
fork( )返回值意义如下：
0：在子进程中，pid变量保存的fork( )返回值为0，表示当前进程是子进程。
>0：在父进程中，pid变量保存的fork( )返回值为子进程的id值（进程唯一标识符）。 -1：创建失败。
如果fork( )调用成功，它向父进程返回子进程的PID，并向子进程返回0，即fork( )被调用了一次，但返回了两次。此时OS在内存中建立一个新进程，所建的新进程是调
用fork( )父进程（parent process）的副本，称为子进程（child process）。子进程继承了父进程的许多特性，并具有与父进程完全相同的用户级上下文。父进程与子进程并发执行。
2、参考程序代码
/*process.c*/
#include
#include
main(int argc,char *argv[])
{
int pid;
/* fork another process */
pid = fork();
if (pid fprintf(stderr, "Fork Failed");
exit(-1);
}
else if (pid == 0) {/* child process */
execlp( "/bin/ls", "ls",NULL);
}
else {/* parent process */
/* parent will wait for the child to complete */ wait(NULL);
printf( "Child Complete" );
exit(0);
}
}
3、编译和运行
$gcc process.c –o processs
4、运行
$./process 程序运行截图
5、思考
（1）系统是怎样创建进程的？
（2）扩展程序，在父进程中输出1到5，在子进程中输出6-10，要求父子进程并发
输出；记录实验结果，并给出简单分析。
6.实验中遇到的问题和解决方法
二、多线程应用
编写unix/Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。下面是一个最简单的多线程程序 example1.c。
1.实验指导
下面的示例中，要使用到两个函数，pthread_create和pthread_join，并声明了一个pthread_t型的变量。
函数pthread_create用来创建一个线程，它的原型为：extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,void *(*__start_routine) (void *), void *__arg));
第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread 不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见
的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。
函数pthread_join用来等待一个线程的结束。函数原型为：
extern int pthread_join __P ((pthread_t __th, void **__thread_return));
第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等
待的线程结束为止，当函数返回时，被等待线程的资源被收回。
一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。它的函数原型为：extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。
2、参考程序代码
/* thread.c*/
#include
#include
void thread(void)
{
int i;
for(i=0;i printf("This is a pthread.\n");
}
int main(int argc,char *argv[])
{
pthread_t id;
int i,ret;
ret=pthread_create(&id,NULL,(void *)
thread,NULL);
if(ret!=0){
printf ("Create pthread error!\n");
exit (1);
}
for(i=0;i printf("This is the main process.\n");
pthread_join(id,NULL);
return (0);
}
3、编译和运行
编译此程序：
gcc example1.c -lpthread -o example1
-lpthread:使用线程库
运行example1，得到如下结果：
This is the main process.
This is a pthread.
This is the main process.
This is the main process.
This is a pthread.
This is a pthread.
再次运行，可能得到如下结果：
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
程序运行截图
4、思考
（1）程序运行后，进程thread中有几个线程存在？（2）为什么前后两次运行结果不一样？答（1）（2）
5.实验中遇到的问题和解决方法
运行结果并没有出现预期效果
篇三：操作系统实验报告
操作系统教程
实验报告
班级：软104
学号：109074267
姓名：王二康
实验一 WINDOWS进程初识
1、实验目的
（1）学会使用VC编写基本的Win32 Consol Application （控制
（2）台应用程序)。
（3）掌握WINDOWS API的使用方法。
（4）编写测试程序，理解用户态运行和核心态运行。
2、实验内容和步骤
（1）编写基本的Win32 Consol Application
步骤1：登录进入Windows，启动VC++ 6.0。
步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。
步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。
步骤4：将清单1-1所示的程序清单复制到新创建的
C/C++源程序中。编译成可执行文件。
步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序：E:\课程\os课\os实验\程序\os11\debug>hello.exe
运行结果 (如果运行不成功，则可能的原因是什么？) ：（2）计算进程在核心态运行和用户态运行的时间
步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。
步骤2：在创建一个新的“Win32 Consol Application”
工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。
步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。
E:\课程\os课\os实验\程序\os12\debug>time TEST.exe
步骤4：运行结果 (如果运行不成功，则可能的原因是什么？)： process ID: 3716,EXE file:3.exe,%d in Kernel mode: 60
步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。
屏蔽i循环：
process ID: 1412,EXE file:3.exe,%d in Kernel mode: 62
屏蔽j循环：
process ID: 1816,EXE file:3.exe,%d in Kernel mode: 34
调整循环变量i的循环次数：
process ID: 2616,EXE file:3.exe,%d in Kernel mode: 64
调整循环变量j的循环次数：
process ID: 1868,EXE file:3.exe,%d in Kernel mode: 50
3、实验结论
对Win32 Consol Application有进一步的认识，WIN32 API也就是核心态就是一个是直接的代码运行，即win32consol Application下代码运行；而用户态是在DOS 下运行的，对编译好的程序进行的运行，核心态速度较快，没有太多的约束，而用户态的运行需要时间较长，由于有相应的约束。
实验二进程管理
背景知识
Windows所创建的每个进程都从调用CreateProcess() API函数开始，该函数的任务是在对象管理器子系统内初始化进程对象。每一进程都以调用ExitProcess() 或TerminateProcess() API函数终止。通常应用程序的框架负责调用 ExitProcess() 函数。对于C++ 运行库来说，这一调用发生在应用程序的main() 函数返回之后。
1. 创建进程
CreateProcess() 调用的核心参数是可执行文件运行时的文件名及其命令行。表 3-4详细地列出了每个参数的类型和名称。
表3-4 CreateProcess() 函数的参数
可以指定第一个参数，即应用程序的名称，其中包括相对于当前进程的当前目录的全路径或者利用搜索方法找到的路径；lpCommandLine参数允许调用者向新应用程序发送数据；接下来的三个参数与进程和它的主线程以及返回的指向该对象的句柄的安全性有关。
然后是标志参数，用以在dwCreationFlags参数中指明系统应该给予新进程什么行为。经常使用的标志是CREATE_SUSPNDED，告诉主线程立刻暂停。当准备好时，应该使用ResumeThread() API来启动进程。另一个常用的标志是CREATE_NEW_CONSOLE，告诉新进程启动自己的控制台窗口，而不是利用父窗口。这一参数还允许设置进程的优先级，用以向系统指明，相对于系统中所有其他的活动进程来说，给此进程多少CPU时间。
接着是CreateProcess() 函数调用所需要的三个通常使用缺省值的参数。第一个参数是lpEnvironment参数，指
明为新进程提供的环境；第二个参数是lpCurrentDirectory，可用于向主创进程发送与缺省目录不同的新进程使用的特殊的当前目录；第三个参数是STARTUPINFO数据结构所必需的，用于在必要时指明新应用程序的主窗口的外观。
实验、 Linux Ubuntu的安装、创建新的虚拟机VMWare 实验 Shell编程 1.实验目的与内容 通过本实验，了解Linux系统的shell机制，掌握简单的shell编程技巧。 编制简单的Shell程序，该程序在用户登录时自动执行，显示某些提示信息,如“Welcome to Linux”, 并在命令提示符中包含当前时间、当前目录和当前用户名等基本信息。 2.程序源代码清单 #include<> #include
close(pfd[1]); close(pfd[0]); wait(&state); wait(&state); } 实验内核模块 实验步骤: (1).编写内核模块 文件中主要包含init_clock()，exit_clock()，read_clock()三个函数。其中init_clock()，exit_clock()负责将模块从系统中加载或卸载，以及增加或删除模块在/proc中的入口。read_clock()负责产生/proc/clock被读时的动作。 (2).编译内核模块Makefile文件 # Makefile under ifneq ($(KERNELRELEASE),) #kbuild syntax. dependency relationshsip of files and target modules are listed here. obj-m := else PWD := $(shell pwd) KVER ?= $(shell uname -r) KDIR := /lib/modules/$(KVER)/build all: $(MAKE) -C $(KDIR) M=$(PWD) modules clean: rm -rf .*.cmd *.o *. *.ko .tmp_versions *.symvers *.order endif 编译完成之后生成模块文件。 (3).内核模块源代码 #include
实验六：Linux进程间通信（2）（4课时） 实验目的： 理解进程通信原理；掌握进程中信号量、共享内存、消息队列相关的函数的使用。实验原理： Linux下进程通信相关函数除上次实验所用的几个还有： 信号量 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。要调用的第一个函数是semget，用以获得一个信号量ID。 int semget(key_t key, int nsems, int flag); key是IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 semctl函数用来对信号量进行操作。 int semctl(int semid, int semnum, int cmd, union semun arg); 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 semop函数自动执行信号量集合上的操作数组。 int semop(int semid, struct sembuf semoparray[], size_t nops); semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。 ftok原型如下： key_t ftok( char * fname, int id ) fname就是指定的文件名(该文件必须是存在而且可以访问的)，id是子序号，虽然为int，但是只有8个比特被使用(0-255)。 当成功执行的时候，一个key_t值将会被返回，否则-1 被返回。 共享内存 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。首先要用的函数是shmget，它获得一个共享存储标识符。 #include
实验报告 课程名称：操作系统 实验项目：windows进程管理 姓名： 专业：计算机科学与技术 班级： 学号：
计算机科学与技术学院 计算机系 2019 年 4 月 23 日
实验项目名称： windows进程管理 一、实验目的 1. 学习windows系统提供的线程创建、线程撤销、线程同步等系统调用； 2. 利用C++实现线程创建、线程撤销、线程同步程序； 3. 完成思考、设计与练习。 二、实验用设备仪器及材料 1. Windows 7或10， VS2010及以上版本。 三、实验内容 1 线程创建与撤销 写一个windows控制台程序（需要MFC），创建子线程，显示Hello, This is a Thread. 然后撤销该线程。 相关系统调用： 线程创建： CreateThread() 线程撤销： ExitThread() 线程终止： ExitThread(0) 线程挂起： Sleep() 关闭句柄： CloseHandle() 参考代码： ; } 运行结果如图所示。 完成以下设计题目： 1. 向线程对应的函数传递参数，如字符串“hello world！”，在线程中显示。 2. 如何创建3个线程A, B, C，并建立先后序执行关系A→B→C。
实验内容2 线程同步 完成父线程和子线程的同步。父线程创建子线程后进入阻塞状态，子线程运行完毕后再唤醒。 相关系统调用： 等待对象 WaitForSingleObject(), WaitForMultipleObjects(); 信号量对象 CreateSemaphore(), OpenSemaphore(), ReleaseSemaphore(); HANDLE WINAPI CreateSemaphore( _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes _In_ LONG lInitialCount, _In_ LONG lMaximumCount, _In_opt_ LPCTSTR lpName ); 第一个参数：安全属性，如果为NULL则是默认安全属性 第二个参数：信号量的初始值，要>=0且<=第三个参数 第三个参数：信号量的最大值 第四个参数：信号量的名称 返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄参考代码： n"); rc=ReleaseSemaphore(hHandle1,1,NULL); err=GetLastError(); printf("Release Semaphore err=%d\n",err); if(rc==0) printf("Semaphore Release Fail.\n"); else printf("Semaphore Release Success. rc=%d\n",rc); } 编译运行，结果如图所示。
实验报告 实验课程: 计算机操作系统学生姓名：XXX 学号：XXXX 专业班级：软件 2014年12月25日
目录 实验一熟悉Windows XP中的进程和线程.. 3实验二进程调度 (7) 实验三死锁避免—银行家算法的实现 (18) 实验四存储管理 (24)
实验一熟悉Windows XP中的进程和线程 一、实验名称 熟悉Windows XP中的进程和线程 二、实验目的 1、熟悉Windows中任务管理器的使用。 2、通过任务管理器识别操作系统中的进程和线程的相关信息。 3、掌握利用spy++.exe来察看Windows中各个任务的更详细信息。 三、实验结果分析 1、启动操作系统自带的任务管理器： 方法：直接按组合键Ctrl+Alt+Del，或者是在点击任务条上的“开始”“运行”，并输入“taskmgr.exe”。
2、调整任务管理器的“查看”中的相关设置，显示关于进程的以下各项信息，并 完成下表： 表一：统计进程的各项主要信息 3、启动办公软件“Word”，在任务管理器中找到该软件的登记，并将其结束掉。再
从任务管理器中分别找到下列程序：winlogon.exe、lsass.exe、csrss.exe、smss.exe，试着结束它们，观察到的反应是任务管理器无法结束进程， 原因是该系统是系统进程。 4、在任务管理器中找到进程“explorer.exe”，将之结束掉，并将桌面上你打开的所 有窗口最小化，看看你的计算机系统起来什么样的变化桌面上图标菜单都消失了、得到的结论explorer.exe是管理桌面图标的文件（说出explorer.exe进程的作用）。 5、运行“spy++.exe”应用软件，点击按钮“”，切换到进程显示栏上，查看进 程“explorer.exe”的各项信息，并填写下表： 进程：explorer.exe 中的各个线程
1. 在 LINUX 命令平台输入 1-2 个字符后按 Tab 键会自动补全后面的部分(前提是要有这个东西，例如在装了 tomcat 的前提下, 输入 tomcat 的 to 按 tab)。 2. ps 命令用于查看当前正在运行的进程。 grep 是搜索 例如： ps -ef | grep java 表示查看所有进程里 CMD 是 java 的进程信息 ps -aux | grep java -aux 显示所有状态 ps 3. kill 命令用于终止进程 例如： kill -9 [PID] -9 表示强迫进程立即停止 通常用 ps 查看进程 PID ，用 kill 命令终止进程 网上关于这两块的内容 ----------------------------------------------------------------------------------- PS ----------------------------------------------------------------------------------- 1. ps 简介 ps 命令就是最根本相应情况下也是相当强大地进程查看命令.运用该命令可以确定有哪些进程正在运行和运行地状态、进程是否结束、进程有没有僵死、哪些进程占用了过多地资源等等.总之大部分信息均为可以通过执行该命令得到地. 2. ps 命令及其参数 ps 命令最经常使用地还是用于监控后台进程地工作情况,因为后台进程是不和屏幕键盘这些标准输入/输出设 备进行通信地,所以如果需要检测其情况,便可以运用 ps 命令了. 该命令语法格式如下： ps [选项] -e 显示所有进程,环境变量 -f 全格式 -h 不显示标题 -l 长格式 -w 宽输出 a 显示终端上地所有进程,包括其他用户地进程 r 只显示正在运行地进程 x 显示没有控制终端地进程 O[+|-] k1 [,[+|-] k2 [,…]] 根据 SHORT KEYS、k1、k2 中快捷键指定地多级排序顺序显示进程列表. 对于 ps 地不同格式都存在着默认地顺序指定.这些默认顺序可以被用户地指定所覆盖.在这里面“+”字符是可选地,“-” 字符是倒转指定键地方向. pids 只列出进程标识符,之间运用逗号分隔.该进程列表必须在命令行参数地最后一个选项后面紧接着给出,中间不能插入空格.比如：ps -f1,4,5.
实验2过程管理实验报告学生号姓名班级电气工程系过程、过程控制块等基本原理过程的含义：过程是程序运行过程中对数据集的处理，以及由独立单元对系统资源的分配和调度。在不同的数据集上运行程序，甚至在同一数据集上运行多个程序，是一个不同的过程。（2）程序状态：一般来说，一个程序必须有三种基本状态：就绪、执行和阻塞。然而，在许多系统中，过程的状态变化可以更好地描述，并且增加了两种状态：新状态和终端状态。1）就绪状态，当一个进程被分配了除处理器（CPU）以外的所有必要资源时，只要获得了处理器，进程就可以立即执行。此时，进程状态称为就绪状态。在系统中，多个进程可以同时处于就绪状态。通常，这些就绪进程被安排在一个或多个队列中，这些队列称为就绪队列。2）一旦处于就绪状态的进程得到处理器，它就可以运行了。进程的状态称为执行状态。在单处理器系统中，只有一个进程在执行。在多处理器系统中，可能有多个进程在执行中。3）阻塞状态由于某些事件（如请求输入和输出、额外空间等），执行进程被挂起。这称为阻塞状态，也称为等待状态。通常，处于阻塞状态的进程被调度为-？这个队列称为阻塞队列。4）新状态当一个新进程刚刚建立并且还没有放入就绪队列中时，它被称为新状态。5）终止状态是
什么时候-？进程已正常或异常终止，操作系统已将其从系统队列中删除，但尚未取消。这就是所谓的终结状态。（3）过程控制块是过程实体的重要组成部分，是操作系统中最重要的记录数据。控制块PCB记录操作系统描述过程和控制过程操作所需的所有信息。通过PCB，一个不能独立运行的程序可以成为一个可以独立运行的基本单元，并且可以同时执行一个进程。换句话说，在进程的整个生命周期中，操作系统通过进程PCB管理和控制并发进程。过程控制块是系统用于过程控制的数据结构。系统根据进程的PCB来检测进程是否存在。因此，进程控制块是进程存在的唯一标志。当系统创建一个进程时，它需要为它创建一个PCB；当进程结束时，系统回收其PCB，进程结束。过程控制块的内容过程控制块主要包括以下四个方面的信息。过程标识信息过程标识用于对过程进行标识，通常有外部标识和内部标识。外部标识符由流程的创建者命名。通常是一串字母和数字。当用户访问进程时使用。外部标识符很容易记住。内部标识符是为了方便系统而设置的。操作系统为每个进程分配一个唯一的整数作为内部标识符。通常是进程的序列号。描述性信息（process scheduling message）描述性信息是与流程调度相关的一些有关流程状态的信息，包括以下几个方面。流程状态：表
何查看后台进程？ ?系统环境： 1、操作系统：Windows 2000 Server，机器内存128M 2、数据库：Oracle 8i R2 (8.1.6) for NT 企业版 3、安装路径：C:\ORACLE ?实现步骤： ? ?SQL> desc v$bgprocess ?名称空? 类型 ? ----------------------------------------- -------- ----------------- ? PADDR RAW(4) --进程状态对象地址 ? NAME VARCHAR2(5) --后台进程名称 ? DESCRIPTION VARCHAR2(64) --后台进程描述 ? ERROR NUMBER --后台进程运行中所遇到的错误数 ? ?SQL> col DESCRIPTION format a40 ?SQL> select * from v$bgprocess; ? ?PADDR NAME DESCRIPTION ERROR ?-------- ----- ---------------------------------------- ---------- ?02CB8B4C PMON process cleanup ########## ?00 TRWR trace writer process ########## ?00 LMON lkmgr monitor ########## ?00 LMD0 lkmgr daemon 0 ########## ?02CB8E6C DBW0 db writer process 0 ########## ?00 DBW1 db writer process 1 ########## ?00 DBW2 db writer process 2 ########## ?00 DBW3 db writer process 3 ##########
进程的控制 1 ．实验目的 通过进程的创建、撤消和运行加深对进程概念和进程并发执行的理解，明确进程与程序之间的区别。 【答：进程概念和程序概念最大的不同之处在于： (1)进程是动态的，而程序是静态的。 (2)进程有一定的生命期，而程序是指令的集合，本身无“运动”的含义。没有建立进程的程序不能作为1个独立单位得到操作系统的认可。 (3)1个程序可以对应多个进程，但1个进程只能对应1个程序。进程和程序的关系犹如演出和剧本的关系。 (4)进程和程序的组成不同。从静态角度看，进程由程序、数据和进程控制块（PCB）三部分组成。而程序是一组有序的指令集合。】2 ．实验内容 (1) 了解系统调用fork()、execvp()和wait()的功能和实现过程。 (2) 编写一段程序，使用系统调用fork()来创建两个子进程，并由父进程重复显示字符串“parent:”和自己的标识数，而子进程则重复显示字符串“child:”和自己的标识数。 (3) 编写一段程序，使用系统调用fork()来创建一个子进程。子进程通过系统调用execvp()更换自己的执行代码，新的代码显示“new
program.”。而父进程则调用wait()等待子进程结束，并在子进程结束后显示子进程的标识符，然后正常结束。 3 ．实验步骤 （1）gedit创建进程1.c （2）使用gcc 1.c -o 1编译并./1运行程序1.c #include
进程间通信实验报告 班级：10网工三班学生姓名：谢昊天学号：1215134046 实验目的和要求： Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。 实验内容与分析设计： （1）消息的创建，发送和接收。 ①使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k 的消息的发送和接收程序。 ②观察上面的程序，说明控制消息队列系统调用msgctl () 在此起什么作用？ （2）共享存储区的创建、附接和段接。 使用系统调用shmget(),shmat(),sgmdt(),shmctl(),编制一个与上述功能相同的程序。（3）比较上述（1），（2）两种消息通信机制中数据传输的时间。 实验步骤与调试过程： 1.消息的创建，发送和接收： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)在SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER 。SERVER每接收到一个消息后显示一句“(server)received”。 (3)CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，既是 SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client)sent”。 (4)父进程在 SERVER和 CLIENT均退出后结束。 2.共享存储区的创建,附接和断接： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1。作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER 每接收到一次数据后显示”(server)received”. (3)CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时, Server端空闲,可发送请求. CLIENT 随即填入9到0.期间等待Server端再次空闲.进行完这些操作后, CLIENT退出. CLIENT每发送一次数据后显示”(client)sent”. (4)父进程在SERVER和CLIENT均退出后结束。 实验结果： 1．消息的创建，发送和接收： 由 Client 发送两条消息，然后Server接收一条消息。此后Client Server交替发送和接收消息。最后一次接收两条消息。Client 和Server 分别发送和接收了10条消息。message 的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象。在多次send message 后才 receive message.这一点有助于理解消息转送的实现机理。
在Linux中查看线程数的三种方法 1、top -H 手册中说：-H : Threads toggle 加上这个选项启动top，top一行显示一个线程。否则，它一行显示一个进程。 2、ps xH 手册中说：H Show threads as if they were processes 这样可以查看所有存在的线程。 3、ps -mp
实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构（PCB结构通常包括以下信息：进程名（进程ID）、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同，PCB结构的内容可以作适当的增删）。为了便于处理，程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类，每类数目为r1…r w。随机产生n进程P i(id,s(j,k)，t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间，在运行过程中，会随机申请新的资源。 3、每个进程可有三个状态（即就绪状态W、运行状态R、等待或阻塞状态B），并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法：时间片轮转调度算法 本程序用该算法对n个进程进行调度，进程每执行一次，CPU时间片数加1，进程还需要的时间片数减1。在调度算法中，采用固定时间片（即：每执行一次进程，该进程的执行时间片数为已执行了1个单位），这时，CPU时间片数加1，进程还需要的时间片数减1，并排列到就绪队列的尾上。 三、实验环境 操作系统环境：Windows系统。 编程语言：C#。 四、实验思路和设计 1、程序流程图
2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态，W（等待）、R（运行）、B（阻塞） //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数，n为初始化进程个数 //r为可随机产生的进程数（r=m-n） //a，b，c分别为A，B，C三类资源的总量 //i为进城计数，i=1…n //h为运行的时间片次数，time1Inteval为时间片大小（毫秒） //对进程进行初始化，建立就绪数组、阻塞数组。 public void input()//对进程进行初始化，建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;
河北大学工商学院 课程设计 题目：操作系统课程设计 学部信息学部 学科门类电气信息 专业计算机 学号2011482370 姓名耿雪涛 指导教师朱亮 2013 年6月19日
主要内容 一、设计目的 通过模拟操作系统的实现，加深对操作系统工作原理理解，进一步了解操作系统的实现方法，并可练习合作完成系统的团队精神和提高程序设计能力。 二、设计思想 实现一个模拟操作系统，使用VB、VC、CB等windows环境下的程序设计语言，以借助这些语言环境来模拟硬件的一些并行工作。模拟采用多道程序设计方法的单用户操作系统，该操作系统包括进程管理、存储管理、设备管理、文件管理和用户接口四部分。 设计模板如下图： 注：本人主要涉及设备管理模块
三、设计要求 设备管理主要包括设备的分配和回收。 ⑴模拟系统中有A、B、C三种独占型设备，A设备1个，B设备2个，C设备2个。 ⑵采用死锁的预防方法来处理申请独占设备可能造成的死锁。 ⑶屏幕显示 注：屏幕显示要求包括：每个设备是否被使用，哪个进程在使用该设备，哪些进程在等待使用该设备。 设备管理模块详细设计 一、设备管理的任务 I/O设备是按照用户的请求，控制设备的各种操作，用于完成I/O 设备与内存之间的数据交换（包括设备的分配与回收，设备的驱动管理等），最终完成用户的I/O请求，并且I/O设备为用户提供了使用外部设备的接口，可以满足用户的需求。 二、设备管理函数的详细描述 1、检查设备是否可用（主要代码） public bool JudgeDevice(DeviceType type) { bool str = false; switch (type) { case DeviceType.a: {
实验三进程的同步 一、实验目的 1、了解进程同步和互斥的概念及实现方法； 2、更深一步的了解fork()的系统调用方式。 二、实验内容 1、预习操作系统进程同步的概念及实现方法。 2、编写一段源程序，用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。程序的输出是什么？分析原因。 3、阅读模拟火车站售票系统和实现进程的管道通信源代码，查阅有关进程创建、进程互斥、进程同步的系统功能调用或API，简要解释例程中用到的系统功能或API的用法，并编辑、编译、运行程序，记录程序的运行结果，尝试给出合理的解释。 4、（选做）修改问题2的代码，使得父子按顺序显示字符“a”；“b”、“c”编辑、编译、运行。记录程序运行结果。 三、设计思想 1、程序框架 （1）创建两个子进程：（2）售票系统：
（3）管道通信： 先创建子进程，然后对内容加锁，将输出语句存入缓存，并让子进程自己进入睡眠，等待别的进程将其唤醒，最后解锁；第二个子进程也执行这样的过程。父进程等待子进程后读内容并输出。 （4）修改程序（1）：在子进程的输出语句前加上sleep()语句，即等待父进程执行完以后再输出。 2、用到的文件系统调用函数 （1）创建两个子进程：fork() （2）售票系统：DWORD WINAPI Fun1Proc(LPVOID lpPartameter); CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); CloseHandle(hThread1); (HANDLE)CreateMutex(NULL,FALSE,NULL); Sleep(4000)（sleep调用进程进入睡眠状态(封锁), 直到被唤醒）; WaitForSingleObject(hMutex,INFINITE); ReleaseMutex(hMutex); （3）管道通信：pipe(fd)，fd: int fd[2]，其中: fd[0] 、fd[1]文件描述符（读、写）; lockf( fd，function，byte)（fd: 文件描述符；function: 1: 锁定 0:解锁；byte: 锁定的字节数，0: 从当前位置到文件尾）; write(fd，buf，byte)、read(fd，buf，byte) （fd: 文件描述符；buf : 信息传送的源（目标）地址；byte: 传送的字节数）; sleep(5); exit(0); read(fd[0]，s，50) （4）修改程序（1）：fork(); sleep(); 四、调试过程 1、测试数据设计 （1）创建两个子进程：
实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的sched.h源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码如下： #include
else{ pid2 = fork(); if(pid2<0){ fprintf(stderr,"childprocess1 failed"); exit(-1); } else if(pid2 == 0){ printf("c\n"); } else{ printf("a\n"); sleep(2); exit(0); } } return 0; } 结果如下： 分析原因： pid=fork(); 操作系统创建一个新的进程（子进程），并且在进程表中相应为它建立一个新的表项。新进程和原有进程的可执行程序是同一个程序；上下文和数据，绝大部分就是原进程（父进程）的拷贝，但它们是两个相互独立的进程！因此，这三个进程哪个先执行，哪个后执行，完全取决于操作系统的调度，没有固定的顺序。 （2）进程的控制 修改已经编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再观察程序执行时屏幕上出现的现象，并分析原因。 将父进程的输出改为father process completed 2/11
操作系统教程 实 验 指 导 书 姓名： 学号： 班级：软124班 指导老师：郭玉华 2014年12月10日
实验一WINDOWS进程初识 1、实验目的 （1）学会使用VC编写基本的Win32 Consol Application（控制台应用程序)。 （2）掌握WINDOWS API的使用方法。 （3）编写测试程序，理解用户态运行和核心态运行。 2、实验内容和步骤 （1）编写基本的Win32 Consol Application 步骤1：登录进入Windows，启动VC++ 6.0。 步骤2：在“FILE”菜单中单击“NEW”子菜单，在“projects”选项卡中选择“Win32 Consol Application”,然后在“Project name”处输入工程名，在“Location”处输入工程目录。创建一个新的控制台应用程序工程。 步骤3：在“FILE”菜单中单击“NEW”子菜单，在“Files”选项卡中选择“C++ Source File”, 然后在“File”处输入C/C++源程序的文件名。 步骤4：将清单1-1所示的程序清单复制到新创建的C/C++源程序中。编译成可执行文件。 步骤5：在“开始”菜单中单击“程序”-“附件”-“命令提示符”命令，进入Windows“命令提示符”窗口，然后进入工程目录中的debug子目录，执行编译好的可执行程序： E:\课程\os课\os实验\程序\os11\debug>hello.exe 运行结果 (如果运行不成功，则可能的原因是什么？) ： 有可能是因为DOS下路径的问题 （2）计算进程在核心态运行和用户态运行的时间 步骤1：按照（1）中的步骤创建一个新的“Win32 Consol Application”工程，然后将清单1-2中的程序拷贝过来，编译成可执行文件。 步骤2：在创建一个新的“Win32 Consol Application”工程，程序的参考程序如清单1-3所示，编译成可执行文件并执行。 步骤3：在“命令提示符”窗口中运行步骤1中生成的可执行文件，测试步骤2中可执行文件在核心态运行和用户态运行的时间。 E:\课程\os课\os实验\程序\os12\debug>time TEST.exe 步骤4：运行结果 (如果运行不成功，则可能的原因是什么？) ： 因为程序是个死循环程序 步骤5：分别屏蔽While循环中的两个for循环，或调整两个for循环的次数，写出运行结果。 屏蔽i循环： 屏蔽j循环： _______________________________________________________________________________调整循环变量i的循环次数：
武汉工程大学计算机科学与工程学院 《操作系统》实验报告[Ⅰ]
一、实验目的 创建进程，实现进程消息通信和共享内存通信，了解进程的创建、退出和获取进程信。了解什么是映像文件、管道通信及其作用，掌握通过内存映像文件和管道技术实现进程通信。 二、实验内容 本例用三种方法实现进程通信，仅用于示例目的，没有进行功能优化。 1、创建进程A和B后，在进程A中输入一些字符，点“利用 SendMessage发送消息”按钮可将消息发到进程B。 2、在进程A中输入一些字符，点“写数据到内存映像文件”按钮， 然后在进程B中点“从内存映像文件读数据”按钮可收到消息。其中在点“写数据到内存映像文件”时，要求创建映像文件，B进程在印象文件中读取数据。 3、先在进程B中点“创建管道并接收数据”按钮，然后在进程A 中输入一些字符，点“写数据到管道文件”按钮可将消息发到进程B。管道是连接读/写进程使他们进行通信的一个共享文件，目的是更好地实现进程间的通信。 三、实验思想 这次试验最主要的内容和核心思想就是学会创建进程并实现进程间的简单通信、创建映像文件和创建管道文件来通信，后两者是实现进程通信的高级通信机制中的两种。. 创建一个程序A和程序B，其中程序A和B各有一个主窗体，A主窗体上要求可以实现创建进程B（即调用函数B）、结束进程B、关闭进程A、向进程B发送数据、创建映像文件、创建管道文件等功能，进程B要求有从映像文件读取数据、创建管道并接收数据、结束进程B功能。最终让A、B进程相互通信。
四、设计分析： 首先设得设计A、B两个程序的操作界面，然后编写各个功能模块。对于A 程序窗体，在“利用SendMessage发送消息”按钮的消息响应函数中，主要是利用Windows API函数CWnd::FindWindow来找到接收消息的窗体，即进程B，找到进程B后，利用这个函数返回的窗体指针的SendMessage函数来发送消息。在“写数据到内存印象文件”按钮的消息响应函数中，主要是利用函数CreateFileMapping来创建一个印象文件，这个函数返回的是这个印象文件的句柄，然后将这个句柄和要发送的消息字符串传递到函数sprintf中，就可以所要发送的消息写入印象文件，在B程序窗体中有个“从内存印象文件读数据”按钮，在这个按钮的消息响应函数中读取父进程所创建的印象文件中的数据就可以实现通信了。在B程序窗体按钮“写数据到管道文件”的消息响应函数中，不能直接将要发送的消息发送到管道文件，因为管道必须先由子进程通过函数CreateNamedPipe创建，只有待子进程创建好管道后父进程才能根据管道创建管道文件，将消息写入管道文件并及时发送给子进程。而且这个管道只能使用一次，即每次发送完消息后那个管道不能在使用了，必须再由子进程创建一个管道，A 进程才能再次创建管道文件并向其中写入消息。这个程序也不一定要MFC实现，还可以用其他的技术和语言实现，比如说Java、VB等，外表构架可以不一样，但核心技术都是一样的，只是不同的调用形式和调用方法，比如说在VB中，实现进程间的一般通信就是使用动态数据交换ＤＤＥ，实现起来就比较简单，但是要创建映像文件和管道文件就比较繁琐，可以根据不同的需求采用不同的语言。 五、程序部分源代码： 1.“利用SendMessage发送消息”按钮中的主要代码 //找到接收消息的窗口(窗口名为Receiver) CString str="进程B"; CWnd *pWnd=CWnd::FindWindow(NULL,str); if(pWnd) { COPYDATASTRUCT buf; char * s=new char[m_Msg1.GetLength()]; //m_Msg1为CString类型的变量 s=m_Msg1.GetBuffer(0);