0

其实我是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");
    }
}
  1. 此任务传递给一个实现 Runnable 的任务类。

// 任务.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);
        }
    } 
}
  1. 从 Tasks.java 中，taskpriority.java 的插入函数已被调用，并且紧接在调用 Earliest Deadline 函数类的 pop() 函数之后。
  2. 我想要的是

最高优先级的第一个线程到达执行。给定线程具有以下详细信息：Task ArrivalTime WCET Period(Cycle) Deadline Task1 38 4Sec。6 44 秒。

任务执行从 38 秒开始。最坏情况执行时间 (WCET) 为 4 秒。Task1 从 38 秒开始，运行 1 秒并计算其剩余时间（4-1=3 秒）。在这 1 秒运行调度程序后，检查是否有其他任务到达。如果第二个任务在 39 秒到达。Task ArrivalTime WCET Period(Cycle) Deadline Task2 39 4Sec. 5 44 秒。

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

现在再次检查剩余时间以达到所有任务 Task1 正在运行的截止日期，并从 4 完成其 2 单位时间，因此 Task1(44-40 = 2Sec.)、Task2(44-39=5sec) 和 Task3 (45-40 =5 秒）。根据所有三个任务的剩余时间，调度程序将最大优先级分配给 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.");
         }
   }

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

4

0 回答 0