上午linux实验做不出来调度算法，现在用java感觉好多了。

思如泉涌，但是翻了一些书，好像不对！！

应该先分成未运行和已运行两种，然后给未运行的作业写调度算法。我一上来就开始调度了。。。

·那就会出现这样的问题：如果是优先级调度，优先级高的还没到到达时间，但是优先级比它低的任务已经到了。应该先执行先到的，还是等着优先级高的呢（一直等的话好像不太合理啊，一直等还算优先级调度吗）好了我知道了

暂时先把输入写成示例试试。

  • 先来先服务1.0版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package task;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class xianlaixianfuwu {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }
    }

    public static void main(String[] args) {
        //输入
        List<tasks> tasksList=new ArrayList<>();
        tasksList.add(new tasks(1,'a',1,7,2,1));
        tasksList.add(new tasks(2,'b',2,8,1,3));
        tasksList.add(new tasks(3,'c',3,8.5,2,4));
        tasksList.add(new tasks(4,'d',4,9,0.5,2));

        //先来先服务
        Comparator<tasks> comparator=Comparator.comparing(tasks :: getArriveTime);
        tasksList.sort(comparator);
        int order=0;
        double time=tasksList.get(0).arriveTime;//此时时间点
        for (xianlaixianfuwu.tasks tasks : tasksList) {
            order++;
            tasks.setOrder(order);
            if(time> tasks.arriveTime){
                tasks.startRunningTime=time;
            }
            time+= tasks.runningTime;
            tasks.runningEndTime=time;
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

  • 优先级调度1.0❌

    错误版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package task;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class youxianjidiaodu {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }
    }

    public static void main(String[] args) {
        //输入
        List<xianlaixianfuwu.tasks> tasksList=new ArrayList<>();
        tasksList.add(new xianlaixianfuwu.tasks(1,'a',1,7,2,1));
        tasksList.add(new xianlaixianfuwu.tasks(2,'b',2,8,1,3));
        tasksList.add(new xianlaixianfuwu.tasks(3,'c',3,8.5,2,4));
        tasksList.add(new xianlaixianfuwu.tasks(4,'d',4,9,0.5,2));

        //优先级调度
        //这里弄不太准，如果优先级高的还没来，是执行别的，还是等着？ 先按等着写
        Comparator<xianlaixianfuwu.tasks> comparator=Comparator.comparing(xianlaixianfuwu.tasks:: getYouxianshu);
        tasksList.sort(comparator);
        int order=0;
        double time=tasksList.get(0).arriveTime;//此时时间点
        for (xianlaixianfuwu.tasks tasks : tasksList) {
            order++;
            tasks.setOrder(order);
            if(time> tasks.arriveTime){
                tasks.startRunningTime=time;
            }
            time+= tasks.runningTime;
            tasks.runningEndTime=time;
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

记录一下正确思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//输入
List<xianlaixianfuwu.tasks> tasksList=new ArrayList<>();
tasksList.add(new xianlaixianfuwu.tasks(1,'a',1,7,2,1));
tasksList.add(new xianlaixianfuwu.tasks(2,'b',2,8,1,3));
tasksList.add(new xianlaixianfuwu.tasks(3,'c',3,8.5,2,4));
tasksList.add(new xianlaixianfuwu.tasks(4,'d',4,9,0.5,2));
//找最先的到达的作为时间time的开始，完成后更新time+=runningtime
//tasksyiwanchangList.add(task001)
//tasksList.del(task001)删除最先的到达的task

//list.for执行下面这行的操作
//在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行优先级最高的执行，更新time+=runningtime

//最后遍历出结果tasksyiwanchengList

//****************************分割线******************************

下面这俩明显感觉到不对劲了如果还是按照错的思路写的话

短作业优先

1

这个更不对了，每次进一个任务都要更新一下响应比，响应比不是一次就定好的，进来一个任务，剩下的任务响应比会变的。

响应比高优先

1

  • 优先级调度2.0

    这回感觉对了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
package task;

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

public class youxianjidiaodu {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }
    }

    public static void main(String[] args) {
        //输入
        List<tasks> tasksList=new ArrayList<>();
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        tasksList.add(new tasks(1,'a',1,7,2,1));
        tasksList.add(new tasks(2,'b',2,8,1,3));
        tasksList.add(new tasks(3,'c',3,8.5,2,4));
        tasksList.add(new tasks(4,'d',4,9,0.5,2));
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行优先级最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按优先数排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getYouxianshu);
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

  • 短作业优先调度

    对的应该，捋顺思路写完上一个容易多了（只改了一个单词）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
package task;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class duanzuoyeyouxian {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }
    }

    public static void main(String[] args) {
        //输入
        List<tasks> tasksList=new ArrayList<>();
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        tasksList.add(new tasks(1,'a',1,7,2,1));
        tasksList.add(new tasks(2,'b',2,8,1,3));
        tasksList.add(new tasks(3,'c',3,8.5,2,4));
        tasksList.add(new tasks(4,'d',4,9,0.5,2));
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选作业runningtime最小的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按作业长短排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getRunningTime);//那这么的话和优先级相比只改了这一个单词
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

  • 响应比高者优先

    完成啦！！！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
![202410304](C:\Users\86158\Desktop\blog\source\img\202410304.jpg)package task;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class xiangyingbigaoyouxian {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序
        double xingyingbi;//响应比

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }

        public double getXingyingbi() {
            return xingyingbi;
        }

        public void setXingyingbi(double xingyingbi) {
            this.xingyingbi = xingyingbi;
        }
    }

    public static void main(String[] args) {
        //输入
        List<tasks> tasksList=new ArrayList<>();
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        tasksList.add(new tasks(1,'a',1,7,2,1));
        tasksList.add(new tasks(2,'b',2,8,1,3));
        tasksList.add(new tasks(3,'c',3,8.5,2,4));
        tasksList.add(new tasks(4,'d',4,9,0.5,2));

        //响应比高优先  当每次进程被调度就要重新计算新的响应比
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行响应比最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务 然后响应比改变 重新计算新的响应比
            //计算runningendtime 迭代每个任务是下一次就被调的情况得到的tasks.runningendtime
            for (tasks tasks : tasksList) {
                //好像应该time和arrivetime比较 还没到的要不要算响应比去比较啊？？
                //先按照还没来的就不参与响应比的计算
                tasks.xingyingbi=-1;
                //为了计算响应比才暂时赋值 后面每次for里都要完成一个任务时才是正式的赋值
                if (tasks.arriveTime<=time){//给来的任务计算响应比 不来的响应比默认-1
                    tasks.runningEndTime+=(time+ tasks.runningTime);
                }
            }

            //每次重新计算响应比 所以没个任务的zhouzhuanshijian必须在下面的计算前就已经知道tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            for (tasks tasks : tasksList) {
                tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
                tasks.xingyingbi=1+(tasks.zhouzhuanshijian/ tasks.runningTime);
            }
            //将未完成的tasks按响应比排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getXingyingbi).reversed();//在这之前必须把响应比算出来
            tasksList.sort(comparator2);

            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

cv大法整成函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

class Main {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序
        double xingyingbi;//响应比

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }

        public double getXingyingbi() {
            return xingyingbi;
        }

        public void setXingyingbi(double xingyingbi) {
            this.xingyingbi = xingyingbi;
        }
    }

    public static void main(String[] args) {
        List<tasks> tasksList=new ArrayList<>();
        tasksList.add(new tasks(1,'a',1,7,2,1));
        tasksList.add(new tasks(2,'b',2,8,1,3));
        tasksList.add(new tasks(3,'c',3,8.5,2,4));
        tasksList.add(new tasks(4,'d',4,9,0.5,2));
        //选择调度
        System.out.println("1.先来先服务");
        System.out.println("2.优先级调度");
        System.out.println("3.短作业优先调度");
        System.out.println("4.响应比高者优先调度");
        Scanner sc=new Scanner(System.in);
        int ch=sc.nextInt();
        switch (ch){
            case 1:xianlaixianfuwu(tasksList);break;
            case 2:youxianjidiaodu(tasksList);break;
            case 3:duanzuoyeyouxian(tasksList);break;
            case 4:xiangyingbigaoyouxian(tasksList);break;
        }
    }

    public static void xianlaixianfuwu(List<tasks> tasksList) {
        //先来先服务
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        int order=0;
        double time=tasksList.get(0).arriveTime;//此时时间点
        for (tasks tasks : tasksList) {
            order++;
            tasks.setOrder(order);
            if(time> tasks.arriveTime){
                tasks.startRunningTime=time;
            }
            time+= tasks.runningTime;
            tasks.runningEndTime=time;
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void youxianjidiaodu(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行优先级最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按优先数排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getYouxianshu);
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void duanzuoyeyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选作业runningtime最小的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按作业长短排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getRunningTime);//那这么的话和优先级相比只改了这一个单词
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void xiangyingbigaoyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //响应比高优先  当每次进程被调度就要重新计算新的响应比
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行响应比最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务 然后响应比改变 重新计算新的响应比
            //计算runningendtime 迭代每个任务是下一次就被调的情况得到的tasks.runningendtime
            for (tasks tasks : tasksList) {
                //好像应该time和arrivetime比较 还没到的要不要算响应比去比较啊？？
                //先按照还没来的就不参与响应比的计算
                tasks.xingyingbi=-1;
                //为了计算响应比才暂时赋值 后面每次for里都要完成一个任务时才是正式的赋值
                if (tasks.arriveTime<=time){//给来的任务计算响应比 不来的响应比默认-1
                    tasks.runningEndTime+=(time+ tasks.runningTime);
                }
            }

            //每次重新计算响应比 所以没个任务的zhouzhuanshijian必须在下面的计算前就已经知道tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            for (tasks tasks : tasksList) {
                tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
                tasks.xingyingbi=1+(tasks.zhouzhuanshijian/ tasks.runningTime);
            }
            //将未完成的tasks按响应比排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getXingyingbi).reversed();//在这之前必须把响应比算出来
            tasksList.sort(comparator2);

            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

大功完成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

class Main {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序
        double xingyingbi;//响应比

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }

        public double getXingyingbi() {
            return xingyingbi;
        }

        public void setXingyingbi(double xingyingbi) {
            this.xingyingbi = xingyingbi;
        }
    }

    public static void main(String[] args) {
        List<tasks> tasksList=new ArrayList<>();
        System.out.println("请输入task个数");
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for (int i = 0; i < n; i++) {
            System.out.println("请依次输入第"+(i+1)+"个进程的序号 进程名 进程号 到达时间 运行时间 优先数");
            int id=sc.nextInt();
            char jingchengname=sc.next().charAt(0);
            int jingchengid= sc.nextInt();
            double arrivetime= sc.nextDouble();
            double runningtime= sc.nextDouble();
            int youxianshu= sc.nextInt();
            tasksList.add(new tasks(id,jingchengname,jingchengid,arrivetime,runningtime,youxianshu));
        }
        //选择调度
        System.out.println("1.先来先服务");
        System.out.println("2.优先级调度");
        System.out.println("3.短作业优先调度");
        System.out.println("4.响应比高者优先调度");
        int ch=sc.nextInt();
        switch (ch){
            case 1:xianlaixianfuwu(tasksList);break;
            case 2:youxianjidiaodu(tasksList);break;
            case 3:duanzuoyeyouxian(tasksList);break;
            case 4:xiangyingbigaoyouxian(tasksList);break;
        }
    }

    public static void xianlaixianfuwu(List<tasks> tasksList) {
        //先来先服务
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        int order=0;
        double time=tasksList.get(0).arriveTime;//此时时间点
        for (tasks tasks : tasksList) {
            order++;
            tasks.setOrder(order);
            if(time>= tasks.arriveTime){
                tasks.startRunningTime=time;
            }else {
                time=tasks.arriveTime;//这里少些一句这个else 才看到 补上了
            }
            time+= tasks.runningTime;
            tasks.runningEndTime=time;
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间(左->右)");
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void youxianjidiaodu(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行优先级最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按优先数排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getYouxianshu);
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间(左->右)");
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void duanzuoyeyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选作业runningtime最小的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按作业长短排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getRunningTime);//那这么的话和优先级相比只改了这一个单词
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间(左->右)");
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }

    public static void xiangyingbigaoyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //响应比高优先  当每次进程被调度就要重新计算新的响应比
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行响应比最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务 然后响应比改变 重新计算新的响应比
            //计算runningendtime 迭代每个任务是下一次就被调的情况得到的tasks.runningendtime
            for (tasks tasks : tasksList) {
                //好像应该time和arrivetime比较 还没到的要不要算响应比去比较啊？？
                //先按照还没来的就不参与响应比的计算
                tasks.xingyingbi=-1;
                //为了计算响应比才暂时赋值 后面每次for里都要完成一个任务时才是正式的赋值
                if (tasks.arriveTime<=time){//给来的任务计算响应比 不来的响应比默认-1
                    tasks.runningEndTime+=(time+ tasks.runningTime);
                }
            }

            //每次重新计算响应比 所以没个任务的zhouzhuanshijian必须在下面的计算前就已经知道tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            for (tasks tasks : tasksList) {
                tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
                tasks.xingyingbi=1+(tasks.zhouzhuanshijian/ tasks.runningTime);
            }
            //将未完成的tasks按响应比排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getXingyingbi).reversed();//在这之前必须把响应比算出来
            tasksList.sort(comparator2);

            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间(左->右)");
            System.out.println(tasks.id+" "+tasks.jinchengname+" "+tasks.jinchengId+" "+ tasks.arriveTime+" "+ tasks.runningTime+" "+ tasks.youxianshu+" "+tasks.startRunningTime+" "+ tasks.runningEndTime+" "+tasks.zhouzhuanshijian+" "+tasks.saiquanzhouzhuanshijian+" "+ tasks.getOrder());
        }
    }
}

优先级调度应该是数大的高，之前写错了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

class Main {
    static class tasks{
        int id;//序号
        char jinchengname;//进程名
        int jinchengId;//
        double arriveTime;//提交时间
        double runningTime;//运行时间
        int youxianshu;//优先数
        double jinrushuchujingshijian;//进入输出＃时间
        double startRunningTime;//开始运行时间
        double shangxvyunxingshijian;//尚需运行时间
        double runningEndTime;//运行结束时间
        double zhouzhuanshijian;//周转时间
        double saiquanzhouzhuanshijian;//带权周转时间
        int order;//运行次序
        double xingyingbi;//响应比

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public char getJinchengname() {
            return jinchengname;
        }

        public void setJinchengname(char jinchengname) {
            this.jinchengname = jinchengname;
        }

        public int getJinchengId() {
            return jinchengId;
        }

        public void setJinchengId(int jinchengId) {
            this.jinchengId = jinchengId;
        }

        public double getArriveTime() {
            return arriveTime;
        }

        public void setArriveTime(double arriveTime) {
            this.arriveTime = arriveTime;
        }

        public double getRunningTime() {
            return runningTime;
        }

        public void setRunningTime(double runningTime) {
            this.runningTime = runningTime;
        }

        public int getYouxianshu() {
            return youxianshu;
        }

        public void setYouxianshu(int youxianshu) {
            this.youxianshu = youxianshu;
        }

        public double getJinrushuchujingshijian() {
            return jinrushuchujingshijian;
        }

        public void setJinrushuchujingshijian(double jinrushuchujingshijian) {
            this.jinrushuchujingshijian = jinrushuchujingshijian;
        }

        public double getStartRunningTime() {
            return startRunningTime;
        }

        public void setStartRunningTime(double startRunningTime) {
            this.startRunningTime = startRunningTime;
        }

        public double getShangxvyunxingshijian() {
            return shangxvyunxingshijian;
        }

        public void setShangxvyunxingshijian(double shangxvyunxingshijian) {
            this.shangxvyunxingshijian = shangxvyunxingshijian;
        }

        public double getRunningEndTime() {
            return runningEndTime;
        }

        public void setRunningEndTime(double runningEndTime) {
            this.runningEndTime = runningEndTime;
        }

        public double getZhouzhuanshijian() {
            return zhouzhuanshijian;
        }

        public void setZhouzhuanshijian(double zhouzhuanshijian) {
            this.zhouzhuanshijian = zhouzhuanshijian;
        }

        public double getSaiquanzhouzhuanshijian() {
            return saiquanzhouzhuanshijian;
        }

        public void setSaiquanzhouzhuanshijian(double saiquanzhouzhuanshijian) {
            this.saiquanzhouzhuanshijian = saiquanzhouzhuanshijian;
        }

        public int getOrder() {
            return order;
        }

        public void setOrder(int order) {
            this.order = order;
        }

        public tasks(int id, char jinchengname, int jinchengId, double arriveTime, double runningTime, int youxianshu) {
            this.id = id;
            this.jinchengname = jinchengname;
            this.jinchengId = jinchengId;
            this.arriveTime = arriveTime;
            this.runningTime = runningTime;
            this.youxianshu = youxianshu;
        }

        public double getXingyingbi() {
            return xingyingbi;
        }

        public void setXingyingbi(double xingyingbi) {
            this.xingyingbi = xingyingbi;
        }
    }

    public static void main(String[] args) {
        List<tasks> tasksList=new ArrayList<>();
        System.out.println("请输入task个数");
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        for (int i = 0; i < n; i++) {
            System.out.println("请依次输入第"+(i+1)+"个进程的序号 进程名 进程号 到达时间 运行时间 优先数");
            int id=sc.nextInt();
            char jingchengname=sc.next().charAt(0);
            int jingchengid= sc.nextInt();
            double arrivetime= sc.nextDouble();
            double runningtime= sc.nextDouble();
            int youxianshu= sc.nextInt();
            tasksList.add(new tasks(id,jingchengname,jingchengid,arrivetime,runningtime,youxianshu));
        }
        //选择调度
        System.out.println("1.先来先服务");
        System.out.println("2.优先级调度");
        System.out.println("3.短作业优先调度");
        System.out.println("4.响应比高者优先调度");
        int ch=sc.nextInt();
        switch (ch){
            case 1:xianlaixianfuwu(tasksList);break;
            case 2:youxianjidiaodu(tasksList);break;
            case 3:duanzuoyeyouxian(tasksList);break;
            case 4:xiangyingbigaoyouxian(tasksList);break;
        }
    }

    public static void xianlaixianfuwu(List<tasks> tasksList) {
        //先来先服务
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        int order=0;
        double time=tasksList.get(0).arriveTime;//此时时间点
        for (tasks tasks : tasksList) {
            order++;
            tasks.setOrder(order);
            if(time>= tasks.arriveTime){
                tasks.startRunningTime=time;
            }else {
                time=tasks.arriveTime;//这里少些一句这个else 才看到 补上了
            }
            time+= tasks.runningTime;
            tasks.runningEndTime=time;
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间\t"+"运行次序(左->右)");
            System.out.println(tasks.id+"\t"+tasks.jinchengname+"\t"+tasks.jinchengId+"\t"+ tasks.arriveTime+"\t"+ tasks.runningTime+"\t"+ tasks.youxianshu+"\t"+tasks.startRunningTime+"\t"+ tasks.runningEndTime+"\t"+tasks.zhouzhuanshijian+"\t"+tasks.saiquanzhouzhuanshijian+"\t"+ tasks.getOrder());
        }
    }

    public static void youxianjidiaodu(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行优先级最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按优先数排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getYouxianshu).reversed();
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间\t"+"运行次序(左->右)");
            System.out.println(tasks.id+"\t"+tasks.jinchengname+"\t"+tasks.jinchengId+"\t"+ tasks.arriveTime+"\t"+ tasks.runningTime+"\t"+ tasks.youxianshu+"\t"+tasks.startRunningTime+"\t"+ tasks.runningEndTime+"\t"+tasks.zhouzhuanshijian+"\t"+tasks.saiquanzhouzhuanshijian+"\t"+ tasks.getOrder());
        }
    }

    public static void duanzuoyeyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选作业runningtime最小的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务
            //将未完成的tasks按作业长短排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getRunningTime);//那这么的话和优先级相比只改了这一个单词
            tasksList.sort(comparator2);
            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间\t"+"运行次序(左->右)");
            System.out.println(tasks.id+"\t"+tasks.jinchengname+"\t"+tasks.jinchengId+"\t"+ tasks.arriveTime+"\t"+ tasks.runningTime+"\t"+ tasks.youxianshu+"\t"+tasks.startRunningTime+"\t"+ tasks.runningEndTime+"\t"+tasks.zhouzhuanshijian+"\t"+tasks.saiquanzhouzhuanshijian+"\t"+ tasks.getOrder());
        }
    }

    public static void xiangyingbigaoyouxian(List<tasks> tasksList) {
        List<tasks> tasksyiwanchengList=new ArrayList<>();
        //响应比高优先  当每次进程被调度就要重新计算新的响应比
        //找最先的到达的作为时间time的开始，完成后更新time+=runningtime
        Comparator<tasks> comparator=Comparator.comparing(tasks:: getArriveTime);
        tasksList.sort(comparator);
        //tasksyiwanchangList.add(task001)
        tasksyiwanchengList.add(tasksList.get(0));
        double time=tasksList.get(0).arriveTime;//此时时间点
        tasksList.get(0).startRunningTime=time;
        time+=tasksList.get(0).runningTime;
        tasksList.get(0).runningEndTime=time;
        //tasksList.del(task001)删除最先的到达的task
        tasksList.remove(0);
        //list.for执行下面这行的操作
        //在剩下的task里&&arrivetime<time也就是已经到达但还没开始的任务里，选执行响应比最高的执行，更新time+=runningtime
        int n= tasksList.size();
        for (int i = 0; i < n; i++) {//每次for里都要完成且只完成一个任务 然后响应比改变 重新计算新的响应比
            //计算runningendtime 迭代每个任务是下一次就被调的情况得到的tasks.runningendtime
            for (tasks tasks : tasksList) {
                //好像应该time和arrivetime比较 还没到的要不要算响应比去比较啊？？
                //先按照还没来的就不参与响应比的计算
                tasks.xingyingbi=-1;
                //为了计算响应比才暂时赋值 后面每次for里都要完成一个任务时才是正式的赋值
                if (tasks.arriveTime<=time){//给来的任务计算响应比 不来的响应比默认-1
                    tasks.runningEndTime+=(time+ tasks.runningTime);
                }
            }

            //每次重新计算响应比 所以没个任务的zhouzhuanshijian必须在下面的计算前就已经知道tasks.zhouzhuanshijian=Time-tasks.arriveTime;
            for (tasks tasks : tasksList) {
                tasks.zhouzhuanshijian=time-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
                tasks.xingyingbi=1+(tasks.zhouzhuanshijian/ tasks.runningTime);
            }
            //将未完成的tasks按响应比排序
            Comparator<tasks> comparator2=Comparator.comparing(tasks:: getXingyingbi).reversed();//在这之前必须把响应比算出来
            tasksList.sort(comparator2);

            int flag=0;
            for (tasks tasks : tasksList) {
                if(tasks.arriveTime<=time){
                    tasks.startRunningTime=time;
                    time+=tasks.runningTime;
                    tasks.runningEndTime=time;
                    tasksyiwanchengList.add(tasks);
                    tasksList.remove(tasks);
                    flag=1;
                    break;
                }
            }
            if (flag==0){
                //如果全都没到达，直接移除接下来最早到达的
                Comparator<tasks> comparator3=Comparator.comparing(tasks:: getArriveTime);
                tasksList.sort(comparator3);
                tasksList.get(0).startRunningTime=tasksList.get(0).arriveTime;
                time+=tasksList.get(0).runningTime;
                tasksList.get(0).runningEndTime=time;
                tasksyiwanchengList.add(tasksList.get(0));
                tasksList.remove(0);
            }
        }
        //最后遍历出结果tasksyiwanchengList
        int order=0;
        for (tasks tasks : tasksyiwanchengList) {
            order++;
            tasks.setOrder(order);
            tasks.zhouzhuanshijian=tasks.runningEndTime-tasks.arriveTime;//arrivetime已知不用管 runningendtime必须知道
            tasks.saiquanzhouzhuanshijian=tasks.zhouzhuanshijian / tasks.runningTime;
            System.out.println("序号\t"+"进程名\t"+"进程号\t"+"到达时间\t"+"运行时间\t"+"优先数\t"+"开始运行时间\t"+"运行结束时间\t"+"周转时间\t"+"带权周转时间\t"+"运行次序(左->右)");
            System.out.println(tasks.id+"\t"+tasks.jinchengname+"\t"+tasks.jinchengId+"\t"+ tasks.arriveTime+"\t"+ tasks.runningTime+"\t"+ tasks.youxianshu+"\t"+tasks.startRunningTime+"\t"+ tasks.runningEndTime+"\t"+tasks.zhouzhuanshijian+"\t"+tasks.saiquanzhouzhuanshijian+"\t"+ tasks.getOrder());
        }
    }
}

响应比=1+（等待时间/运行时间）√

响应比=1+（周转时间/运行时间）×