时间片轮转算法javaGUI实现代码，有创建进程按钮，包括开始时间和运行时间添加框，表格动态显示运行过程及状态，并设置按钮显示最终调度记录

### 回答1：
以下是一个简单的时间片轮转算法的Java GUI实现代码，包括创建进程按钮、开始时间和运行时间添加框、表格动态显示运行过程及状态，并设置按钮显示最终调度记录。请注意，此代码仅为示例，可能需要根据具体需求进行修改和优化。

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;

public class TimeSliceRoundRobin {
    private JFrame frame;
    private JPanel panel;
    private JLabel processLabel, startTimeLabel, runTimeLabel, quantumLabel;
    private JTextField processField, startTimeField, runTimeField, quantumField;
    private JButton createButton, startButton, recordButton;
    private JTable table;
    private DefaultTableModel model;
    private List<Process> processList;
    private int quantum;
    private int currentTime;
    private int finishedCount;

    public static void main(String[] args) {
        TimeSliceRoundRobin scheduler = new TimeSliceRoundRobin();
        scheduler.init();
    }

    private void init() {
        frame = new JFrame("Time Slice Round Robin");
        frame.setSize(500, 500);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        panel = new JPanel();
        panel.setLayout(new GridLayout(5, 2));

        processLabel = new JLabel("Process");
        panel.add(processLabel);
        processField = new JTextField();
        panel.add(processField);

        startTimeLabel = new JLabel("Start Time");
        panel.add(startTimeLabel);
        startTimeField = new JTextField();
        panel.add(startTimeField);

        runTimeLabel = new JLabel("Run Time");
        panel.add(runTimeLabel);
        runTimeField = new JTextField();
        panel.add(runTimeField);

        quantumLabel = new JLabel("Time Quantum");
        panel.add(quantumLabel);
        quantumField = new JTextField();
        panel.add(quantumField);

        createButton = new JButton("Create");
        createButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                createProcess();
            }
        });
        panel.add(createButton);

        startButton = new JButton("Start");
        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                startScheduler();
            }
        });
        panel.add(startButton);

        recordButton = new JButton("Show Records");
        recordButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                showRecords();
            }
        });
        recordButton.setEnabled(false);
        panel.add(recordButton);

        model = new DefaultTableModel();
        model.addColumn("Process");
        model.addColumn("Start Time");
        model.addColumn("Run Time");
        model.addColumn("Remaining Time");
        model.addColumn("Status");
        table = new JTable(model);

        JScrollPane scrollPane = new JScrollPane(table);
        frame.getContentPane().add(panel, BorderLayout.NORTH);
        frame.getContentPane().add(scrollPane, BorderLayout.CENTER);

        frame.setVisible(true);
    }

    private void createProcess() {
        String processName = processField.getText();
        int startTime = Integer.parseInt(startTimeField.getText());
        int runTime = Integer.parseInt(runTimeField.getText());

        if (processList == null) {
            processList = new ArrayList<>();
        }

        Process process = new Process(processName, startTime, runTime);
        processList.add(process);

        Object[] rowData = new Object[5];
        rowData[0] = processName;
        rowData[1] = startTime;
        rowData[2] = runTime;
        rowData[3] = runTime;
        rowData[4] = "Waiting";
        model.addRow(rowData);

        processField.setText("");
        startTimeField.setText("");
        runTimeField.setText("");
    }

    private void startScheduler() {
        quantum = Integer.parseInt(quantumField.getText());
        startButton.setEnabled(false);
        recordButton.setEnabled(true);

        while (finishedCount < processList.size()) {
            for (Process process : processList) {
                if (process.getStatus().equals("Finished")) {
                    continue;
                }

                if (process.getStartTime() > currentTime) {
                    continue;
                }

                int remainingTime = process.getRemainingTime();
                if (remainingTime <= quantum) {
                    currentTime += remainingTime;
                    process.setRemainingTime(0);
                    process.setStatus("Finished");
                    finishedCount++;

                    int rowIndex = getRowIndex(process.getName());
                    model.setValueAt(0, rowIndex, 3);
                    model.setValueAt("Finished", rowIndex, 4);
                } else {
                    currentTime += quantum;
                    process.setRemainingTime(remainingTime - quantum);

                    int rowIndex = getRowIndex(process.getName());
                    model.setValueAt(process.getRemainingTime(), rowIndex, 3);
                    model.setValueAt("Running", rowIndex, 4);
                }
            }
        }
    }

    private void showRecords() {
        String message = "Process\tStart Time\tRun Time\tFinish Time\tTurnaround Time\n";

        for (Process process : processList) {
            int finishTime = process.getStartTime() + process.getRunTime();
            int turnaroundTime = finishTime - process.getStartTime();
            message += process.getName() + "\t" + process.getStartTime() + "\t" + process.getRunTime() + "\t" + finishTime + "\t" + turnaroundTime + "\n";
        }

        JOptionPane.showMessageDialog(frame, message);
    }

    private int getRowIndex(String processName) {
        for (int i = 0; i < model.getRowCount(); i++) {
            if (model.getValueAt(i, 0).equals(processName)) {
                return i;
            }
        }
        return -1;
    }

    private class Process {
        private String name;
        private int startTime;
        private int runTime;
        private int remainingTime;
        private String status;

        public Process(String name, int startTime, int runTime) {
            this.name = name;
            this.startTime = startTime;
            this.runTime = runTime;
            this.remainingTime = runTime;
            this.status = "Waiting";
        }

        public String getName() {
            return name;
        }

        public int getStartTime() {
            return startTime;
        }

        public int getRunTime() {
            return runTime;
        }

        public int getRemainingTime() {
            return remainingTime;
        }

        public void setRemainingTime(int remainingTime) {
            this.remainingTime = remainingTime;
        }

        public String getStatus() {
            return status;
        }

        public void setStatus(String status) {
            this.status = status;
        }
    }
}

### 回答2：
以下是一个简单的时间片轮转算法的Java GUI实现代码：

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

public class TimeSliceRoundRobinAlgorithm extends JFrame {
    private JPanel panel;
    private JButton createProcessButton;
    private JButton showScheduleButton;
    private JTextField startTimeField;
    private JTextField runTimeField;
    private JTable processTable;
    private DefaultTableModel tableModel;
    private List<Process> processes;
    private int currentProcessIndex;

    public TimeSliceRoundRobinAlgorithm() {
        panel = new JPanel(new BorderLayout());

        createProcessButton = new JButton("创建进程");
        createProcessButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                createProcess();
            }
        });

        showScheduleButton = new JButton("显示调度记录");
        showScheduleButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                showSchedule();
            }
        });

        JLabel startTimeLabel = new JLabel("开始时间：");
        startTimeField = new JTextField();
        JLabel runTimeLabel = new JLabel("运行时间：");
        runTimeField = new JTextField();

        JPanel inputPanel = new JPanel();
        inputPanel.add(createProcessButton);
        inputPanel.add(startTimeLabel);
        inputPanel.add(startTimeField);
        inputPanel.add(runTimeLabel);
        inputPanel.add(runTimeField);
        inputPanel.add(showScheduleButton);

        tableModel = new DefaultTableModel(new Object[]{"进程ID", "开始时间", "运行时间", "状态"}, 0);
        processTable = new JTable(tableModel);

        panel.add(inputPanel, BorderLayout.NORTH);
        panel.add(new JScrollPane(processTable), BorderLayout.CENTER);

        processes = new ArrayList<>();
        currentProcessIndex = 0;

        setContentPane(panel);
        setTitle("时间片轮转算法");
        setSize(500, 500);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    // 创建进程
    private void createProcess() {
        int startTime = Integer.parseInt(startTimeField.getText());
        int runTime = Integer.parseInt(runTimeField.getText());

        Process process = new Process(startTime, runTime);
        processes.add(process);

        tableModel.addRow(new Object[]{process.getID(), process.getStartTime(), process.getRunTime(), "就绪"});
    }

    // 显示调度记录
    private void showSchedule() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                Process currentProcess = processes.get(currentProcessIndex);
                int remainingTime = currentProcess.getRemainingTime();

                if (remainingTime > 0) {
                    if (remainingTime <= 1) {
                        currentProcess.setStatus("完成");
                        tableModel.setValueAt(currentProcess.getStatus(), currentProcessIndex, 3);
                        currentProcessIndex = (currentProcessIndex + 1) % processes.size();
                    } else {
                        currentProcess.decreaseRemainingTime();
                        currentProcessIndex = (currentProcessIndex + 1) % processes.size();
                    }
                }
            }
        }, 0, 1000);
    }

    // 进程类
    private static class Process {
        private static int totalProcessCount = 0;
        private int ID;
        private int startTime;
        private int runTime;
        private int remainingTime;
        private String status;

        public Process(int startTime, int runTime) {
            this.ID = ++totalProcessCount;
            this.startTime = startTime;
            this.runTime = runTime;
            this.remainingTime = runTime;
            this.status = "就绪";
        }

        public int getID() {
            return ID;
        }

        public int getStartTime() {
            return startTime;
        }

        public int getRunTime() {
            return runTime;
        }

        public int getRemainingTime() {
            return remainingTime;
        }

        public void decreaseRemainingTime() {
            remainingTime--;
        }

        public String getStatus() {
            return status;
        }

        public void setStatus(String status) {
            this.status = status;
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new TimeSliceRoundRobinAlgorithm();
            }
        });
    }
}

本代码实现了一个简单的时间片轮转算法的Java GUI程序。程序界面上有一个“创建进程”按钮，以及用于输入进程开始时间和运行时间的两个文本框。在程序的表格中，动态显示了进程的运行过程及状态，并设置了一个按钮用于显示最终的调度记录。当点击"创建进程"按钮时，会根据输入的开始时间和运行时间创建一个新的进程，并将该进程的信息添加到表格中。当点击"显示调度记录"按钮时，程序将按照时间片的规则，依次运行各个进程，直到所有进程都完成。在每次调度过程中，会更新表格中对应进程的状态，并在最后一个进程完成时停止调度。

### 回答3：
下面是一个简单的时间片轮转算法的Java GUI实现代码。

首先，在Java中创建一个类名为TimeSliceScheduling的类：

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class TimeSliceScheduling extends JFrame implements ActionListener {
    private JButton createProcessButton;
    private JButton showFinalScheduleButton;
    private JTextField startTimeField;
    private JTextField runningTimeField;
    private JTable processTable;
    private DefaultTableModel tableModel;
    private ArrayList<Process> processes;
    private ArrayList<String[]> scheduleRecord;

    private int timeSlice;
    private int currentTime;

    public TimeSliceScheduling() {
        setTitle("时间片轮转算法");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建按钮和文本框
        createProcessButton = new JButton("创建进程");
        showFinalScheduleButton = new JButton("显示最终调度记录");
        startTimeField = new JTextField(10);
        runningTimeField = new JTextField(10);

        // 创建表格
        tableModel = new DefaultTableModel(new String[]{"开始时间", "运行时间"}, 0);
        processTable = new JTable(tableModel);

        // 添加组件到窗口
        setLayout(new FlowLayout());
        add(new JLabel("开始时间: "));
        add(startTimeField);
        add(new JLabel("运行时间: "));
        add(runningTimeField);
        add(createProcessButton);
        add(showFinalScheduleButton);
        add(new JScrollPane(processTable));

        // 为按钮添加监听器
        createProcessButton.addActionListener(this);
        showFinalScheduleButton.addActionListener(this);

        // 初始化数据结构
        processes = new ArrayList<>();
        scheduleRecord = new ArrayList<>();
        timeSlice = 10; // 为了简化，假设时间片大小为10

        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == createProcessButton) {
            // 获取开始时间和运行时间
            int startTime = Integer.parseInt(startTimeField.getText());
            int runningTime = Integer.parseInt(runningTimeField.getText());

            // 创建新进程
            Process process = new Process(startTime, runningTime);
            processes.add(process);

            // 将进程添加到表格中
            tableModel.addRow(new String[]{String.valueOf(startTime), String.valueOf(runningTime)});
        } else if (e.getSource() == showFinalScheduleButton) {
            // 运行调度算法
            runScheduler();

            // 创建最终调度记录窗口并显示记录
            String[] columnNames = {"时间", "进程ID"};
            String[][] rowData = new String[scheduleRecord.size()][2];
            for (int i = 0; i < scheduleRecord.size(); i++) {
                rowData[i] = scheduleRecord.get(i);
            }
            JTable finalScheduleTable = new JTable(rowData, columnNames);
            JOptionPane.showMessageDialog(null, new JScrollPane(finalScheduleTable), "最终调度记录", JOptionPane.PLAIN_MESSAGE);
        }
    }

    private void runScheduler() {
        currentTime = 0;
        int remainingProcesses = processes.size();
        int currentProcessIndex = 0;

        while (remainingProcesses > 0) {
            Process currentProcess = processes.get(currentProcessIndex);
            if (currentProcess.getRemainingTime() > 0) {
                if (currentProcess.getRemainingTime() <= timeSlice) {
                    scheduleRecord.add(new String[]{String.valueOf(currentTime), String.valueOf(currentProcessIndex)});
                    currentTime += currentProcess.getRemainingTime();
                    currentProcess.setRemainingTime(0);
                    remainingProcesses--;
                } else {
                    scheduleRecord.add(new String[]{String.valueOf(currentTime), String.valueOf(currentProcessIndex)});
                    currentTime += timeSlice;
                    currentProcess.setRemainingTime(currentProcess.getRemainingTime() - timeSlice);
                }
            }

            currentProcessIndex = (currentProcessIndex + 1) % processes.size();
        }
    }

    public static void main(String[] args) {
        new TimeSliceScheduling();
    }
}

class Process {
    private int startTime;
    private int runningTime;
    private int remainingTime;

    public Process(int startTime, int runningTime) {
        this.startTime = startTime;
        this.runningTime = runningTime;
        this.remainingTime = runningTime;
    }

    // getter和setter方法...

    public int getRemainingTime() {
        return remainingTime;
    }

    public void setRemainingTime(int remainingTime) {
        this.remainingTime = remainingTime;
    }
}

这个程序中有两个按钮，一个用于创建进程，另一个用于显示最终的调度记录。进程的开始时间和运行时间通过文本框输入，并添加到表格中。点击显示最终调度记录按钮时，将调用`runScheduler`方法来执行时间片轮转算法，并创建一个新的窗口显示最终的调度记录。

请注意，此代码仅用于演示时间片轮转算法的基本思想和Java GUI的用法，可能还需要进行进一步的优化和完善，以适应更复杂的实际应用场景。