数媒操作系统课程设计黄宇达329700042沈宁329700046Word文档下载推荐.docx
- 文档编号:21831842
- 上传时间:2023-02-01
- 格式:DOCX
- 页数:19
- 大小:83.17KB
数媒操作系统课程设计黄宇达329700042沈宁329700046Word文档下载推荐.docx
《数媒操作系统课程设计黄宇达329700042沈宁329700046Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《数媒操作系统课程设计黄宇达329700042沈宁329700046Word文档下载推荐.docx(19页珍藏版)》请在冰豆网上搜索。
2、在Linux2.4中修改调度程序的代码,扩展一个新的调度算法
B、在Java虚拟机上完成如下两个Project(2,3选一):
1、基于java虚拟机的线程调度
2、请求页式管理的Java实现
3.用JAVA语言模仿“生产者—消费者问题
C、方向命题,具体内容不限,任选2题;
D、自主命题。
二、实验内容:
该小组为二人小组,选择完成B类中的以下两个任务
1、基于java虚拟机的线程调度
3、用JAVA语言模仿“生产者—消费者问题
具体实验内容如下
·
基于java虚拟机的线程调度
1、Java线程的优先级机制及调度机制
2、用Java语言实现基于优先级的轮转线程调度
至少创建5个线程并输出它们在上述调度算法下的调度情况,并输出到终端,以检查算法的执行情况
用JAVA语言模仿“生产者—消费者问题”
1.通过Java语言中的wait()和notify()命令模拟操作系统中的P/V操作;
2.为每个生产者/消费者产生一个线程,设计正确的同步算法
3.每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部内容、当前指针位置和生产者/消费者线程的自定义标识符。
4.生产者和消费者各有两个以上。
多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。
三、源代码
1.基于java虚拟机的线程调度
/*起始化类*/
importjava.util.ArrayList;
importjava.util.List;
publicclassProcess{
publicstaticList<
double[]>
task_info=newArrayList<
>
();
//进程列表
publicstaticinttask_num=5;
//进程数
publicstaticvoidinit_task()//初始化进程列表
{
for(inti=0;
i<
task_num;
i++)
double[]t=newdouble[4];
t[0]=i;
//进程号
t[1]=0;
//到达时间
t[2]=0;
//响应比
t[3]=(int)(Math.random()*100)%20+1;
//需要运行时间
task_info.add(t);
}
publicstaticvoidmain(Stringarg[])
Process.init_task();
//初始化进程列表
System.out.println("
\n\n==========================时间片轮转======================"
);
RR.init_task(task_info,task_num);
RR.CircleTime();
//时间片轮转
}
/*主类*/
importjava.text.SimpleDateFormat;
importjava.util.Date;
importjava.util.concurrent.ArrayBlockingQueue;
/**
*Createdby32706on2016/12/8.
*时间片轮转调度算法
*/
publicclassRR{
privatestaticSimpleDateFormattm=newSimpleDateFormat("
HH:
mm:
ss"
privatestaticinttask_num=5;
privatestaticintCircle_size=4;
//定义时间片大小
publicstaticArrayBlockingQueuetask_q=newArrayBlockingQueue(task_num);
//进程队列
privatestaticList<
double[]>
execute_time=newArrayList<
//进程执行时间
publicstaticvoidCircleTime()
try{
while(true){
double[]t=newdouble[4];
t=(double[])task_q.take();
intcurrent_task_time=(int)t[3];
inttask_NO=(int)t[0];
System.out.print(tm.format(newDate())+"
第"
+task_NO+"
号进程开始运行===="
if(current_task_time<
=Circle_size)//如果能够在本时间片中运行完成
Thread.sleep((long)current_task_time*1000);
//模拟运行所需时间
System.out.println(tm.format(newDate())+"
结束执行=====本次用时"
+current_task_time+"
S"
double[]exe_t=newdouble[2];
exe_t[0]=task_NO;
exe_t[1]=System.currentTimeMillis()-t[1];
//计算该进程所用的周转时间
execute_time.add(exe_t);
//加入到周转时间队列
else{//如果不能再本次时间片中运行完
t[3]=t[3]-Circle_size;
task_q.put(t);
Thread.sleep(Circle_size*1000);
本次时间片用完~~~~~进程等待"
if(task_q.size()==0)//如果进程队列为空了,就退出循环
break;
catch(Exceptione)
show_time();
//显示每个进程的调度时间
publicstaticvoidshow_time()//显示每个进程的调度时间
doublesum_time=0;
execute_time.size();
double[]t=execute_time.get(i);
task:
"
+t[0]+"
:
周转时间="
+(int)(t[1]/1000)+"
sum_time+=t[1];
使用时间片轮转的策略,平均周转时间为:
+(int)(sum_time/execute_time.size()/1000)+"
staticvoidinit_task(List<
in,inttn)//初始化进程列表
task_num=tn;
double[]t=in.get(i);
t[1]=System.currentTimeMillis();
//获得进程到达时间
}catch(InterruptedExceptione){
e.printStackTrace();
importjava.util.LinkedList;
publicclassStorage
{
//仓库最大存储量
privatefinalintMAX_SIZE=100;
//仓库存储的载体
privateLinkedList<
Object>
list=newLinkedList<
//生产num个产品
publicvoidproduce(intnum)
{
//同步代码段
synchronized(list)
//如果仓库剩余容量不足
while(list.size()+num>
MAX_SIZE)
【要生产的产品数量】:
+num+"
/t【库存量】:
+list.size()+"
/t暂时不能执行生产任务!
try
//由于条件不满足,生产阻塞
list.wait();
}
catch(InterruptedExceptione)
//生产条件满足情况下,生产num个产品
for(inti=1;
i<
=num;
++i)
list.add(newObject());
【已经生产产品数】:
/t【现仓储量为】:
+list.size());
list.notifyAll();
//消费num个产品
publicvoidconsume(intnum)
//如果仓库存储量不足
while(list.size()<
num)
【要消费的产品数量】:
//由于条件不满足,消费阻塞
//消费条件满足情况下,消费num个产品
list.remove();
【已经消费产品数】:
//get/set方法
publicLinkedList<
getList()
returnlist;
publicvoidsetList(LinkedList<
list)
this.list=list;
publicintgetMAX_SIZE()
returnMAX_SIZE;
}
publicclassProducerextendsThread
//每次生产的产品数量
privateintnum;
//所在放置的仓库
privateStoragestorage;
//构造函数,设置仓库
publicProducer(Storagestorage)
this.storage=storage;
//线程run函数
publicvoidrun()
produce(num);
//调用仓库Storage的生产函数
storage.produce(num);
publicintgetNum()
returnnum;
publicvoidsetNum(intnum)
this.num=num;
publicStoragegetStorage()
returnstorage;
publicvoidsetStorage(Storagestorage)
publicclassConsumerextendsThread
//每次消费的产品数量
publicConsumer(Storagestorage)
consume(num);
storage.consume(num);
publicclassTest
publicstaticvoidmain(String[]args)
//仓库对象
Storagestorage=newStorage();
//生产者对象
Producerp1=newProducer(storage);
Producerp2=newProducer(storage);
Producerp3=newProducer(storage);
Producerp4=newProducer(storage);
Producerp5=newProducer(storage);
Producerp6=newProducer(storage);
Producerp7=newProducer(storage);
//消费者对象
Consumerc1=newConsumer(storage);
Consumerc2=newConsumer(storage);
Consumerc3=newConsumer(storage);
//设置生产者产品生产数量
p1.setNum(10);
p2.setNum(10);
p3.setNum(10);
p4.setNum(10);
p5.setNum(10);
p6.setNum(10);
p7.setNum(80);
//设置消费者产品消费数量
c1.setNum(50);
c2.setNum(20);
c3.setNum(30);
//线程开始执行
c1.start();
c2.start();
c3.start();
p1.start();
p2.start();
p3.start();
p4.start();
p5.start();
p6.start();
p7.start();
四、实验结果测试、收获与体会:
1.组内分工
黄宇达:
主要负责用JAVA语言模仿“生产者—消费者问题”,进行工作安排,代码完善以及修改,完善实验报告。
沈宁:
主要基于java虚拟机的线程调度。
分析实验过程。
代码完善以及修改。
小组答辩时间:
1月6日
2.基于java虚拟机的线程调度
根据要求,设置了0~4五个进程。
实时任务调度策略,时间片轮转。
将时间片设置为4s。
当任务的时间片用完,系统将重新分配时间片,并置于就绪队列尾。
放在队列尾。
保证了所有具有相同优先级的RR任务的调度公平。
最终输出每个进程的周转时间和总平均周转时间。
设计思路主要围绕着时间片为中心,规划好进程列表,并随机生成每个进程完成所需要的时间。
进行时间轮转。
当时间片用完,将进程放置于就绪队列的尾部进行排列。
并用Thread.sleep将进程进行休眠,以达到真实的模拟效果。
在真实系统中这种调度策略是从所有处于就绪状态的线程中选择优先级最高的线程分配一定的CPU时间运行。
该时间过后再选择其他线程运行。
只有当线程运行结束、放弃(yield)CPU或由于某种原因进入阻塞状态,低优先级的线程才有机会执行。
如果有两个优先级相同的线程都在等待CPU,则调度程序以轮转的方式选择运行的线程。
3用JAVA语言模仿“生产者—消费者问题”
实验结果演示:
首先在实验开始之前,必须搞清楚概念。
生产者消费者问题,也称有限缓冲问题,是一个多线程同步问题的经典案例。
该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。
生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。
与此同时,消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。
要解决这个问题,就必须让生产者在缓冲区满时休眠(要么干脆就放弃数据),等到下次消费者消耗缓冲区中的数据的时候,生产者才能被唤醒,开始往缓冲区添加数据。
同样,也可以让消费者在缓冲区空时进入休眠,等到生产者往缓冲区添加数据之后,再唤醒消费者。
当概念清楚之后,设计思路也就很清晰了。
我们需要的是一个虚拟的缓冲区,并且要有一定量的消费者和生产者来对缓冲区添加数据和消耗数据。
并且通过Java语言中的wait()和notify()命令模拟操作系统中的唤醒和等待操作。
当生产者生产数量满足不了消费者产品消耗时,消费者将被wait().等待生产者生产足够的数量才notifyAll()将消费者唤醒。
实验感悟:
基于java虚拟机的线程调度的实验,我们这次通过利用了时间片转轮调度算法,来实现多个线程的调度,与此同时也保障了相同优先级任务的时间公平,实验过程中,也遇到了一些麻烦,为了解决这些麻烦,我们也在网上查阅了一些相关的资料,通过借鉴和改善相应的代码和意见,最后终于实现了实验指导书上的要求。
而另一个用JAVA语言模仿“生产者—消费者问题”的实验,一看到这个实验,虽然之前没有印象,但却有似明非明的感觉,然后和组员一讨论,发现上个多线程实验正好用到了相关的知识,这次正好可以巩固之前的知识再对其进行实际的应用。
而这个实验也有一点不同之处,那就是缓冲区的处理,当然这也是相当容易实现的。
总之,通过这次课程设计,我们更加清楚的理解了多线程相关方面的知识,也通过“生产者——消费者问题”,对所学到的知道进行了进一步巩固,有很大的收获。
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 操作系统 课程设计 黄宇达 329700042 沈宁 329700046
![提示](https://static.bdocx.com/images/bang_tan.gif)