信号量控制线程同步课程实践报告
课程设计说明书2011—2012学年第一学期
题目:信号量控制线程同步
学院：计算机学院
专业班级：
学号：
学生姓名：
指导教师：
成绩：
时间： 8:00—10:00
2011年12月6日
课程设计任务书
2010 ～2011 学年第一学期
学生姓名：专业班级：
指导教师：工作部门：计算机学院
一、课程设计题目
信号量控制线程同步
二、课程设计内容
该任务含两个程序的设计与编写，程序1同步两个线程，其一输出奇数，另一线程输出偶数，且二者交叉数据输出；程序2实现男女共用浴室的情况下的同步与互斥，男女到达浴室的时间数据放在文本文件。对于给定的输入文件，观察测试输出结果的正确性。
三、进度安排
（1）1-2学时，选定题目、分析需求、理解需求；
（2）3-4学时，程序设计，定义数据类型、数据处理方式；
（3）5-10学时，编写程序、调试、测试；
（4）11-12学时，编写设计报告；
（5）13-16学时，答辩。
四、基本要求
（1）使用偏好的编程语言，源程序要有适当的注释，使程序容易阅读
（2）学生可自动增加新功能模块（视情况可另外加分）。
（3）写出课程设计报告，应不少于3000字（不含附录），同一组学生每人必须提交1份，报告中列明分工。
课程负责人签名：
年月日
课程设计成绩评定表
姓名
成绩评定权重
总分
总成绩
（五分制）平时成绩
20
报告成绩
50
答辩成绩
30
信号量控制线程同步
摘要
信号量控制线程同步算法，主要设置两个线程，用一个或两个信号量分别控制线程，使得线程交替输出，资源临界区信号的控制利用，使用二个信号量，控制二线程其中之一输出一个数后，随后另一个线程也输出一个数，交替输出直至结束。以及实现：当有一个女生在浴室里，那么其他女生可以进入，但是男生不行，反之亦然。
关键词：线程同步信号量临界区
目录
第一章设计内容......................... 错误！未定义书签。第二章总体设计......................... 错误！未定义书签。
2.1 设计任务.............................. 错误！未定义书签。
2.2 设计调用图............................ 错误！未定义书签。第三章详细设计 (3)
3.1 数据结构设计 (3)
3.2流程图 (4)
第四章调试与测试 (5)
4.1 调试过程中的主要问题 (5)
4.2 测试结果 (5)
附录 (8)
参考文献 (17)
心得体会 ................................ 错误！未定义书签。
1 设计内容
编写信号量控制线程同步的算法，实现以下功能：
(1) 两个线程，一者输出1-30的偶数，一者输出1-30的奇数
(2) 使用一个信号量，控制二线程分别输出（即一个线程完成数据输出后，另一个线程方可开始数据输出。）
(3) 使用二个信号量，控制二线程其中之一输出一个数后，随后另一个线程也输出一个数，交替输出直至结束。
(4) 当有一个女生在浴室里，那么其他女生可以进入，但是男生不行，反之亦然。 (5) 本系统是控制台应用程序，界面非常直观
2 总体设计
2.1设计任务：
用用一个信号量，两个线程控制奇偶数的交替输出以及两个线程控制先输出奇数再输出偶数的程序。男女共浴问题先要设置洗澡时间，男人和女人到达浴室的时间，还要读写文件，并且在文件中显示出最后的结果。程序要设计得简单，可读性强，运行效率高，占用内存小，有一定的健壮性和良好的可维护性。
2.2 设计调用图
图2-1设计调用图1
主函数
Thread_1() Thread_2()
Main()
Male()
Female() FemaleThread()
MaleThread(
图2-2设计调用图2
3 详细设计
3.1数据结构设计：
这两个程序使用C#编写：
程序1：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ConsoleApplication1{};//命名空间
private static void Thread_1()；//控制奇数输出的线程函数private static void Thread_2()；//控制偶数输出的线程函数
程序2：
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.IO;
namespace ConsoleApplication2{};//命名空间
public static void Male(ref int[] data)；// public static void Female(ref int[] data)；//
private static void MaleThread()；//
private static void FemaleThread()//
3.2流程图：
信号量控制线程同步1 创建奇数线程对象thrad1
创建偶数线程对象thread2
一个信号量控制两个线程同步
结束
图3.1 程序结构概览图
信号量控制线程同步2
4 调试与测试
4.1调试过程主要问题：
我在测试本程序的时候最主要的问题就是在VC++6.0与VS2008之中对于条用系统的函数pow(2,k-i)的不一致，VS2008中老是提示函数调用不明确，导致遇到了一些问题，不过最终还是找到的问题的所在，那就是double型和int行的隐式转换问题。
还有对于文件存储问题是在不知道怎么去处理，又加上是在对并不怎么熟悉的伙伴系统之中，只好舍之（当然，是为了能够正确测试出程序的可运行性和直观性）。经过这次的课程设计，还是学会了编程不但需要头脑，还要很细心才行。
4.2 测试结果
①内存申请与回收后块的大小变化显示
附录
// MMC.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
/* algo8-2.c 伙伴系统。实现算法8.2的程序 */
#include"c1.h"
#include"c8-2.h"
#define N 100 /* 占用块个数的最大值 */
Space r; /* r为生成空间的首地址，全局量 */
unsigned char *p;
unsigned char gBuffer[256*1024];//长度为0~255的char类型
Space AllocBuddy(FreeList avail,int n)
{ /* avail[0..m]为可利用空间表，n为申请分配量，若有不小于n的空闲块，*/
/* 则分配相应的存储块，并返回其首地址；否则返回NULL。算法8.2 */
int i,k;
Space pa,pi,pre,suc;
for(k=0;k<=m&&(avail[k].nodesize if(k>m) /* 分配失败，返回NULL */ return NULL; else /* 进行分配 */ { pa=avail[k].first; /* pa指向可分配子表的第一个结点 */ pre=pa->llink; /* pre和suc分别指向pa所指结点的前驱和后继 */ suc=pa->rlink; if(pa==suc) /* 可分配子表只有1个结点 */ avail[k].first=NULL; /* 分配后该子表变成空表 */ else /* 从子表中删去pa所指结点(链表的第1个结点) */ { pre->rlink=suc; suc->llink=pre; avail[k].first=suc; /* 该子表的头指针指向pa所指结点的后继 */ } for(i=1;avail[k-i].nodesize>=n+1;++i) { /* 从大到小将剩余块插入相应子表，约定将低地址(最前面)的块作为分配块 */ pi=pa+(int)pow(2,k-i); /* pi指向再分割的后半块(剩余块) */ pi->rlink=pi; /* pi是该链表的第1个结点，故左右指针都指向自身 */ pi->llink=pi; pi->tag=0; /* 块标志为空闲 */ pi->kval=k-i; /* 块大小 */ avail[k-i].first=pi; /* 插入链表 */ } pa->tag=1; /* 最后剩给pa的是分配块，令其块标志为占用 */ pa->kval=k-(--i); /* 块大小 */ } return pa; /* 返回分配块的地址 */ } Space buddy(Space p) { /* 返回起始地址为p，块大小为pow(2,p->kval)的块的伙伴地址 */ if((p-r)%(int)pow(2,p->kval+1)==0) /* p为前块 */ return p+(int)pow(2,p->kval); /* 返回后块地址 */ else /* p为后块 */ return p-(int)pow(2,p->kval); /* 返回前块地址 */ } void Reclaim(FreeList pav,Space *p) { /* 伙伴系统的回收算法。将p所指的释放块回收到可利用空间表pav中 */ Space s; s=buddy(*p); /* 伙伴块的起始地址 */ while(s>=r&&s { /* ,伙伴块起始地址在有效范围内且伙伴块空闲并与p块等大，从链表上删除该伙伴块结点 */ if(s->rlink==s) /* 链表上仅此一个结点 */ pav[s->kval].first=NULL; /* 置此链表为空 */ else /* 链表上不止一个结点 */ { s->llink->rlink=s->rlink; /* 前驱的后继为该结点的后继 */ s->rlink->llink=s->llink; /* 后继的前驱为该结点的前驱 */ if(pav[s->kval].first==s) /* s是链表的第一个结点 */ pav[s->kval].first=s->rlink; /* 修改表头指向下一个结点 */ } /* 以下修改结点头部 */ if((*p-r)%(int)pow(2,(*p)->kval+1)==0) /* p为前块 */ (*p)->kval++; /* 块大小加倍 */ else /* p为后块(s为前块) */ { s->kval=(*p)->kval+1; /* 块大小加倍 */ *p=s; /* p指向新块首地址 */ } s=buddy(*p); /* 下一个伙伴块的起始地址 */ } /* 以下将p插到可利用空间表中 */ (*p)->tag=0; /* 设块标志为空闲 */ if(pav[(*p)->kval].first==NULL) /* 该链表空 */ pav[(*p)->kval].first=(*p)->llink=(*p)->rlink=*p; /* 左右指针及表头都指向自身 */ else /* 该链表不空，插在表头 */ { (*p)->rlink=pav[(*p)->kval].first; (*p)->llink=(*p)->rlink->llink; (*p)->rlink->llink=*p; (*p)->llink->rlink=*p; pav[(*p)->kval].first=*p; } *p=NULL; } void Print(FreeList p) { /* 输出p中所有可利用空间表 */ int i; Space h; for(i=0;i<=m;i++) if(p[i].first) /* 第i个可利用空间表不空 */ { h=p[i].first; /* h指向链表的第一个结点的头部域(首地址) */ do { printf("块的大小=%d 块的首地址=%u ",(int)pow(2,h->kval),h); /* 输出结点信息 */ printf("块标志=%d(0:空闲 1:占用)\n",h->tag); h=h->rlink; /* 指向下一个结点的头部域(首地址) */ }while(h!=p[i].first); /* 没到循环链表的表尾 */ } } void PrintUser(Space p[]) { /* 输出p数组所指的已分配空间 */ int i; for(i=0;i if(p[i]) /* 指针不为0(指向一个占用块) */ { printf("占用块%d的首地址=%u ",i,p[i]); /* 输出结点信息 */ printf("块的大小=%d",(int)pow(2,p[i]->kval)); printf(" 块标志=%d(0:空闲 1:占用)\n",p[i]->tag); } } void main() { int i,n; FreeList a; Space q[N]={NULL}; /* q数组为占用块的首地址 */ printf("sizeof(BYTE_b)=%u m=%u (int)pow(2,m)=%u\n",sizeof(BYTE_b),m,(int)pow(2,m)); for(i=0;i<=m;i++) /* 初始化a */ { a[i].nodesize=(int)pow(2,i); a[i].first=NULL; } memset(gBuffer,0x00,256*1024); //r=a[m].first=(BYTE_b*)malloc(a[m].nodesize*sizeof(BYTE_b)); /* 在最大链表中生成一个结点 */ r=a[m].first=(BYTE_b*)gBuffer; if(r) /* 生成结点成功 */ { r->llink=r->rlink=r; /* 初始化该结点 */ r->tag=0; r->kval=m; Print(a); n=100; q[0]=AllocBuddy(a,n); /* 向a申请100个BYTE_b的内存(实际获得128个BYTE_b) */ memcpy(q[0]+2,"aaaaaa",6); printf("%s",q[0]); printf("申请%d个字节后，可利用空间为:\n",n); Print(a); PrintUser(q); n=200; q[1]=AllocBuddy(a,n); /* 向a申请200个BYTE_b的内存(实际获得256个BYTE_b) */ memcpy(q[1]+2,"aaaaaa",6); printf("%s",q[0]); printf("申请%d个字节后，可利用空间为:\n",n); Print(a); PrintUser(q); n=220; q[2]=AllocBuddy(a,n); /* 向a申请220个BYTE_b的内存(实际获得256个BYTE_b) */ memcpy(q[2]+2,"aaaaaa",6); printf("%s",q[0]); printf("申请%d个字节后，可利用空间为:\n",n); Print(a); PrintUser(q); Reclaim(a,&q[1]); /* 回收q[1]，伙伴不空闲 */ printf("回收q[1]后，可利用空间为:\n"); Print(a); PrintUser(q); Reclaim(a,&q[0]); /* 回收q[0]，伙伴空闲 */ printf("回收q[0]后，可利用空间为:\n"); Print(a); PrintUser(q); Reclaim(a,&q[2]); /* 回收q[2]，伙伴空闲，生成一个大结点 */ printf("回收q[2]后，可利用空间为:\n"); Print(a); PrintUser(q); } else printf("ERROR\n"); } 参考文献 [1]Bruce Eckel：《Java编程思想》[M]，机械工业出版社第四版 [2]严蔚敏吴伟民：《数据结构》[M]，清华大学出版社 [3]Andrew.T ：《现代操作系统》[M]，机械工业出版社 [4]陈维心林小茶：《C++面向对象程序设计教程》[M]，清华大学出版社 [5]Mark Allen Weiss：《数据结构与算法分析》[M]，人民邮电出版社 心得体会 又是一次课程设计，之前经过了大二时期的课程设计之后，渐渐对课程设计有一定的了解，所以对于这次的课程设计来说，相比之前容易了不少，不过通过这次操作系统的课程设计，主要让我学习了有关信号量，内存等方面的一些问题，虽说伙伴系统对于自己来说有难度，但是通过实践调试和查找相关资料，懂得怎么样去发现错误了，学习理论课上不明白的东西。不过，其中自己也犯了不少的错误，必须的一个一个错误和问题的解决。再次使用C++编程，这门编程语言博大精深，这次实践课的内容和经验，让自己温习了以前所学的东西，又加强了自己和团队的交流。 每次实践课都是一个学习理论的验证，我觉得不管什么课程的实践课都必须认真对待，通过实际操作去理解理论中的抽象，那样才能真正弄懂这门课程的精髓，才能在学习中有所收获。 计算机学院课程设计答辩记录表 专业学院计算机学院专业软件工程姓名学号课程设计 信号量控制线程同步 题目 答辩日期答辩时间 答 辩 提 问 及 其 回 答 记 录 教师评语 进程的控制 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 实验2 并发与调度 2.2 Windows 2000线程同步 (实验估计时间：120分钟) 背景知识 实验目的 工具/准备工作 实验内容与步骤 背景知识 Windows 2000提供的常用对象可分成三类：核心应用服务、线程同步和线程间通讯。其中，开发人员可以使用线程同步对象来协调线程和进程的工作，以使其共享信息并执行任务。此类对象包括互锁数据、临界段、事件、互斥体和信号等。 多线程编程中关键的一步是保护所有的共享资源，工具主要有互锁函数、临界段和互斥体等；另一个实质性部分是协调线程使其完成应用程序的任务，为此，可利用内核中的事件对象和信号。 在进程内或进程间实现线程同步的最方便的方法是使用事件对象，这一组内核对象允许一个线程对其受信状态进行直接控制 (见表4-1) 。 而互斥体则是另一个可命名且安全的内核对象，其主要目的是引导对共享资源的访问。拥有单一访问资源的线程创建互斥体，所有想要访问该资源的线程应该在实际执行操作之前获得互斥体，而在访问结束时立即释放互斥体，以允许下一个等待线程获得互斥体，然后接着进行下去。 与事件对象类似，互斥体容易创建、打开、使用并清除。利用CreateMutex() API 可创建互斥体，创建时还可以指定一个初始的拥有权标志，通过使用这个标志，只有当线程完成了资源的所有的初始化工作时，才允许创建线程释放互斥体。 为了获得互斥体，首先，想要访问调用的线程可使用OpenMutex() API来获得指向对象的句柄；然后，线程将这个句柄提供给一个等待函数。当内核将互斥体对象发送给等待线程时，就表明该线程获得了互斥体的拥有权。当线程获得拥有权时，线程控制了对共享资源的访问——必须设法尽快地放弃互斥体。放弃共享资源时需要在该对象上调用ReleaseMute() API。然后系统负责将互斥体拥有权传递给下一个等待着的线程(由到达时间决定顺序) 。 实验目的 在本实验中，通过对事件和互斥体对象的了解，来加深对Windows 2000线程同步的理解。 1) 回顾系统进程、线程的有关概念，加深对Windows 2000线程的理解。 2) 了解事件和互斥体对象。 3) 通过分析实验程序，了解管理事件对象的API。 4) 了解在进程中如何使用事件对象。 5) 了解在进程中如何使用互斥体对象。 6) 了解父进程创建子进程的程序设计方法。 工具/准备工作 在开始本实验之前，请回顾教科书的相关内容。 您需要做以下准备： 1) 一台运行Windows 2000 Professional操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版。 实验内容与步骤 1. 事件对象 2. 互斥体对象 1. 事件对象 清单2-1程序展示了如何在进程间使用事件。父进程启动时，利用CreateEvent() API创建一个命名的、可共享的事件和子进程，然后等待子进程向事件发出信号并终止父进程。在创建时，子进程通过OpenEvent() API打开事件对象，调用SetEvent() API使其转化为已接受信号状态。两个进程在发出信号之后几乎立即终止。 步骤1：登录进入Windows 2000 Professional。 步骤2：在“开始”菜单中单击“程序”-“Microsoft Visual Studio 6.0”–“Microsoft Visual C++ 6.0”命令，进入Visual C++窗口。 java多线程实验报告 篇一：西北农林科技大学java多线程实验报告 实验7 多线程 1.实验目的 (1) 掌握Java多线程的概念和实现方法 (2) 掌握Java多线程的同步问题 2.实验内容 任务一：火车售票 假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒买一张票。打印出售票过程，注意使用synchronized确保同一张票只能卖出一次。程序运行结果见左图。 打开Eclipse Tickets.java public class Ticket extends Thread { int ticket =1000; String name =""; public void run(){ while(true){synchronized(name){ if(ticket "第" + Thread.currentThread().getName()+ "售票点卖出了第" + ticket-- + "张票"); } } } }} try{ } catch(InterruptedException e){ } Thread.sleep(100); Test.java public class Test { } public static void main(String args[]){} Ticket t = new Ticket(); new Thread(t,"1").start(); new Thread(t,"2").start(); new Thread(t,"3").start(); new Thread(t,"4").start(); new Thread(t,"5").start(); new Thread(t,"6").start(); new Thread(t,"7").start(); new Thread(t,"8").start(); new Thread(t,"9").start(); new Thread(t,"10").start(); 任务二：银行存款 假设某家银行，它可接受顾客的汇款，每做一次汇款，便可计算出汇款的总额。现有两个顾客，每人都分3次，每次100元将钱到入。试编写一个程序，模拟实际作业。 程序如下： classCBank { private static int sum=0; public static void add(int n){ inttmp=sum; tmp=tmp+n;// 累加汇款总额 try{ Thread.sleep((int)(10000*Math.random())); // 实验三：进程同步实验 一、实验任务： (1)掌握操作系统的进程同步原理； (2)熟悉linux的进程同步原语； (3 )设计程序，实现经典进程同步问题。 二、实验原理： (1)P、V操作 PV操作由P操作原语和V操作原语组成(原语是不可中断的过程) ，对信号量进行操作，具体定义如下： P( S):①将信- 号量S的值减1,即S=S-1; ②如果S30，则该进程继续执行；否则该进程置为等待状态，排入等待队列。 V( S):①将信号量S的值加1,即S=S+1 ； ②如果S>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。 (2)信号量 信号量(semaphore )的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的 值仅能由PV操作来改变。 一般来说，信号量S30时，S表示可用资源的数量。执行一次P操作意味着请求分配一 个单位资源，因此S的值减1;当S<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S 的值加1;若S均，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。 (3)linux的进程同步原语 ①wait();阻塞父进程，子进程执行； ②#in clude 操作系统 实验报告 哈尔滨工程大学 计算机科学与技术学院 一、实验概述 1. 实验名称 进程的同步 2. 实验目的 ⑴使用EOS的信号量，编程解决生产者 消费者问题，理解进程同步的意义。 ⑵调试跟踪EOS信号量的工作过程，理解进程同步的原理。 ⑶修改EOS的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理。 3. 实验类型 验证+设计 4. 实验内容 ⑴准备实验 ⑵使用EOS的信号量解决生产者－消费者问题 ⑶调试EOS信号量的工作过程 ①创建信号量 ②等待释放信号量 ③等待信号量（不阻塞） ④释放信号量（不唤醒） ⑤等待信号量（阻塞） ⑥释放信号量（唤醒） ⑷修改EOS的信号量算法 二、实验环境 WindowsXP + EOS集成实验环境 三、实验过程 1. 设计思路和流程图 图4-1.整体试验流程图 图4-2.Main 函数流程图、生产者消费、消费者流程图 2. 算法实现 3. 需要解决的问题及解答 (1). 思考在ps/semaphore.c 文件内的PsWaitForSemaphore 和PsReleaseSemaphore 函数中，为什么要使用原子操作？ 答：在执行等待信号量和释放信号量的时候，是不允许cpu响应外部中断的，如果此时cpu响应了外部中断，会产生不可预料的结果，无法正常完成原子操作。 (2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。 (3).P143生产者在生产了13号产品后本来要继续生产14号产品，可此时生产者为什么必须等待消费者消费了4号产品后，才能生产14号产品呢？生产者和消费者是怎样使用同步对象来实现该同步过程的呢？ 答：这是因为临界资源的限制。临界资源就像产品仓库，只有“产品仓库”空闲生产者才能生产东西，有权向里面放东西。所以它必须等到消费者，取走产品，“产品空间”（临界资源）空闲时，才继续生产14号产品。 (4). 根据本实验3.3.2节中设置断点和调试的方法，自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞，直到生产者线程生产了24号产品后，消费者线程才被唤醒并继续执行的过程。 答：可以按照下面的步骤进行调试 (1) 删除所有的断点。 (2) 按F5启动调试。OS Lab会首先弹出一个调试异常对话框。 (3) 在调试异常对话框中选择“是”，调试会中断。 (4) 在Consumer函数中等待Full信号量的代码行（第173行）WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。 (5) 在“断点”窗口（按Alt+F9打开）中此断点的名称上点击右键。 (6) 在弹出的快捷菜单中选择“条件”。 (7) 在“断点条件”对话框（按F1获得帮助）的表达式编辑框中，输入表达式“i == 24”。 (8) 点击“断点条件”对话框中的“确定”按钮。 (9) 按F5继续调试。只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。 4. 主要数据结构、实现代码及其说明 修改PsWaitForSemaphore函数 if (Semaphore->Count>0){ Semaphore->Count--; flag=STATUS_SUCCESS; }//如果信号量大于零，说明尚有资源，可以为线程分配 else flag=PspWait(&Semaphore->WaitListHead, Milliseconds); KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。 return flag; }//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待 修改PsReleaseSemaphore函数 if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) { 实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念，并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 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; 实验报告 课程名称： Java语言程序设计 姓名: 学号: 班级: 数学与计算机科学学院 数学与计算机科学学院实验报告实验名称：多线程 指导教师：日期： if (isPrime) count++; } System.out.println(st + "~" + en + "之间共有" + count + "个质数"); } public static void main(String[] args) { UseThread thread1 = new UseThread(2, 1000); UseThread thread2 = new UseThread(1000, 2000); thread1.start(); thread2.start(); } } 第2题代码： public class Experiment14_2 { public static void main(String[] args) { MyThread t1 = new MyThread("T1"); MyThread t2 = new MyThread("T2"); t1.start(); t2.start(); System.out.println("活动线程数：" + Thread.activeCount()); System.out.println("main()运行完毕"); } } class MyThread extends Thread { public MyThread(String s) { super(s); } public void run() { for (int i = 1; i <= 3; i++) { System.out.println(getName() + "第" + i + "次运行"); try { sleep((int) (Math.random() * 100)); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(getName() + "结束"); } } 实验题目进程的创建小组合作否姓名班级学号 一、实验目的 1、了解进程的创建。 2、了解进程间的调用以及实现。 3、分析进程竞争资源的现象，学习解决互斥的方法。 4、加深对进程概念的理解，认识并发执行的本质。 二．实验环境 Windows 系统的计算机一台，安装了Linux虚拟机 三、实验内容与步骤 1、fork（）系统调用的使用例子 程序代码： #include wait(0); printf("parent process doesn't change the glob and loc:\n"); printf("glob=%d,loc=%d\n",glob,loc); exit(0); } 运行结果： 2、理解vofork（）调用： 程序代码： #include 多线程同步操作多个窗口 RunApp "notepad.exe" RunApp "notepad.exe" RunApp "notepad.exe" Delay 2000 Dimenv temp_Hwnd temp_Hwnd = 0 Dim str, arr, i str = Plugin.Window.Search("无标题- 记事本") arr = Split(str, "|") For i = 0 To UBound(arr) - 1 temp_Hwnd = Plugin.Window.FindEx(arr(i), 0, "Edit", 0) BeginThread WriteString While temp_Hwnd <> 0'判断多线程已经启动完毕，继续循环下一个。 Delay 500 Wend Next EndScript Function WriteString() Dim str, Hwnd Hwnd = temp_Hwnd temp_Hwnd = 0 Do str = WaitKey If Hwnd <> Plugin.Window.GetKeyFocusWnd Then Call Plugin.Bkgnd.KeyPress(Hwnd, str) End If Loop End Function 多线程多开窗口同步执行与子线程间的数值如何传递： 1.Dimenv IsThread, i 2.Dim arr_Thread() 3.For i = 0 To 2 4. IsThread = False'未启动线程 5. Redim Preserve arr_Thread(i) 6. arr_Thread(i) = BeginThread(EnterThread) 7. While IsThread = False'未启动成功，等待中 8. Delay 500 9. Wend 10. '跳出循环说明 IsThread = True，已经执行到了，循环继续启动下一个 11.Next 操作系统实验报告 课程名称操作系统实验名称进程（线程）的同步与互斥成绩 学生姓名作业君专业软件工程班级、学号 同组者姓名无实验日期2020 一、实验题目:进程（线程）的同步与互斥 二、实验目的： 自行编制模拟程序，通过形象化的状态显示，加深理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。1．掌握基本的同步与互斥算法，理解生产者消费者模型。 2．学习使用Windows中基本的同步对象，掌握相关API的使用方法。 3．了解Windows中多线程的并发执行机制，实现进程的同步与互斥 三、实验内容与要求： 1．实验内容 以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。 2．实验要求 学习并理解生产者/消费者模型及其同步/互斥规则； 学习了解Windows同步对象及其特性； 熟悉实验环境，掌握相关API的使用方法； 设计程序，实现生产者/消费者进程(线程)的同步与互斥； 四、算法描述（含数据结构定义）或流程图 #include #define MAX_THREAD_NUM 64 //最大线程数 #define INTE_PER_SEC 1000 //延迟时间的毫秒值 const int SIZE_OF_BUFFER = 10; //缓冲区长度 int ProductID = 0; //产品号 int ConsumeID = 0; //将被消耗的产品号 int in = 0; //产品进缓冲区时的缓冲区下标 int out = 0; //产品出缓冲区时的缓冲区下标 bool running = true; //判断程序能否继续执行的逻辑值 int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列 HANDLE g_hMutex; //公有信号量，用于线程间的互斥HANDLE g_hFullSemaphore; //生产者的私有信号量，当缓冲区满时迫使生产者等待 HANDLE g_hEmptySemaphore; //消费者的私有信号量，当缓冲区空时迫使消费者等待 //定义一个结构体用于存储线程的信息 struct ThreadInfo { int serial; //线程号 char entity; //线程类别(生产者或消费者) double delay; //等待时间 double persist; //操作时间 }; //生产者 void Producer(void* p) { //定义变量用于存储当前线程的信息 DWORD m_delay; DWORD m_persist; int m_serial; //从参数中获得信息 m_serial = ((ThreadInfo*)(p))->serial; m_delay = (DWORD)(((ThreadInfo*)(p))->delay * INTE_PER_SEC); m_persist = (DWORD)(((ThreadInfo*)(p))->persist * INTE_PER_SEC); while (running) { //P操作 cout << "生产者线程 " << m_serial << " 请求生产." << endl; WaitForSingleObject(g_hEmptySemaphore, INFINITE); 线 程实验报告 黄澄宇320070911241 1.分析 （1）问题阐述，描述。 运用线程的方法设计一个ftp面向客户\服务器的网络应用程序，主要包括服务器端和客户端两方面的工作。 （2）问题分析。 针对问题要求，应该能够实现客户端和服务器端的功能。其中服务器端主要对客户端进行监听。客户端向服务器端进行提出请求。 （3）寻找揭发。 TCP\IP服务器端应用程序都是通过JA V A语言中提供的SeverSocket和Socket两个有关网络的类来实现。 SeverSocket类除了建立一个Sever之外，还通过accept()方法提供了随时监听客户端连接请求的功能。 2.设计。 在服务器端指定一个用来等待连接的端口号，在客户端规定一个主机和端口号，从而在客户端和服务器端创建Socket\ServerSocket实例。 现在服务器端生成一个ServerSocket实例的对象，随时监听客户端的连接请求。 当客户端需要连接时，相应的要生成一个Socket实例的对象，并发出连接请求，其在host参数指明该主机名，port参数指明端口号。 服务器端通过accept（）方法接收到客户端的请求后，开辟一个接口与之进行连接，利用输入输出流，按照一定的协议对Socket 进行读写操作。 关闭输入输出流和Socket。 3.实现。 //FTPServer.java import https://www.360docs.net/doc/c3889689.html,.*; import java.io.*; import java.util.*; public class FTPServer { public static void main(String args[]) throws Exception { ServerSocket soc=new ServerSocket(5127); System.out.println("FTP Server Started on Port Number "); while(true) { 一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求： 1．子线程输出的线程序号不能重复。 2．全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1．主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2．子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果： 实验四同步与互斥 【实验目的和要求】 1、掌握进程（线程）的同步与互斥。 2、掌握生产者消费者问题的实现方法。 3、掌握多线程编程方法。 【实验内容】 实现生产者消费者问题 1、有一个仓库，生产者负责生产产品，并放入仓库，消费者会从仓库中拿走产品(消费)。 2、仓库中每次只能入一个(生产者或消费者)。 3、仓库中可存放产品的数量最多10个,当仓库放满时，生产者不能再放入产品。 4、当仓库空时，消费者不能从中取出产品。 5、生产、消费速度不同。 【实验原理】 1、信号量mutex提供对缓冲池访问的互斥要求并初始化为1，信号量empty和 full分别用来表示空缓冲项和满缓冲项的个数，信号量empty初始化为n，信号量full初始化为0。 2、定义如下结构及数据： 定义缓冲区内的数据类型：typedef int buffer_item; 缓冲区：buffer_item buffer[BUFFER_SIZE]; 对缓冲区操作的变量：int in,out; 信号量mutex提供了对缓冲池访问的互斥要求：pthread_mutex_t mutex; 信号量empty和full分别表示空缓冲顶和满缓冲顶的个数：sem_t empty,full; 可以设定生产者的生产速度及消费者的消费速度：int pro_speed,con_speed; 对缓冲区操作的自增函数：#define inc(k) if(k < BUFFER_SIZE) k = k+1;else k=0 3、并定义了如下实现问题的函数模块： 将生产的产品放入缓冲区： int insert_item(buffer_item item) 从缓冲区内移走一个产品： int remove_item(buffer_item *item) 生产者进程：void *producer(void *param) 消费者进程：void *consumer(void *param) 生产者结构进程消费者结构进程 【程序代码】 //sx.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.这一点有助于理解消息转送的实现机理。 线程程序设计 一、课题内容和要求 内容：设计和编写一个编写一个指针式时钟程序，应用线程实现时钟的走动。 要求：本实验旨在通过实验，培养学生将JAVA 线程的相关知识点（包括线程调度，线程同步等）有机结合并加以综合应用，在实验中设计多线程程序的能力。 二、设计思路分析 class Clock:一个指针式时钟的主类 class Layout: 添加窗口和时钟组件 class ClockPaint:定义时钟组件 三、概要设计 public class Clock extends JFrame { public static void main(String[] s) ; } class Layout extends JFrame { public Layout(); } class ClockPaint extends JPanel implements Runnable { int x, y, r; int h, m, s; double rad = Math.PI / 180; public ClockPaint(int x, int y, int r); public void paint(Graphics g); public void run(); } 时钟的绘制: 运行时钟: 四、详细设计 import java.awt.*; import javax.swing.*; import java.util.*; public class Clock extends JFrame { public static void main(String[] s) { new Layout(); } } class Layout extends JFrame {// 添加窗口和时钟组件public Layout() { ClockPaint cp = new ClockPaint(20, 20, 70); add(cp); . 题目用多线程同步方法解决生产者－消费 者问题(Producer-Consumer Problem) 学院计算机科学与技术学院 专业软件工程 班级 姓名 指导教师 年月日 目录 目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16) 课程设计任务书 学生姓名：专业班级： 指导教师：工作单位：计算机科学与技术学院 题目: 用多线程同步方法解决生产者－消费者问题 (Producer-Consumer Problem) 初始条件： 1．操作系统：Linux 2．程序设计语言：C语言 3．有界缓冲区内设有20个存储单元，其初值为0。放入／取出的数据项按增序设定为1－20这20个整型数。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要 求） 1．技术要求： 1）为每个生产者／消费者产生一个线程，设计正确的同步算法 2）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、当前指针位置和生产者／消费者线程的自定义标识符。 3）生产者和消费者各有两个以上。 4）多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2．设计说明书内容要求： 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个程序及其运行结果的主机IP地址和目录。） 5）运行结果与运行情况 （提示: （1）有界缓冲区可用数组实现。 （2）编译命令可用：cc -lpthread -o 目标文件名源文件名 （3）多线程编程方法参见附件。） 3. 调试报告： 1)调试记录 2)自我评析和总结 上机时间安排： 18周一~ 五 08：0 － 12：00 指导教师签名：年月日进程管理实验报告
实验2-2windows2000 线程同步
java多线程实验报告
操作系统进程同步实验报告
进程的同步实验报告汇总
操作系统实验报告--实验一--进程管理
Java多线程实验报告
操作系统实验报告(进程的创建)(DOC)
多线程同步操作多个窗口
进程(线程)的同步与互斥实验报告
线程实验报告
4：一个经典的多线程同步问题汇总
实验四 同步与互斥 Linux实验报告
进程间通信实验报告
JAVA线程程序设计(小时钟)实验报告(附完整代码)
用多线程同步方法解决生产者-消费者问题(操作系统课设)