Java 多队列的最短作业优先

目前，我有一个程序，模拟一组流程的最短作业优先策略。但是，我的任务是使其适用于多优先级队列。所以一个高，低，低的队列：高=1，低=2，低=3。最初的代码工作得很好，现在我一直在尝试为3个单独的进程队列实现它。我已经成功地将正确的进程添加到每个队列中，但我只能做到这一点。 问题是，如何将SJF策略应用于每个队列

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class TEST
{
    List<Process> processList;
    List<Process> highPriorityQueue;
    List<Process> mildPriorityQueue;
    List<Process> lowPriorityQueue;
    List<Process> finalProcessList;
    private int count;
    private int timeQuantum;
    int j=0;
    private int ganntP[];
    private int ganntT[];

    private int totalWaitingTime=0;
    private int totalTurnAroundTime=0;

    private float avgWatingTime=0;
    private float avgTurnaroundTime=0;
    TEST(List<Process> processList)
    {
        count=processList.size();
        this.timeQuantum=timeQuantum;
        this.processList=new ArrayList<Process>();
        this.highPriorityQueue=new ArrayList<Process>();
        this.mildPriorityQueue=new ArrayList<Process>();
        this.lowPriorityQueue=new ArrayList<Process>();
        this.finalProcessList = new ArrayList<Process>();
        ganntT=new int[200];
        ganntP=new int[200];        

        for(Process p : processList)
        {
            if(p.getPriority()==1)
                this.highPriorityQueue.add(new Process(p.getProcessId(), p.getArrivalTime(), p.getBurstTime(),p.getPriority()));
            else if(p.getPriority()==2)
                this.mildPriorityQueue.add(new Process(p.getProcessId(), p.getArrivalTime(), p.getBurstTime(),p.getPriority()));
            else if(p.getPriority()==3)
                this.lowPriorityQueue.add(new Process(p.getProcessId(), p.getArrivalTime(), p.getBurstTime(),p.getPriority()));
        }


        Collections.sort(highPriorityQueue, Process.BY_ARRIVAL_TIME);
        Collections.sort(highPriorityQueue, Process.BY_BURST_TIME);
        Collections.sort(mildPriorityQueue, Process.BY_ARRIVAL_TIME);
        Collections.sort(mildPriorityQueue, Process.BY_BURST_TIME);
        Collections.sort(lowPriorityQueue, Process.BY_ARRIVAL_TIME);
        Collections.sort(lowPriorityQueue, Process.BY_BURST_TIME);

        // CREATE NEW QUEUE WITH COMBINED PRIORITIES IN ORDER
        // SEE WHAT PROBLEM IS
        // CHECK SJF WHY NOT WORKING
        //finalProcessList.addAll(highPriorityQueue);
        //finalProcessList.addAll(mildPriorityQueue);
        //finalProcessList.addAll(lowPriorityQueue);

    }

    /*public void simulate()
    {
        int currentTime=0;
        int remainingProcess=count; 
        while (remainingProcess > 0)
        {
            int min=1000;
            int index=-1;
            Process current = null;

            for (int i = 0; i < count; i++) 
            {
                current = processList.get(i);

                if (current.getRemainingTime() > 0 && current.getBurstTime()<min &&current.getArrivalTime()<=currentTime )
                {   
                    index=i;
                    min=current.getBurstTime();
                }   
            }
            if(index==-1)
            {   currentTime++;
                continue;
            }
            current = processList.get(index);
            if (current.getStartTime()==-1) 
            {
                current.setStartTime(currentTime);
            }

            ganntP[j]=current.getProcessId();
            ganntT[j]=currentTime;
            j++;

            current.setRemainingTime(0);
            current.setEndTime(currentTime +current.getBurstTime());
            currentTime+=current.getBurstTime();
            remainingProcess--;


        }
        for(int i=0;i<count;i++)
        {   
            Process current=processList.get(i);
            current.setWaitingTime(current.getEndTime()-current.getBurstTime()-current.getArrivalTime());
            current.setTurnaroundTime(current.getEndTime()  - current.getArrivalTime());

            totalWaitingTime+=current.getWaitingTime();
            totalTurnAroundTime+=current.getTurnaroundTime();
        }
        avgWatingTime=(float)totalWaitingTime/count;
        avgTurnaroundTime=(float)totalTurnAroundTime/count;

    }*/

    public void printResult()
    {
        Collections.sort(this.processList, Process.BY_PROCESSID);
        System.out.println("Simulation result of TEST ");
        System.out.println("ProcessID | ArrivalTime | BurstTime | Priority | StartTime | EndTime| WaitingTime | TurnAroundTime");
        System.out.println("PId ArrivalT BurstT Priority  StartT   EndT  WaitingT TurnAroundT");
        for(Process p : processList)
        {
            System.out.println(p);  

        }
        System.out.println("Average Waiting Time of Multilevel "+avgWatingTime);
        System.out.println("Average TurnAround Time of Multilevel "+avgTurnaroundTime);

        System.out.println("HIGH PRIORITY");
        System.out.println("PId ArrivalT BurstT Priority  StartT   EndT  WaitingT TurnAroundT");
        for(Process p : highPriorityQueue)
        {
            System.out.println(p);
        }
        System.out.println("MILD PRIORITY");
        System.out.println("PId ArrivalT BurstT Priority  StartT   EndT  WaitingT TurnAroundT");
        for(Process p : mildPriorityQueue)
        {
            System.out.println(p);
        }
        System.out.println("LOW PRIORITY");
        System.out.println("PId ArrivalT BurstT Priority  StartT   EndT  WaitingT TurnAroundT");
        for(Process p : lowPriorityQueue)
        {
            System.out.println(p);
        }
        for(int i=0;i<j;i++)
        {
            System.out.println("Time "+ganntT[i]+" Process "+ganntP[i]);    

        }
        System.out.println();
        System.out.println("LIST COMBINE TEST");
        System.out.println("PId ArrivalT BurstT Priority  StartT   EndT  WaitingT TurnAroundT");
        for(Process p : finalProcessList)
        {
            System.out.println(p);
        }
    }
}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
公开课考试
{
列表进程列表；
列出高优先级队列；
列出mildPriorityQueue；
列出低优先级队列；
列出最终进程列表；
私人整数计数；
私有时间量子；
int j=0；
私有int ganntP[]；
私人国际机场[]；
私有整数totalWaitingTime=0；
私有时间=0；
私有浮动avgWatingTime=0；
私有浮动平均周转时间=0；
测试（列表进程列表）
{
count=processList.size（）；
this.timeQuantum=timeQuantum；
this.processList=newArrayList（）；
this.highPriorityQueue=new ArrayList（）；
this.mildPriorityQueue=new ArrayList（）；
this.lowPriorityQueue=newArrayList（）；
this.finalProcessList=新的ArrayList（）；
ganntT=新整数[200]；
ganntP=新整数[200]；
for（进程p:processList）
{
如果（p.getPriority（）==1）
add（新进程（p.getProcessId（），p.getArrivalTime（），p.getBurstTime（），p.getPriority（））；
else if（p.getPriority（）==2）
add（新进程（p.getProcessId（），p.getArrivalTime（），p.getBurstTime（），p.getPriority（））；
else if（p.getPriority（）==3）
add（新进程（p.getProcessId（），p.getArrivalTime（），p.getBurstTime（），p.getPriority（））；
}
收集.排序（highPriorityQueue，Process.BY_ARRIVAL_TIME）；
Collections.sort（highPriorityQueue，Process.BY_BURST_TIME）；
收集.排序（mildPriorityQueue，Process.BY\u ARRIVAL\u TIME）；
Collections.sort（mildPriorityQueue、Process.BY\u BURST\u TIME）；
Collections.sort（lowPriorityQueue，Process.BY\u ARRIVAL\u TIME）；
Collections.sort（lowPriorityQueue，Process.BY\u BURST\u TIME）；
//按顺序创建具有组合优先级的新队列
//看看有什么问题
//检查SJF为什么不工作
//finalProcessList.addAll（highPriorityQueue）；
//finalProcessList.addAll（mildPriorityQueue）；
//addAll（lowPriorityQueue）；
}
/*公共空间模拟（）
{
int currentTime=0；
整数剩余过程=计数；
同时（剩余进程>0）
{
int最小值=1000；
int指数=-1；
过程电流=零；
for（int i=0；i如果（current.getRemainingTime（）>0&¤t.getBurstTime（）可能会查看java中的
PriorityQueue
，如果您使用比较器添加/删除一个值，那么它会对自身进行排序
我建议您使用
java.util.PriorityQueue
并为
进程定义一个
比较器
（或者让它实现
Comparable
）。然后您只需将所有进程添加到其中，队列就会对它们进行排序。
您可能需要解释您已经完成了哪些工作，以及您希望“准确地”完成哪些工作还有什么不起作用。看看如何创建一个。顺便说一下，我不会使用更多的列表，只是使用一个排序列表和一个比较器，使用优先级作为一个因子来将进程放在正确的位置。@AxelH在简介中说了一个“多优先级队列”，现在网上没有太多关于这个的信息，所以我最好的猜测是每个优先级都有一个队列。我lso有一个版本，只根据优先级排序，但只针对整个流程列表。因此，您有一个要求，但没有确切的描述。因此，它可以是一个简单的FIFO，但有3个不同的队列，首先需要清空高，然后清空中，然后清空低。几乎所有的状态都是这样“使用多优先级队列策略来调度进程，并使用最短作业优先策略来调度每个队列中的进程。"是的，我本来打算研究它，但担心它可能会影响整个代码等，目前它工作正常，当它只有一个完整的进程列表，但现在我已经把它分成了3个列表，你可以使用一个
PriorityQueue
一次用于所有进程，有一个线程安全版本，只需编写一个比较器来正确排序任务如果一个线程正在构思轮询第一个项目，或者如果队列为空，让它等待在摘要中，它指出我应该使用多优先级队列-假设每个优先级有3个队列，我的目标是处理所有高优先级，那么如果高优先级为空，则队列的比较器可以处理多个优先级。