java实现多个进程调度算法，有界面

实现多个进程调度算法需要考虑到进程调度的核心算法和界面的交互设计。以下是一个简单的实现示例：

1. 进程调度算法

可以选择实现以下常见的进程调度算法：

- 先来先服务（FCFS）
- 短作业优先（SJF）
- 优先级调度（Priority Scheduling）
- 时间片轮转（Round Robin）

2. 界面设计

可以使用Java Swing库来创建用户界面。在主界面上，需要提供以下功能：

- 显示当前正在运行的进程
- 显示已经完成的进程
- 提供添加新进程的功能，包括进程名、到达时间、需要执行的时间等信息
- 提供选择不同的调度算法的功能，并根据算法进行进程调度
- 显示各个进程的执行情况，包括开始时间、结束时间、等待时间、周转时间等信息

3. 实现示例

以下是一个简单的实现示例，仅供参考：

import java.awt.BorderLayout;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.SwingConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.table.DefaultTableModel;

public class ProcessScheduler extends JFrame {

    private JPanel contentPane;
    private JTextField txtName;
    private JTextField txtArrivalTime;
    private JTextField txtBurstTime;
    private JTable table;
    private DefaultTableModel model;
    private List<Process> processList = new ArrayList<>();

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    ProcessScheduler frame = new ProcessScheduler();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public ProcessScheduler() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 600, 400);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(null);

        JLabel lblName = new JLabel("Name:");
        lblName.setBounds(20, 20, 80, 25);
        contentPane.add(lblName);

        txtName = new JTextField();
        txtName.setBounds(100, 20, 100, 25);
        contentPane.add(txtName);
        txtName.setColumns(10);

        JLabel lblArrivalTime = new JLabel("Arrival Time:");
        lblArrivalTime.setBounds(20, 50, 80, 25);
        contentPane.add(lblArrivalTime);

        txtArrivalTime = new JTextField();
        txtArrivalTime.setBounds(100, 50, 100, 25);
        contentPane.add(txtArrivalTime);
        txtArrivalTime.setColumns(10);

        JLabel lblBurstTime = new JLabel("Burst Time:");
        lblBurstTime.setBounds(20, 80, 80, 25);
        contentPane.add(lblBurstTime);

        txtBurstTime = new JTextField();
        txtBurstTime.setBounds(100, 80, 100, 25);
        contentPane.add(txtBurstTime);
        txtBurstTime.setColumns(10);

        JButton btnAdd = new JButton("Add");
        btnAdd.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String name = txtName.getText();
                int arrivalTime = Integer.parseInt(txtArrivalTime.getText());
                int burstTime = Integer.parseInt(txtBurstTime.getText());
                processList.add(new Process(name, arrivalTime, burstTime));
                showProcessList();
                clearInputFields();
            }
        });
        btnAdd.setBounds(20, 120, 80, 25);
        contentPane.add(btnAdd);

        model = new DefaultTableModel();
        model.addColumn("Name");
        model.addColumn("Arrival Time");
        model.addColumn("Burst Time");
        model.addColumn("Start Time");
        model.addColumn("End Time");
        model.addColumn("Waiting Time");
        model.addColumn("Turnaround Time");

        table = new JTable(model);
        table.setBounds(220, 20, 350, 300);
        contentPane.add(table);

        JButton btnFcfs = new JButton("FCFS");
        btnFcfs.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                List<Process> resultList = fcfs(processList);
                showResultList(resultList);
            }
        });
        btnFcfs.setBounds(20, 160, 80, 25);
        contentPane.add(btnFcfs);

        JButton btnSjf = new JButton("SJF");
        btnSjf.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                List<Process> resultList = sjf(processList);
                showResultList(resultList);
            }
        });
        btnSjf.setBounds(20, 200, 80, 25);
        contentPane.add(btnSjf);

        JButton btnPriority = new JButton("Priority");
        btnPriority.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                List<Process> resultList = priority(processList);
                showResultList(resultList);
            }
        });
        btnPriority.setBounds(20, 240, 80, 25);
        contentPane.add(btnPriority);

        JButton btnRoundRobin = new JButton("Round Robin");
        btnRoundRobin.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int timeSlice = Integer.parseInt(txtTimeSlice.getText());
                List<Process> resultList = roundRobin(processList, timeSlice);
                showResultList(resultList);
            }
        });
        btnRoundRobin.setBounds(20, 280, 120, 25);
        contentPane.add(btnRoundRobin);

        JLabel lblTimeSlice = new JLabel("Time Slice:");
        lblTimeSlice.setBounds(150, 280, 80, 25);
        contentPane.add(lblTimeSlice);

        txtTimeSlice = new JTextField();
        txtTimeSlice.setBounds(220, 280, 50, 25);
        contentPane.add(txtTimeSlice);
        txtTimeSlice.setColumns(10);
    }

    private void clearInputFields() {
        txtName.setText("");
        txtArrivalTime.setText("");
        txtBurstTime.setText("");
    }

    private void showProcessList() {
        model.setRowCount(0);
        for (Process process : processList) {
            Object[] rowData = new Object[3];
            rowData[0] = process.getName();
            rowData[1] = process.getArrivalTime();
            rowData[2] = process.getBurstTime();
            model.addRow(rowData);
        }
    }

    private void showResultList(List<Process> resultList) {
        model.setRowCount(0);
        for (Process process : resultList) {
            Object[] rowData = new Object[7];
            rowData[0] = process.getName();
            rowData[1] = process.getArrivalTime();
            rowData[2] = process.getBurstTime();
            rowData[3] = process.getStartTime();
            rowData[4] = process.getEndTime();
            rowData[5] = process.getWaitingTime();
            rowData[6] = process.getTurnaroundTime();
            model.addRow(rowData);
        }
    }

    private List<Process> fcfs(List<Process> processList) {
        List<Process> resultList = new ArrayList<>();
        int currentTime = 0;
        for (Process process : processList) {
            process.setStartTime(currentTime);
            process.setEndTime(currentTime + process.getBurstTime());
            process.setWaitingTime(currentTime - process.getArrivalTime());
            process.setTurnaroundTime(process.getEndTime() - process.getArrivalTime());
            currentTime = process.getEndTime();
            resultList.add(process);
        }
        return resultList;
    }

    private List<Process> sjf(List<Process> processList) {
        List<Process> resultList = new ArrayList<>();
        int currentTime = 0;
        while (!processList.isEmpty()) {
            Process shortestProcess = null;
            for (Process process : processList) {
                if (shortestProcess == null || process.getBurstTime() < shortestProcess.getBurstTime()) {
                    shortestProcess = process;
                }
            }
            processList.remove(shortestProcess);
            shortestProcess.setStartTime(currentTime);
            shortestProcess.setEndTime(currentTime + shortestProcess.getBurstTime());
            shortestProcess.setWaitingTime(currentTime - shortestProcess.getArrivalTime());
            shortestProcess.setTurnaroundTime(shortestProcess.getEndTime() - shortestProcess.getArrivalTime());
            currentTime = shortestProcess.getEndTime();
            resultList.add(shortestProcess);
        }
        return resultList;
    }

    private List<Process> priority(List<Process> processList) {
        List<Process> resultList = new ArrayList<>();
        int currentTime = 0;
        while (!processList.isEmpty()) {
            Process highestPriorityProcess = null;
            for (Process process : processList) {
                if (highestPriorityProcess == null || process.getPriority() < highestPriorityProcess.getPriority()) {
                    highestPriorityProcess = process;
                }
            }
            processList.remove(highestPriorityProcess);
            highestPriorityProcess.setStartTime(currentTime);
            highestPriorityProcess.setEndTime(currentTime + highestPriorityProcess.getBurstTime());
            highestPriorityProcess.setWaitingTime(currentTime - highestPriorityProcess.getArrivalTime());
            highestPriorityProcess.setTurnaroundTime(highestPriorityProcess.getEndTime() - highestPriorityProcess.getArrivalTime());
            currentTime = highestPriorityProcess.getEndTime();
            resultList.add(highestPriorityProcess);
        }
        return resultList;
    }

    private List<Process> roundRobin(List<Process> processList, int timeSlice) {
        List<Process> resultList = new ArrayList<>();
        int currentTime = 0;
        int remainingTimeSlice = 0;
        while (!processList.isEmpty()) {
            Process currentProcess = processList.get(0);
            if (currentProcess.getBurstTime() <= timeSlice - remainingTimeSlice) {
                processList.remove(0);
                currentProcess.setStartTime(currentTime);
                currentProcess.setEndTime(currentTime + currentProcess.getBurstTime());
                currentProcess.setWaitingTime(currentTime - currentProcess.getArrivalTime());
                currentProcess.setTurnaroundTime(currentProcess.getEndTime() - currentProcess.getArrivalTime());
                currentTime = currentProcess.getEndTime();
                resultList.add(currentProcess);
                remainingTimeSlice = 0;
            } else {
                currentProcess.setBurstTime(currentProcess.getBurstTime() - timeSlice + remainingTimeSlice);
                processList.remove(0);
                processList.add(currentProcess);
                remainingTimeSlice = timeSlice;
            }
        }
        return resultList;
    }

    private JTextField txtTimeSlice;
}

class Process {

    private String name;
    private int arrivalTime;
    private int burstTime;
    private int priority;
    private int startTime;
    private int endTime;
    private int waitingTime;
    private int turnaroundTime;

    public Process(String name, int arrivalTime, int burstTime) {
        this.name = name;
        this.arrivalTime = arrivalTime;
        this.burstTime = burstTime;
    }

    public String getName() {
        return name;
    }

    public int getArrivalTime() {
        return arrivalTime;
    }

    public int getBurstTime() {
        return burstTime;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public int getStartTime() {
        return startTime;
    }

    public void setStartTime(int startTime) {
        this.startTime = startTime;
    }

    public int getEndTime() {
        return endTime;
    }

    public void setEndTime(int endTime) {
        this.endTime = endTime;
    }

    public int getWaitingTime() {
        return waitingTime;
    }

    public void setWaitingTime(int waitingTime) {
        this.waitingTime = waitingTime;
    }

    public int getTurnaroundTime() {
        return turnaroundTime;
    }

    public void setTurnaroundTime(int turnaroundTime) {
        this.turnaroundTime = turnaroundTime;
    }

}