最短剩余时间优先:Java多线程
我试图用java模拟CPU调度算法,并使用多线程。我成功地实现了FCFS(先到先得)和SJF(最短工作优先)。但问题是当我开始考虑SRTF(最短剩余时间优先)时,它是一种先发制人的SJF形式。 我使用的是以下模型:
- CPU的一个线程,它有一个
CLOCK
变量,该变量每100ms
一次都在滴答作响(一个简单的时钟增量)。我有一个boolean isAvailable;
标志,让进程在开始执行之前检查CPU是否可用李> - 用于长期调度程序(LTS)的线程,它将进程从进程列表推送到就绪队列李>
- 短期调度程序(STS)的线程,它从ReadyQueue中获取一个进程并将其分配给CPU李>
- 一旦进程被STS从ReadyQueue中移除以执行,该进程将检查CPU的
isAvailable
标志。如果true
,它会将标志设置为false并开始执行(我只是让线程睡眠(100 * burstTime) ms
,因为这只是一个模拟)。否则,进程就会一直忙着等待:while(CPU.isAvailable != true);
李>
我手头有进程列表,以及它们的到达时间和突发时间。 在我模拟非抢占式调度(FCFS和SJF)之前,一切都没问题。但是当我尝试SRTF时,我无法找到一种方法来抢占当前正在运行的进程线程
对于SRTF,我知道如何从ReadyQueue中选择下一个流程。一旦我从队列中选择了一个进程,我可以尝试将isAvailable
标志设置为false
,但那我怎么知道最初执行的是哪个线程呢?由于我没有使用太多的同步b/w线程,我将有多个进程使用CPU
线程。有点乱了。请帮忙。谢谢
以下是流程的代码:
enum State {ARRIVED, WAITING, READY, RUNNING, EXECUTED}
public class Process implements Runnable
{
int pid;
int arrTime;
int burstTime;
int priority;
long startTime;
long endTime;
State procState = null;
Process(int pid, int arrTime, int burstTime, int priority)
{
this.pid = pid;
this.arrTime = arrTime;
this.burstTime = burstTime;
this.priority = priority;
this.procState = State.ARRIVED;
this.startTime = 0;
this.endTime = 0; /* I also considered adding a timeElapsedUnderExecution
attribute to the process. So I can check after every cycle if the CPU is still available
and keep incrementing the time elapsed. Once the timeElapsed becomes same as burstTime, i
stop the process. Or if after a cycle, the CPU is not available, i know from where to
resume my Process. Is this the way to go ? */
}
boolean isReady()
{
if((this.arrTime <= CPU.CLOCK) && (this.procState == State.ARRIVED))
return true;
else return false;
}
@Override
public void run() {
// TODO Auto-generated method stub
if(this.procState == State.READY)
this.procState = State.WAITING;
while(!CPU.isAvailable());
try
{
this.procState = State.RUNNING;
System.out.println("Process " + pid + " executing...");
this.startTime = CPU.CLOCK;
System.out.println("Process " + this.pid + ": Begins at " + this.startTime);
Thread.sleep(this.burstTime * 100);
this.endTime = CPU.CLOCK;
System.out.println("Process " + this.pid + ": Ends at " + this.endTime);
this.procState = State.EXECUTED;
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
System.out.println("Interrupted: " + pid);
e.printStackTrace();
}
}
}
CPU的代码:
import java.util.LinkedList;
import java.util.Queue;
public class CPU implements Runnable
{
static Long CLOCK = new Long(0);
static LinkedList<Process> ReadyQ = new LinkedList<Process>();
private static boolean isAvailable = true;
static boolean done = false;
public static boolean isAvailable() {
return isAvailable;
}
public static void setAvailable(boolean isAvailable) {
CPU.isAvailable = isAvailable;
}
static void incrementCLOCK()
{
LTS.checkArrival();
CPU.CLOCK++;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Clock Tick: " + CPU.CLOCK);
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("CPU starts.!!!");
while(CPU.done != true)
synchronized(CPU.CLOCK)
{
incrementCLOCK();
}
}
}
LTS的代码:
public class LTS implements Runnable
{
private static Process[] pList = null;
private final int NUM;
static Integer procStarted;
static Integer procFinished;
static boolean STSDone = false;
LTS(Process[] pList, int num)
{
this.NUM = num;
LTS.pList = pList;
}
static void checkArrival()
{
if(pList == null) return;
for(int i = 0; i < pList.length; i++)
if(pList[i].isReady())
{
pList[i].procState = State.READY;
System.out.println("Process " + pList[i].pid + " is now ready.");
CPU.ReadyQ.add(pList[i]);
}
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Long Term Scheduler starts.!!!");
while(LTS.STSDone != true)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(LTS.STSDone);
System.out.println("LTS ends.!!!");
CPU.done = true;
}
}
共 (0) 个答案