2016数媒操作系统课程设计-黄宇达2014329700042、沈宁2014329700046

浙江理工大学《操作系统课程设计》

课程设计报告

2016～2017学年第1学期

学院信息学院

班级14数字媒体技术2班

姓名黄宇达、沈宁

2014329700042

学号

2014329700046

任课教师桂宁

数字媒体技术专业

2017年1月

·用JAVA语言模仿“生产者—消费者问题”

1.通过Java语言中的wait（）和notify（）命令模拟操作系统中的P/V操作；

2.为每个生产者／消费者产生一个线程，设计正确的同步算法

3.每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的当前全部内容、

当前指针位置和生产者／消费者线程的自定义标识符。

4.生产者和消费者各有两个以上。

多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。

三、源代码

1.基于java虚拟机的线程调度

/*起始化类*/

import java.util.ArrayList;

import java.util.List;

public class Process {

public static List task_info=new ArrayList<>();//进程列表

public static int task_num=5;//进程数

public static void init_task()//初始化进程列表

{

for(int i=0;i

{

double[] t=new double[4];

t[0]=i;//进程号

t[1]=0;//到达时间

t[2]=0;//响应比

t[3]=(int)(Math.random()*100)%20+1;//需要运行时间

task_info.add(t);

}

}

public static void main(String arg[])

{

Process.init_task();//初始化进程列表

System.out.println("\n\n==========================时间片轮转======================");

RR.init_task(task_info,task_num);

RR.CircleTime();//时间片轮转

}

}

/*主类*/

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.concurrent.ArrayBlockingQueue;

/**

* Created by 32706 on 2016/12/8.

* 时间片轮转调度算法

*/

public class RR {

private static SimpleDateFormat tm= new SimpleDateFormat("HH:mm:ss");

private static int task_num=5;

private static int Circle_size=4;//定义时间片大小

public static ArrayBlockingQueue task_q=new ArrayBlockingQueue(task_num);//进程队列

private static List execute_time=new ArrayList<>();//进程执行时间

public static void CircleTime()

{

try {

while (true) {

double[] t = new double[4];

t = (double[])task_q.take();

int current_task_time=(int)t[3];

int task_NO=(int)t[0];

System.out.print(tm.format(new Date())+"第" +task_NO+"号进程开始运行====");

if(current_task_time<=Circle_size)//如果能够在本时间片中运行完成

{

Thread.sleep((long) current_task_time*1000);//模拟运行所需时间

System.out.println(tm.format(new Date())+"结束执行=====本次用时"+current_task_time+"S");

double[] exe_t=new double[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);

System.out.println(tm.format(new Date())+"本次时间片用完~~~~~进

程等待");

}

if(task_q.size()==0)//如果进程队列为空了，就退出循环

break;

}

}

catch (Exception e)

{

}

show_time();//显示每个进程的调度时间

}

public static void show_time()//显示每个进程的调度时间

{

double sum_time=0;

for(int i=0;i

{

double[] t=execute_time.get(i);

System.out.println("task:"+t[0]+":周转时间="+(int)(t[1]/1000)+"S");

sum_time+=t[1];

}

System.out.println("使用时间片轮转的策略，平均周转时间为："+(int)(sum_time/execute_time.size()/1000)+"S");

}

static void init_task(List in,int tn)//初始化进程列表

{

task_num=tn;

for(int i=0;i

{

double [] t=in.get(i);

t[1] = System.currentTimeMillis();//获得进程到达时间

try {

task_q.put(t);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

·用JAVA语言模仿“生产者—消费者问题”

import java.util.LinkedList;

public class Storage

{

// 仓库最大存储量

private final int MAX_SIZE = 100;

// 仓库存储的载体

private LinkedList