En Kısa Kalan Süre Önce: Java Multithreading

Question

Java programlama algoritmalarını simüle etmeye çalışıyorum ve multithreading kullanıyorum. FCFS'yi (First Come First Service) ve SJF'yi (En Kısa Önce İş) başarıyla uygulayabildim. Ama problem, SRF'nin (En Kısa Kalan Süre Önce) düşünüldüğü ve bu da SJF'nin önleyici bir şekli olarak düşünmeye başladığım zamandır. CPU için

• bir iş parçacığı, geçiyor tutar bir CLOCK değişkeni, (basit bir saat artım) her 100ms sahiptir: Aşağıdaki modelini kullanıyorum. İşlemi gerçekleştirmeye başlamadan önce CPU'nun kullanılabilir olup olmadığını kontrol etmek için işlemler için bir boolean isAvailable; bayrağım var.
• Süreci, işlem listesinden Hazır Sırasına geçiren Uzun Dönemli Zamanlayıcı (LTS) için bir iş parçacığı.
• Kısa Dönem Zamanlayıcı (STS) için bir iş parçacığı hazırlanır, bu işlem ReadyQueue'dan bir işlem alır ve bunu CPU'ya atar.
• Bir işlem, yürütme için STS tarafından ReadyQueue'dan kaldırıldıktan sonra işlem, CPU'nun isAvailable bayrağını denetler. true ise, bayrağı false olarak ayarlar ve çalışmasını başlatır (bunun için sadece iş parçacığı yalnızca bir simülasyon olduğu için (100 * burstTime) ms için uyumaya çalışıyorum). Aksi halde, işlem beklemeyi şu anda beklemektedir: while(CPU.isAvailable != true);.

Elde ettikleri ve çıkma zamanları ile birlikte işlemlerin listesini elimden alırım. Önleyici olmayan zamanlamayı (FCFS ve SJF) simüle etmediğimde tamamdır. Ancak, SRTF'yi denediğim için, şu anda çalışan işlem iş parçacığını önleme yöntemini bulamıyorum.

SRTF için, bir sonraki işlemi ReadyQueue'dan seçme yolunu biliyorum. Kuyruktan bir işlem seçtiğimde isAvailable bayrağını false'a ayarlamayı deneyebilirim, ancak sonra hangi iş parçacığının orijinal olarak çalıştığını nasıl bilebilirim? Ve senkronizasyon b/w iş parçacığı pek kullanmıyorum, ben CPU iş parçacığı kullanarak birden çok işlem olacaktır. Biraz dağınık. Lütfen yardım et. Teşekkürler! CPU için

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(); 
    } 
    } 
} 

kod: LTS için

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(); 
      } 
    } 
} 

kodu:

Bu

bir Süreci kodudur

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; 
    } 
} 

Answer 1

Sorun 1 numaralı senin paylaştı olmasıdır Durum iplik güvenli değildir. Boole gibi basit şeylerin bile dişlerde (aka “uçucu”) görünmesini sağlamak için doğru diş iplerine ihtiyaç vardır.