山东大学操作系统课程设计代码分析及设计实现及测试报告Word下载.docx
- 文档编号:22742054
- 上传时间:2023-02-05
- 格式:DOCX
- 页数:59
- 大小:51.10KB
山东大学操作系统课程设计代码分析及设计实现及测试报告Word下载.docx
《山东大学操作系统课程设计代码分析及设计实现及测试报告Word下载.docx》由会员分享,可在线阅读,更多相关《山东大学操作系统课程设计代码分析及设计实现及测试报告Word下载.docx(59页珍藏版)》请在冰豆网上搜索。
privateThreadQueuejoinQueue=null;
privatebooleanJoined=false;
publicbooleanIsAlive(){
if(this.status==statusNew||status==statusReady||
status==statusRunning||status==statusBlocked)
returntrue;
elsereturnfalse;
}
publicvoidjoin(){
//
if(!
this.IsAlive())return;
while(IsAlive()){
//
this.joinQueue.acquire(this);
//
}
this.joinQueue.waitForAccess(KThread.currentThread());
KThread.sleep();
publicstaticvoidfinish(){
///
if(currentThread.Joined){
currentThread.joinQueue.nextThread().ready();
///
3.1.4测试代码及结果
创建AThread和Bthread两个线程,AThread循环打印“AThread循环第..次”语句,Bthread开始打印“B_thread就绪”语句,中间执行AThread。
Join()方法,最后打印“B_thread执行结束”语句。
测试代码:
packagenachos.threads;
importnachos.machine.*;
publicclassKThreadTest{
publicKThreadTest(){
publicstaticvoidsimpleJoinTest(){
KThreadA_thread=newKThread(newKThreadTest.A_thread(5));
KThreadB_thread=newKThread(newKThreadTest.B_thread(A_thread));
B_thread.fork();
B_thread.join();
publicstaticclassB_threadimplementsRunnable{
B_thread(KThreadjoinee){
this.joinee=joinee;
publicvoidrun(){
System.out.println("
B_thread就绪"
);
ForkingandjoiningA_thread..."
this.joinee.fork();
this.joinee.join();
B_thread执行结束"
privateKThreadjoinee;
publicstaticclassA_threadimplementsRunnable{
A_thread(intnum){
this.num=num;
A_thread就绪"
A_thread开始执行"
//Thisshouldjustkillsomecycles
for(inti=0;
i<
this.num;
++i){
A_thread循环第"
+i+"
次"
KThread.currentThread().yield();
A_thread执行结束"
privateintnum;
测试结果:
3.2Task1.2condition2类
3.2.1要求分析
threads.Lock类提供了锁以保证互斥.在临界代码区的两端执行Lock.acquire()和Lock.release()即可保证同时只有一个线程访问临界代码区.条件变量建立在锁之上,由threads.Condition实现,它是用来保证同步的工具.每一个条件变量拥有一个锁变量(该锁变量亦可被执行acquire和release操作,多个条件变量可共享同一个锁变量).当处于临界区内的拥有某锁Lock的当前线程对与锁Lock联系的条件变量执行sleep操作时,该线程失去锁L并被挂起.下一个等待锁L的线程获得锁L(这个过程由调度程序完成)并进入临界区.当拥有锁L的临界区内的当前线程对与锁L联系的条件变量执行wake操作时(通常调用wake之后紧接着就是Lock.release),等待在该条件变量上的至多一个被挂起的线程(由调用sleep引起)被重新唤醒并设置为就绪状态.若执行wakeall操作,则等待在该条件变量上的所有被挂起的线程都被唤醒.threads.condition已经实现了一个条件变量(采用信号量实现),题目要求用屏蔽/禁止中断的方法再实现一下条件变量(写在threads.condition2中)
3.2.2设计方案
为每个条件变量添加一个锁conditionLock和一个Kthread对象组成的等待队列waitqueue,condition.sleep将调用sleep()的线程加入到等待队列,释放锁,并阻塞,以便其他线程唤醒它,一旦’唤醒’立即要求锁,并在sleep函数开始/结尾处屏蔽/允许中断以保证原子性;
condition.wake中从等待队列中取出线程进行ready()实现唤醒,
(同样要在wake函数开始/结尾处屏蔽/允许中断),wakeall函数的实现依赖于wake.只需不断地wake直到队列为空为止.
3.2.3实现代码
见threads/condition2.java
privateLockconditionLock;
privateLinkedList<
KThread>
waitQueue;
publicvoidsleep(){
waitQueue.add(KThread.currentThread());
conditionLock.release();
conditionLock.acquire();
publicvoidwake(){
waitQueue.remove().ready();
3.2.4测试代码及结果
创建共有条件变量c2test,一个临界资源count和三个线程,thread1,thread2,thread3,初始化三个线程后thread1,thread2调用c2test.sleep()后开始“睡眠”,thread3调用c2test.wakeAll()唤醒所有线程,thread1,thead2开始交替访问临界资源count并更改其“余额”数值。
publicclassCondition2Test{
Lockcondlock=newLock();
Condition2c2test=newCondition2(condlock);
publicCondition2Test(){
publicvoidsimpleCondition2Test(){
System.out.println("
\n****Condition2Testisnowexecuting.****"
初始化账户余额为10000"
finalMyCountmyCount=newMyCount("
0000001"
10000);
//创建并发访问的账户
KThreadthread1=newKThread(newRunnable(){
newSaveThread("
张三"
myCount,2000);
张三goestosleep"
condlock.acquire();
c2test.sleep();
System.out.println("
张三reacquireslockwhenwoken."
condlock.release();
张三isawake!
!
"
myCount.save(2000,"
张三"
});
KThreadthread2=newKThread(newRunnable(){
李四"
李四goestosleep"
李四reacquireslockwhenwoken."
李四isawake!
李四"
KThreadthread3=newKThread(newRunnable(){
thread3Wakingupthethread"
condlock.acquire();
c2test.wakeAll();
condlock.release();
张三and李四wokeupbywakeAll"
thread1.fork();
thread2.fork();
thread3.fork();
thread1.join();
thread2.join();
thread3.join();
****Condition2Testfinished.****\n"
}
}
classSaveThreadextendsKThread{
privateStringname;
//操作人
privateMyCountmyCount;
//账户
privateintx;
//存款金额
SaveThread(Stringname,MyCountmyCount,intx){
this.name=name;
this.myCount=myCount;
this.x=x;
publicvoidrun(){
myCount.save(x,name);
classMyCount{
privateStringid;
//账号
privateintcash;
//账户余额
Locklock=newLock();
//账户锁
Condition2c2test=newCondition2(lock);
MyCount(Stringid,intcash){
this.id=id;
this.cash=cash;
publicvoidsave(intx,Stringname){
lock.acquire();
//获取锁
if(x>
0){
cash+=x;
//存款
System.out.println(name+"
存款"
+x+"
,当前余额为"
+cash);
lock.release();
//释放锁
3.3Task1.3alram类
3.3.1要求分析
一个线程调用waitUntil(x)后,它即被挂起.在当前时钟走过x个滴答后,该线程被重新唤醒.线程被唤醒后并不一定立即进入运行态,只要将其放入就绪队列中即可.另外,多个线程可以分别调用waitUntil函数。
3.3.2设计方案
于Alarm类有关的是machine.Timer类.它在大约每500个时钟滴答使调用回调函数(由Timer.setInterruptHandler函数设置).因此,Alarm类的构造函数中首先要设置该回调函数Alarm.timerInterrupt().
为了实现waitUntil,需要在Alarm类中实现一个队列Alarm.alarmQueue.队列中的每个项目是(线程,唤醒时间,相应条件变量)的三元组.在调用waitUntil(x)函数时,首先得到关于
以上三元组的信息:
(线程:
当前线程,唤醒时间:
当前时间+x,新分配的条件变量),然后将该元组放入队列中,并对条件变量sleep操作使当前线程挂起.在时钟回调函数中(大约每500个时钟间隔调用一次)则依次检查队列中的每个三元组.如果唤醒时间大于当前时间,则将元组移出队列并对元组中的条件变量执行wake操作将相应线程唤醒.
3.3.3实现代码
publicvoidtimerInterrupt(){
while(!
alarmqueue.isEmpty()&
&
(alarmqueue.peek().wakeTime<
=Machine.timer().getTime())){
AlarmThreadthread=alarmqueue.remove();
thread.waitThread.ready();
//
publicvoidwaitUntil(longx){
AlarmThreadthread=newAlarmThread(KThread.currentThread(),wakeTime,conditionlock);
alarmqueue.add(thread);
privateKThreadwaitThread;
privateConditiontimecondition;
privatelongwakeTime;
3.3.4测试代码及结果
创建5个线程,依次“睡眠”20000ticks,线程醒来后各自打印出睡眠开始时间,要求睡眠时间,醒来时间,以及实际睡眠时间。
测试代码:
publicstaticvoidselfTest(intnumOfTest){
Runnablea=newRunnable(){
AlarmTestThread();
};
for(inti=0;
i<
numOfTest;
i++){
intnumOfThreads=5;
print("
Creating"
+numOfThreads+"
numofthreads"
for(intj=0;
j<
numOfThreads;
j++){
KThreadthread=newKThread(a);
thread.setName("
thread"
thread.fork();
ThreadedKernel.alarm.waitUntil(30000000);
staticvoidAlarmTestThread(){
longsleepTime=20000;
longtimeBeforeSleep=Machine.timer().getTime();
ThreadedKernel.alarm.waitUntil(sleepTime);
longtimeAfterSleep=Machine.timer().getTime();
longactualSleepTime=timeAfterSleep-timeBeforeSleep;
print(KThread.currentThread().toString()+"
被要求在:
"
+timeBeforeSleep+"
睡眠"
+sleepTime+"
ticks"
被唤醒时间:
+Machine.timer().getTime()+"
要求睡眠时间:
:
ticks,实际睡眠时间:
+actualSleepTime);
publicstaticvoidprint(StringMessage){
System.out.println(Message);
3.4Task1.4communicator类
3.4.1要求分析
用条件变量实现Communicator类中的speaker()和listen()函数一个锁lock
两个条件变量speaker(lock),listener(lockw)用来用来控制听说动作。
3.4.2设计方案
每个Communicator有一个锁lock(保证操作的原子性)和与该锁联系的两个条件变量用于保证speaker和listener间的同步.在speak函数中,首先检查若已经有一个speaker在等待(message变量)或无listener等待,则挂起.否则设置message变量,准备数据并唤醒一个listener.在listen函数中,增加一个listener后,若speaker数目非零且listener数目为1(及恰好可以配对)首先唤醒speaker,然后将自己挂起以等待speaker准备好数据再将自己唤醒.这个问题其实是一个缓冲区长度为0的生产者/消费者问题。
3.4.3实现代码
Communicator.java
intspeakersize,listenersize;
intMessage;
Conditionspeaker,listener;
publicvoidspeak(intword){
//
while(speakersize!
=0)
{speaker.sleep();
this.Message=word;
speakersize++;
while(listenersize==0)
{speaker.sleep();
listener.wake();
speakersize--;
speaker.wake();
publicintlisten(){
listenersize++;
if(listenersize==1&
speakersize!
speaker.wake();
listener.sleep();
intmyMessage=this.Message;
listenersize--;
returnmyMessage;
3.4.4测试代码及结果
importjava.util.ArrayList;
importjava.util.Random;
publicclassCommunicatorTest{
publicCommunicatorTest(){
Message=1;
numOfSpeakers=5;
numOfListeners=5;
communicator=newCommunicator();
publicvoidcommTest(intnum){
\nCommunicatorTest开始"
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 山东大学 操作系统 课程设计 代码 分析 设计 实现 测试报告
![提示](https://static.bdocx.com/images/bang_tan.gif)