Add code for the Job itself

This commit is contained in:
Bradlee Speice 2012-09-28 18:07:28 -04:00
parent 470e720197
commit a1be9111fa
2 changed files with 117 additions and 22 deletions

View File

@ -1,22 +1,37 @@
/*Job Class /*
* Contains Int Size and Int Time * Author: Bradlee Speice
* Job Class
*
* The purpose of this class is to simulate a running "Job" in memory. To create a new Job, call the
* "start" method, and inform the job of how long it should run, and give it an identifier.
* The job will use this to report back that it is done. If you need to pause the job, you
* can do so. Finally, the job will report back to whoever called it that it needs to be destroyed.
* If there are any questions, email bspeice@uncc.edu
*/ */
public class Job { public class Job {
private int size,time; private jobThread myThread; //Reference to the thread we control
private boolean myThreadPaused; //Used to keep track of the execution state of our thread
//private BaseAlgorithm parentAlgorithm; //Used for knowing who to tell that we're done.
public Job(int s, int t){ public Job(int jobTime, int jobID/*, BaseAlgorithm parentAlgorithm */){
size = s; //Create a new job, and start it running
time = t; myThread = new jobThread(jobTime, jobID /*, parentAlgorithm*/);
myThread.start();
} }
public void setSize(int s){size = s;} public void pause(){
public void setTime(int t){time = t;} if (!myThreadPaused){
myThread.pause();
public int getSize(){return size;} myThreadPaused = true;
public int getTime(){return time;} }
public String toString(){
return "("+size+","+time+")";
} }
public void resume(){
if (myThreadPaused){
myThread.jobResume();
myThreadPaused = false;
}
}
} }

80
jobThread.java Normal file
View File

@ -0,0 +1,80 @@
public class jobThread extends Thread {
private final int sleepResolution = 200; //Milliseconds
private long jobTime; //Milliseconds
private long elapsedTime;
private boolean isPaused, pauseStateChanged;
private long startTime;
private int jobID;
private boolean jobDone;
/* private BaseAlgorithm parentAlgorithm *///Our parent to notify when we're done.
public jobThread(long jobTime, int jobID /*, BaseAlgorithm parentAlgorithm*/){
this.jobTime = jobTime;
elapsedTime = 0;
isPaused = false;
startTime = 0;
this.jobID = jobID;
//this.parentAlgorithm = parentAlgorithm;
}
public void pause(){
synchronized(this){
isPaused = true;
pauseStateChanged = true;
}
}
public void jobResume(){
synchronized(this){
isPaused = false;
pauseStateChanged = true;
}
}
public void run(){
//The event loop.
//Basically, check that elapsedTime plus current time delta
//are not greater than the time we're supposed to run.
//If paused, don't do anything until we resume
try{
while (!jobDone){
//Begin event logic
sleep(sleepResolution);
synchronized(this){
if (pauseStateChanged){
if (isPaused){
//We have just been paused, save the time that we've currently
//been running, and then go back to the event loop
elapsedTime += System.currentTimeMillis() - startTime;
continue;
} else {
//We have just been resumed, restart the timer
startTime = System.currentTimeMillis();
continue;
}
} else {
if (isPaused){
//Nothing much happening, we're still paused.
continue;
} else {
//Not paused, Check if we need to keep running
long currentDelta = System.currentTimeMillis() - startTime;
if (currentDelta + elapsedTime >= jobTime){
jobDone = true;
}
}
}
}
}
//We're done, go ahead and notify our algorithm to clean us up
/* parentAlgorithm.deallocate(jobID); */
} catch (Exception e) {
return;
}
}
}