Question

实际上我是java线程领域的新手。我想实现实时系统的最早截止时间优先调度算法。我已经为以下任务生成了代码： 1.每1秒后生成一次任务。 // Main.java

import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Random;

public class Main 
{
     public static void main(String args[])throws Exception
     {    
          Node node;
          Random rand = new Random();
          int Threshold = 10;
          long Period,Deadline,Duration;

          System.out.println("Task Generation Starts....\n");
          System.out.println(Thread.currentThread().getName()+ "  START\n");
          for(int i =1;i<=Threshold;i++)
          {  
              Calendar c = new GregorianCalendar();
              long m = c.get(GregorianCalendar.SECOND);
              Duration = rand.nextInt(4)+1;
              Period =   rand.nextInt(10)+1;
              Deadline = Period + m;
              node = new Node("Task"+i, m, Duration, Period, Deadline);
              new Tasks("Task"+i,node);
              Thread.sleep(1000);
          } 
          System.out.println(Thread.currentThread().getName()+ "  STOP\n");
    }
}

此任务传递给一个实现Runnable的任务类。

// Tasks.java

    import java.util.logging.Level;
import java.util.logging.Logger;
import java.lang.Thread;

    class Tasks implements Runnable
    { 
      Thread T;
      String taskname;

      Node task;
      TaskPriority taskpriority = new TaskPriority();


      public Tasks(String S,Node newtask)
       {
          this.taskname=S;
          this.task = newtask;
          T = Thread.currentThread();
          T.setName(taskname);
          T = new Thread(this, T.getName());
          System.out.println(T.getName()+ "Starts Running");
          T.start();
       }

      public void run()
      { 
        try
        {
           taskpriority.insert(task);
           taskpriority.pop();

        }
        catch(InterruptedException ie)
        {
            Logger.getLogger(Tasks.class.getName()).log(Level.SEVERE,"error is"+ie.getMessage(),ie);
        }
    } 
}

来自Tasks.java，在调用最早截止时间函数类的pop（）函数之后立即调用了taskpriority.java的insert函数。
我想要的是

最大优先级的第一个线程到达执行。鉴于Thread有以下细节：任务到达时间WCET期间（周期）截止日期任务1 38 4Sec。 6 44秒。

任务执行从38秒开始。最差情况执行时间（WCET）为4秒。 Task1从38秒开始，运行1秒并计算其剩余（4-1 = 3秒）。在此1秒运行调度程序之后检查是否有其他任务到达。如果第二个任务到达39秒。任务到达时间WCET期间（周期）截止日期任务2 39 4Sec。 5 44秒。

现在EDF将检查剩余时间以完成两个任务的截止时间：任务1（在任务1实际到达时间为38但在执行1秒后变为39）（44-39 = 5秒）和任务2（44- 39 = 5秒。）旧任务将继续，并在另一秒后再次，即40秒。 EDF调度程序将在1秒后再次检查。和Task3已经到了。任务到达时间WCET期间（周期）截止日期 Task3 40 2Sec。 5 45秒

现在再次检查剩下的时间以实现所有任务的截止时间Task1正在运行并从4完成其2个单位时间因此Task1（44-40 = 2Sec。），Task2（44-39 = 5sec）和Task3（ 45-40 = 5秒。）。根据所有三个任务的剩余时间，Scheduler为Task1分配最大优先级，它优先于Task4和Task2。通过这种方式，这个给定的算法将适用于即将到来的任务（此处阈值为10）。

此处我无法在每1秒后更改/为线程分配优先级。我怎么才能知道哪个线程即将到来。

// EDF代码

    public void EarliestDF() throws InterruptedException, SecurityException
    {        
        Calendar calendar = new GregorianCalendar();
         long a = calendar.get(GregorianCalendar.SECOND);
         System.out.println("Task\t\tArrivalTime\tWCET\t\tPeriod(Cycle)\t  Deadline");
         System.out.println( Thread.currentThread().getName()+"\t\t"+a+"\t\t"+task.duration+"Sec.\t\t"+task.period +"\t\t"+task.deadline+" Sec.");
         System.out.println("\n");

         Execution(task);


         Calendar calendar2 = new GregorianCalendar();
         long start = calendar2.get(GregorianCalendar.SECOND);

         long newP = task.period-task.duration;

         System.out.println(Thread.currentThread().getName() +" is waiting for next phase from :\t"+start + " Sec.");

         Thread.sleep(newP * 1000);

         Calendar calendar3 = new GregorianCalendar();
         long stop = calendar3.get(GregorianCalendar.SECOND);
         System.out.println(task.taskname +" execution arrive again at:\t"+stop + "Sec.");
         System.out.println("\n");

         System.out.println(Thread.currentThread().getName()+"is in Process again\t");
         newQ();
        }

   public void Execution(Node task) throws InterruptedException
   {

       if(task.Arrival+task.duration<=task.deadline)
     {
         System.out.print("Execution of"+Thread.currentThread().getName()+"has started at ");
         Calendar calendar2 = new GregorianCalendar();
         long start = calendar2.get(GregorianCalendar.SECOND);
         System.out.print(start+" Sec.\n");  

         while (time<=task.duration)
         {      
                Thread.sleep(1000);
                System.out.println(time+" Sec...");
                task.duration=task.duration-time;
                System.out.println("Time Left"+ task.duration);
                task.Arrival = start + time;
                System.out.println("Task   "  + Thread.currentThread().getName());
                System.out.println("\n");
                time++;
         }

                Calendar calendar1 = new GregorianCalendar();
                long stop = calendar1.get(GregorianCalendar.SECOND);
                System.out.println("Total Completion Time of"+Thread.currentThread().getName() + "is:\t"+stop+" Sec.");
         }
   }

从这段代码中我没有逐一得到结果....如果任何线程具有最大优先级，它应该抢占最小优先级线程。我无法将优先级分配给线程。这是我的主要问题。

无法分配线程优先级

0 个答案: