作业批处理调度java代码及实例

合集下载

算法设计与分析——批处理作业调度(回溯法)

算法设计与分析——批处理作业调度(回溯法)

算法设计与分析——批处理作业调度(回溯法)之前讲过⼀个相似的问题流⽔作业调度问题,那⼀道题最开始⽤动态规划,推到最后得到了⼀个Johnson法则,变成了⼀个排序问题,有兴趣的可以看⼀下本篇博客主要参考⾃⼀、问题描述给定n个作业的集合{J1,J2,…,Jn}。

每个作业必须先由机器1处理,然后由机器2处理。

作业Ji需要机器j的处理时间为t ji。

对于⼀个确定的作业调度,设Fji是作业i在机器j上完成处理的时间。

所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。

批处理作业调度问题要求对于给定的n个作业,制定最佳作业调度⽅案,使其完成时间和达到最⼩。

例:设n=3,考虑以下实例:看到这⾥可能会对这些完成时间和是怎么计算出来的会有疑问,这⾥我拿123和312的⽅案来说明⼀下。

对于调度⽅案(1,2,3)作业1在机器1上完成的时间是2,在机器2上完成的时间是3作业2在机器1上完成的时间是5,在机器2上完成的时间是6作业3在机器1上完成的时间是7,在机器2上完成的时间是10所以,作业调度的完成时间和= 3 + 6 + 10这⾥我们可以思考⼀下作业i在机器2上完成的时间应该怎么去求?作业i在机器1上完成的时间是连续的,所以是直接累加就可以。

但对于机器2就会产⽣两种情况,这两种情况其实就是上图的两种情况,对于(1,2,3)的调度⽅案,在求作业2在机器2上完成的时间时,由于作业2在机器1上还没有完成,这就需要先等待机器1处理完;⽽对于(3,1,2)的调度⽅案,在求作业2在机器2上完成的时间时,作业2在机器1早已完成,⽆需等待,直接在作业1被机器1处理之后就能接着被处理。

综上,我们可以得到如下表达式if(F2[i-1] > F1[i])F2[i] = F2[i-1] + t[2][i]elseF2[i] = F1[i] + t[2][i]⼆、算法设计类Flowshop的数据成员记录解空间的结点信息,M输⼊作业时间,bestf记录当前最⼩完成时间和,数组bestx记录相应的当前最佳作业调度。

java中taskscheduler用法

java中taskscheduler用法

java中taskscheduler用法(原创实用版)目录1.TaskScheduler 简介2.TaskScheduler 的作用3.TaskScheduler 的实现4.TaskScheduler 的示例正文【TaskScheduler 简介】TaskScheduler 是 Java 中的一个类,用于实现任务的调度和管理。

它是 Java 并发编程中的一个重要组成部分,能够帮助开发者有效地控制任务的执行时间,提高程序的执行效率。

【TaskScheduler 的作用】TaskScheduler 的主要作用是调度和管理任务的执行。

通过TaskScheduler,开发者可以设置任务的执行时间,可以设置多个任务的执行顺序,还可以监控任务的执行状态。

这样,开发者就可以根据实际需要,灵活地控制任务的执行,提高程序的执行效率。

【TaskScheduler 的实现】TaskScheduler 的实现主要是通过java.util.concurrent.Executors 类中的 schedule() 方法来实现的。

这个方法接受一个实现 Runnable 接口的任务,以及任务的执行时间,然后返回一个 Future 对象,表示任务的执行结果。

通过这个方法,开发者可以设置任务的执行时间,监控任务的执行状态,还可以获取任务的执行结果。

【TaskScheduler 的示例】下面是一个简单的 TaskScheduler 示例:```javaimport java.util.concurrent.*;public class TaskSchedulerExample {public static void main(String[] args) {// 创建一个 TaskScheduler 实例TaskScheduler taskScheduler =Executors.newScheduledThreadPool(1);// 创建一个实现 Runnable 接口的任务Runnable task = new Runnable() {@Overridepublic void run() {System.out.println("任务执行中...");}};// 设置任务的执行时间ScheduledFuture<?> future =taskScheduler.schedule(task, 1, TimeUnit.SECONDS);// 关闭 TaskSchedulertaskScheduler.shutdown();// 等待任务执行完成try {future.get();} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}System.out.println("任务执行完成");}}```在这个示例中,我们首先创建了一个 TaskScheduler 实例,然后创建了一个实现 Runnable 接口的任务。

jfinal batch用法

jfinal batch用法

jfinal batch用法JFinal Batch 是JFinal框架提供的一个批处理任务调度组件,可以用于实现定时调度任务的执行。

以下是JFinal Batch的用法示例:1. 首先,在你的项目中引入JFinal Batch的依赖:```xml<dependency><groupId>com.jfinal</groupId><artifactId>jfinal-batch</artifactId><version>1.9</version></dependency>```2. 创建一个继承自`com.jfinal.core.Batch`的任务类,重写`doBatch()`方法来实现具体的批处理逻辑,例如:```javapublic class MyBatch extends Batch {@Overridepublic void doBatch() throws Exception {// 批处理逻辑代码System.out.println("执行批处理任务");}}```3. 在你的JFinal配置类中,注册并配置批处理任务:```javapublic class AppConfig extends JFinalConfig {@Overridepublic void configConstant(Constants constants) {// 配置批处理任务JFinalBatchConfig.addJob("myJob",MyBatch.class.getName(), "* * * * *");}@Overridepublic void configRoute(Routes routes) {// ...}@Overridepublic void configPlugin(Plugins plugins) {// ...}@Overridepublic void configInterceptor(Interceptors interceptors) { // ...}@Overridepublic void configHandler(Handlers handlers) {// ...}}```在上述代码中,`addJob()`方法用来注册一个批处理任务,参数分别为任务名称、任务类名和任务的Cron表达式。

操作系统进程调度用java 写的源代码

操作系统进程调度用java 写的源代码

操作系统进程调度用java 写的源代码package tc;public class Begin{public static void main(String[] args) {new MyFrame();}}package tc;import java.awt.BorderLayout; import java.awt.Dimension;import java.awt.FlowLayout;import java.awt.GridLayout;import java.awt.Toolkit;import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.ArrayList;import java.util.Iterator;import java.util.Vector;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JList;import javax.swing.JPanel;import javax.swing.JScrollPane;import javax.swing.JTextArea;import javax.swing.JTextField;public class MyFrame extends JFrame{int minx = 0;int n;String m;String s;ArrayList<Running> list1 = new ArrayList(); ArrayList<Running> list2 = new ArrayList(); Vector<String> v = new Vector();JPanel jp = new JPanel();JPanel jp1 = new JPanel();JPanel jp2 = new JPanel();JPanel jp3 = new JPanel();JPanel jp4 = new JPanel();JPanel jp5 = new JPanel();JTextArea area1 = new JTextArea(); JTextArea area2 = new JTextArea();JList list = new JList();static JTextField jt1 = new JTextField(5); static JTextField jt2 = new JTextField(5); static JTextField jt3 = new JTextField(5); JTextField jt4 = new JTextField(); JTextField jt5 = new JTextField(); JTextField jt6 = new JTextField();JLabel jl1 = new JLabel("进程名", 0); JLabel jl2 = new JLabel("id", 0);JLabel jl3 = new JLabel("优先数", 0); JButton jb1 = new JButton("就绪"); JButton jb2 = new JButton("优先数轮转法"); JButton jb3 = new JButton("阻塞"); JButton jb4 = new JButton("唤醒"); JButton jb5 = new JButton("创建"); JButton jb6 = new JButton("先来先服务"); JButton jb7 = new JButton("撤销(就绪)"); JButton jb8 = new JButton("撤销(阻塞)");JScrollPane js1 = new JScrollPane(this.list, 22, 30);Toolkit kit = Toolkit.getDefaultToolkit();private final int x = 0;private final int y = 0;private final int width = this.kit.getScreenSize().width / 3 * 2; private final int height = this.kit.getScreenSize().height / 5 * 4;public MyFrame(){super("进程管理系统");setBounds(0, 0, this.width, this.height);add(this.jp1, "Center");this.jp1.setLayout(new GridLayout(2, 2, 20, 0));this.jp1.add(this.jp2);this.jp1.add(this.jp3);this.jp1.add(this.jp4);this.jp1.add(this.jp);this.jp2.setLayout(new BorderLayout());this.jp2.add(this.jt4, "North");this.jt4.setText("进程名\tid\t优先数");this.jt4.setEditable(false);this.jp2.add(this.area1);this.area1.setEditable(false);this.jp3.setLayout(new BorderLayout());this.jp3.add(this.jt5, "North");this.jt5.setText("进程名\tid\t优先数");this.jt5.setEditable(false);this.jp3.add(this.list);this.jp4.setLayout(new BorderLayout());this.jp4.add(this.jt6, "North");this.jt6.setText("进程名\tid\t优先数");this.jt6.setEditable(false);this.jp4.add(this.area2);this.jp.add(this.jb2);this.jp.add(this.jb6);this.jp.add(this.jb3);this.jp.add(this.jb4);this.jp.add(this.jb8);this.jp.setLayout(new FlowLayout());this.jb8.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {String a = (String)MyFrame.this.list.getSelectedValue();MyFrame.this.v.remove(a);MyFrame.this.list.setListData(MyFrame.this.v);}});this.jb2.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){Iterator it2 = MyFrame.this.list2.iterator();if (!it2.hasNext()){int min = 1000;Running r = new Running(1, 1, "a", "b");Iterator it = MyFrame.this.list1.iterator();while (it.hasNext()) {Running re = (Running)it.next();if (re.number <= min){min = re.number;r = re;}}MyFrame.this.list2.add(r);MyFrame.this.area2.append(r.getRecord());MyFrame.this.list1.remove(r);MyFrame.this.area1.setText(null);Iterator it1 = MyFrame.this.list1.iterator();while (it1.hasNext()) {Running re = (Running)it1.next();MyFrame.this.area1.append(re.getRecord());MyFrame.this.area1.append("\n");}}}});this.jb6.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {Iterator it2 = MyFrame.this.list2.iterator();if (!it2.hasNext()){int min = 1000;Running r = new Running(1, 1, "a", "b");Iterator it = MyFrame.this.list1.iterator();while (it.hasNext()) {Running re = (Running)it.next();if (re.i <= min){min = re.i;r = re;}}MyFrame.this.list2.add(r);MyFrame.this.area2.append(r.getRecord());MyFrame.this.list1.remove(r);MyFrame.this.area1.setText(null);Iterator it1 = MyFrame.this.list1.iterator();while (it1.hasNext()) {Running re = (Running)it1.next();MyFrame.this.area1.append(re.getRecord());MyFrame.this.area1.append("\n");}}}});this.jb3.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) {Iterator it3 = MyFrame.this.list2.iterator();Iterator aa = MyFrame.this.list1.iterator();while ((it3.hasNext() & aa.hasNext())){Running runn = (Running)it3.next();MyFrame.this.v.addElement(runn.getRecord());MyFrame.this.list.setListData(MyFrame.this.v);MyFrame.this.list.setVisibleRowCount(10);MyFrame.this.list2.remove(runn);MyFrame.this.area2.setText(null);Iterator it2 = MyFrame.this.list2.iterator();if (!it2.hasNext()){int min = 1000;Running r = new Running(1, 1, "a", "b");Iterator it = MyFrame.this.list1.iterator();while (it.hasNext()) {Running re = (Running)it.next();if (re.number <= min){min = re.number;r = re;}}MyFrame.this.list2.add(r);MyFrame.this.area2.append(r.getRecord());MyFrame.this.list1.remove(r);MyFrame.this.area1.setText(null);Iterator it1 = MyFrame.this.list1.iterator();while (it1.hasNext()) {Running re = (Running)it1.next();MyFrame.this.area1.append(re.getRecord());MyFrame.this.area1.append("\n");}}}}});this.jb4.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {String a = (String)MyFrame.this.list.getSelectedValue();MyFrame.this.v.remove(a);MyFrame.this.list.setListData(MyFrame.this.v);Running rr = new Running(MyFrame.this.minx++, Xchange.getThirdString(a), Xchange.getFirstString(a), Xchange.getSecondString(a));MyFrame.this.list1.add(rr);MyFrame.this.area1.setText(null);Iterator it = MyFrame.this.list1.iterator();while (it.hasNext()) {Running re = (Running)it.next();MyFrame.this.area1.append(re.getRecord());MyFrame.this.area1.append("\n");}}});add(this.jp5, "North");this.jp5.add(this.jb5);this.jp5.add(this.jl1);this.jp5.add(jt1);this.jp5.add(this.jl2);this.jp5.add(jt2);this.jp5.add(this.jl3);this.jp5.add(jt3);this.jb5.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){MyFrame.this.n = Integer.parseInt(MyFrame.jt3.getText());MyFrame.this.m = MyFrame.jt1.getText();MyFrame.this.s = MyFrame.jt2.getText();Running run = new Running(MyFrame.this.minx++, MyFrame.this.n, MyFrame.this.m, MyFrame.this.s);MyFrame.this.list1.add(run);MyFrame.this.area1.setText(null);MyFrame.jt1.setText(null);MyFrame.jt2.setText(null);MyFrame.jt3.setText(null);Iterator it = MyFrame.this.list1.iterator();while (it.hasNext()) {Running re = (Running)it.next();MyFrame.this.area1.append(re.getRecord());MyFrame.this.area1.append("\n");}}});setDefaultCloseOperation(3);setVisible(true);}}package tc;public class Running{int number;int i;String name;String id;public Running(int i, int n, String m, String s){this.i = i;this.number = n; = m;this.id = s;}public String getRecord(){String s = + " " + this.id + " " + this.number;return s;}}package tc;public class Xchange{public static String getFirstString(String d){char[] a = new char[50];char[] b = new char[50];char[] c = new char[50];char[] e = new char[50];int t = 0;int acount = 0;int bcount = 0;int ccount = 0;int ecount = 0;int is = 0;for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {a[(acount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {b[(bcount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {c[(ccount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {e[(ecount++)] = d.charAt(i); }}for (int i = 0; a[i] != 0; i++) {is = i + 1;}char[] ax = new char[is];for (int i = 0; i < is; i++) {ax[i] = a[i];}String as = new String(ax); return as;}public static String getSecondString(String d) { char[] a = new char[50];char[] b = new char[50];char[] c = new char[50];char[] e = new char[50];int t = 0;int acount = 0;int bcount = 0;int ccount = 0;int ecount = 0;int is = 0;for (int i = t; i < d.length(); i++) {if (d.charAt(i) != ' ') {a[(acount++)] = d.charAt(i);} else {t = i;break;}}for (int i = t; i < d.length(); i++) {if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {b[(bcount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {c[(ccount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {e[(ecount++)] = d.charAt(i); }}for (int i = 0; b[i] != 0; i++) {is = i + 1;}char[] bx = new char[is];for (int i = 0; i < is; i++) {bx[i] = b[i];}String bs = new String(bx);return bs;}public static int getThirdString(String d) { char[] a = new char[50];char[] b = new char[50];char[] c = new char[50];char[] e = new char[50];int t = 0;int acount = 0;int bcount = 0;int ccount = 0;int ecount = 0;int is = 0;for (int i = t; i < d.length(); i++) {if (d.charAt(i) != ' ') {a[(acount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {b[(bcount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) {if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) { if (d.charAt(i) != ' ') {c[(ccount++)] = d.charAt(i); } else {t = i;break;}}for (int i = t; i < d.length(); i++) { if (d.charAt(i) == ' ')continue;t = i;break;}for (int i = t; i < d.length(); i++) {if (d.charAt(i) != ' ') {e[(ecount++)] = d.charAt(i);}}for (int i = 0; c[i] != 0; i++) {is = i + 1;}char[] cx = new char[is];for (int i = 0; i < is; i++) {cx[i] = c[i];}String cs = new String(cx);int num = Integer.parseInt(cs);return num;}}。

java多级反馈队列调度代码实现

java多级反馈队列调度代码实现

标题:深入探讨Java多级反馈队列调度代码实现在计算机科学领域中,调度算法是一项重要的研究课题。

在操作系统中,多级反馈队列调度算法是一种常见的调度算法,它能够有效地管理系统资源,实现任务的合理分配和处理。

Java作为一种广泛应用的编程语言,在实现多级反馈队列调度算法方面具有独特的优势和灵活性。

在本文中,我将深入探讨Java多级反馈队列调度算法的实现方式,以及我个人对该主题的理解和观点。

1. 多级反馈队列调度算法概述多级反馈队列调度算法是一种基于时间片轮转的调度方法,它将系统中的任务分为多个子队列,并为每个队列分配不同的优先级。

任务按照优先级顺序执行,同时具有就绪状态的任务会进入相应的队列中等待执行。

当一个任务的时间片用完后,如果任务还未执行完,则会被放入下一个较低优先级的队列中继续等待执行。

2. Java实现多级反馈队列调度算法在Java中实现多级反馈队列调度算法,可以通过使用线程、队列和调度器等相关类和接口来完成。

需要创建多个队列来存储不同优先级的任务,然后使用线程来模拟任务的执行过程。

通过调度器来监控和管理不同队列中任务的执行顺序和时间片的分配,最终实现多级反馈队列调度算法的功能。

3. 个人观点和理解对于多级反馈队列调度算法的实现,我认为在Java中可以充分利用面向对象的特性和多线程的优势来完成。

通过创建任务类、队列类和调度器类等对象,可以更清晰地表达算法的逻辑和实现方式。

Java语言本身对于线程的支持和管理也能够很好地满足多级反馈队列调度算法的需求,使得实现起来更加灵活和高效。

总结回顾在本文中,我深入探讨了Java多级反馈队列调度算法的实现方式,通过分析算法的结构和逻辑,以及在Java语言中的具体实现方式,希望能够帮助读者更好地理解和掌握该调度算法。

通过本次撰写,我对Java多级反馈队列调度算法有了更深入的了解,并且对于在Java中实现该算法的方式和优势有了更清晰的认识。

我相信,在实际工作和项目中,能够更好地应用和运用这一调度算法,提高系统的效率和性能。

操作系统实验报告-批处理系统的作业调度

操作系统实验报告-批处理系统的作业调度
#include
#include
#include
#include
#include
#include
typedefcharstring[10];/*//定义string为含有10个字符元素的字符数组类型*/
structtask{
stringname;/*作业号*/
intarrtime;/*作业抵达时间*/
操作系统实验报告-批处理系统的作业调度
实验一批处理系统的作业调度
(1)加深对作业概念的理解。
(2)深入细致介绍批处理系统如何非政府作业、管理作业和调度作业。
编写程序完成批处理系统的作业调度,要求采用响应比优先调度算法。
最低积极响应比优先法(hrrn)就是对fcfs方式和sjf方式的一种综合均衡。hrrn调度策略同时考量每个作业的等待时间长短和估算须要的继续执行时间长短,从中挑选出积极响应比最低的作业资金投入继续执行。
printf("%9s%9d%9d%9d%9d%9d%9d\n",
jcb[i].name,jcb[i].arrtime,jcb[i].sertime,
jcb[i].begtime,jcb[i].fintime,jcb[i].turtime,jcb[i].wtutime);
voidcheck()
intstatime,endtime,sumturtime=0.0,sumwtutime=0.0,aveturtime,avewtutime;intcurrent=0,times=0,pre=0;
printf("-------------------------------------------------------------------------\n");

java作业调度

java作业调度

实验二、作业调度模拟程序一、实验目的(1)加深对作业调度算法的理解;(2)进行程序设计的训练。

二、实验内容和要求用高级语言编写一个或多个作业调度的模拟程序。

单道批处理系统的作业调度程序。

作业一投入运行,它就占有计算机的一切资源直到作业完成为止,因此调度作业时不必考虑它所需要的资源是否得到满足,它所运行的时间等因素。

作业调度算法;(1)采用先来先服务(FCFS)调度算法,即按作业到达的先后次序进行调度。

总是首先调度在系统中等待时间最长的作业。

(2)短作业优先(SJF) 调度算法,优先调度要求运行时间最短的作业。

(3)响应比高者优先(HRRN)调度算法,为每个作业设置一个优先权(响应比),调度之前先计算各作业的优先权,优先数高者优先调度。

RP (响应比)=作业周转时间/ 作业运行时间每个作业由一个作业控制块JCB表示,JCB可以包含以下信息:作业名、提交(到达)时间、所需的运行时间、所需的资源、作业状态、链指针等等作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种之一。

每个作业的最初状态都是等待W。

三、实验方法、步骤及结果测试(1)原理分析及流程图A.编程工具与文件本实验采用JA V A高级语言编写,用eclipse编程工具,原文件为Task.java ,生成文件有Task.class,统一放在Task包(文件夹)中。

B.流程图:单道FCFS算法:单道SJPF算法与单道HRRN算法的流程图与FCFS算法的基本一样,只是第二步中的调度顺序的算法不同,SJPF算法与HRRN算法第二步分别为:SJPF算法:调度执行时间最短的作业投入作业,并修改相应的指针,记录开始时间、完成时间等。

HRRN算法:调度后备队列中所有作业响应比高的作业投入作业,并修改相应指针,记录开始时间、完成时间等。

(2)详细程序代码及注释package Task;import java.awt.*;import javax.swing.*;import java.awt.event.*;import java.text.*;class JCB{String name;//进程名称String state="W";//进程状态int enterTimes ;int needTimes;//运行完所需要时间int costTimes;//已经使用时间int startTimes;}public class Task extends JApplet{private JLabel label_init = new JLabel("进程初始设置");private String[] process_name = {"001", "002", "003", "004", "005"}; //进程标签private JTextField[] field_needtime = new JTextField[5]; //需要时间设置框private JTextField[] field_entertime = new JTextField[5];//到达时间设置框private JLabel[] label_pname = new JLabel[5]; //进程名加载标签组 JCB[] jcb = new JCB[5];private JButton button_OK = new JButton("确定");private JButton button_init = new JButton("清空");private JLabel label_zhixing=new JLabel("正在执行");private JLabel label_houbei=new JLabel("后备队列");private JLabel[] field_txt = new JLabel[30]; //调度前信息显示框private JLabel label_after = new JLabel("算法调度"); //调度标签private JButton fcfs = new JButton("FCFS");private JButton sjpf = new JButton("SJPF");private JButton hrrn = new JButton("HRRN");private JLabel[] zhixing_txt = new JLabel[4];//当前执行记录private JLabel[] field_after = new JLabel[40]; //调度后信息显示框private JLabel label_name = new JLabel("进程名");private JLabel label_enter = new JLabel("到达时间");private JLabel label_need = new JLabel("要求服务时间");private JLabel label_start = new JLabel("开始时间");private JLabel label_cost = new JLabel("已用时间");private JLabel label_over = new JLabel("结束时间");private JLabel label_zhou = new JLabel("周转时间");private JLabel label_dzhou = new JLabel("带权周转时间");private JLabel label_n = new JLabel("进程名");private JLabel label_ne = new JLabel("要求服务时间");private JLabel label_e = new JLabel("到达时间");private JTextField foot = new JTextField();public Task() { //设置该类的构造器this.setBackground(Color.LIGHT_GRAY); //设置背景颜色}public void init() { //解决初始化问题JPanel panel_top = new JPanel();panel_top.setLayout(new GridLayout(1, 3));panel_top.add(label_init);for (int i = 0; i < 5; i++) {jcb[i] = new JCB();}JPanel panel_init = new JPanel();panel_init.setLayout(new GridLayout(3, 6));panel_init.add(label_n);for (int i = 0; i < process_name.length; i++) { //将进程名添加到panel label_pname[i] = new JLabel(process_name[i], JLabel.CENTER);label_pname[i].setForeground(Color.red);panel_init.add(label_pname[i]);}panel_init.add(label_ne); //要求服务时间for (int i = 0; i < 5; i++) {field_needtime[i] = new JTextField("");panel_init.add(field_needtime[i]);}panel_init.add(label_e); //到达时间for (int i = 0; i < 5; i++) {field_entertime[i] = new JTextField("");panel_init.add(field_entertime[i]);}JPanel panel_before = new JPanel();panel_before.add(button_OK);panel_before.add(button_init);button_OK.addActionListener(new InitJBC());button_init.addActionListener(new Clear());JPanel panel_1 = new JPanel();panel_1.setLayout(new BorderLayout());panel_1.add(panel_top, "North");panel_1.add(panel_init, "Center");panel_1.add(panel_before,"South");JPanel panel_houbeibiao = new JPanel();panel_houbeibiao.setLayout(new GridLayout(6, 5));panel_houbeibiao.add(new JLabel("进程名"));panel_houbeibiao.add(new JLabel("到达时间"));panel_houbeibiao.add(new JLabel("要求服务时间"));panel_houbeibiao.add(new JLabel("已用时间"));panel_houbeibiao.add(new JLabel("状态"));for (int j = 0; j < 25; j++) {field_txt[j] = new JLabel("");panel_houbeibiao.add(field_txt[j]);}JPanel panel_button = new JPanel();panel_button.setLayout(new GridLayout(1, 4, 10, 10)); panel_button.add(label_after);panel_button.add(fcfs);panel_button.add(sjpf);panel_button.add(hrrn);fcfs.addActionListener(new Fcfs());sjpf.addActionListener(new Sjf());hrrn.addActionListener(new Hrn());fcfs.setEnabled(false);sjpf.setEnabled(false);hrrn.setEnabled(false);fcfs.setToolTipText("先来先服务算法");sjpf.setToolTipText("段作业优先算法");hrrn.setToolTipText("最高响应比算法");JPanel panel_2 = new JPanel(new BorderLayout(2,2));panel_2.add(label_houbei,"North");panel_2.add(panel_houbeibiao, "Center");panel_2.add(panel_button,"South"); //后备表结束JPanel panel_zhixingbiao=new JPanel();panel_zhixingbiao.setLayout(new GridLayout(2,5));panel_zhixingbiao.add(new JLabel("进程名"));panel_zhixingbiao.add(new JLabel("到达时间"));panel_zhixingbiao.add(new JLabel("要求服务时间"));panel_zhixingbiao.add(new JLabel("状态"));panel_zhixingbiao.add(new JLabel("现在时间"));for (int j = 0; j <4 ; j++) {zhixing_txt[j] = new JLabel("");panel_zhixingbiao.add(zhixing_txt[j]);}JPanel panel_zhixing=new JPanel(new GridLayout(2,1)); panel_zhixing.add(label_zhixing,"North");panel_zhixing.add(panel_zhixingbiao,"Center");panel_zhixing.add(label_cost,"South");JPanel panel_lz = new JPanel();panel_lz.setLayout(new GridLayout(6, 8, 4, 4));panel_lz.add(label_name); //进程名panel_lz.add(label_enter); //到达时间panel_lz.add(label_need); //需要时间panel_lz.add(label_start); //开始时间panel_lz.add(label_over);//完成时间panel_lz.add(label_cost); //已用时间panel_lz.add(label_zhou); //周转时间panel_lz.add(label_dzhou);//带权周转时间for (int i = 0; i < 40; i++) {field_after[i] = new JLabel("");panel_lz.add(field_after[i]);}JPanel panel_3 = new JPanel(new BorderLayout());panel_3.add(panel_lz, "Center");panel_3.add(foot,"South");foot.setEnabled(false);foot.setDisabledTextColor(Color.red);/*布局整体结构*/JPanel panel11=new JPanel(new BorderLayout(2,1));//上面两个表的布局 panel11.add(panel_1,"North");panel11.add(panel_2,"South");JPanel panel22=new JPanel(new BorderLayout(2,1));panel22.add(panel_zhixing,"North");panel22.add(panel_3,"South");getContentPane().setLayout(new BorderLayout(5, 5));getContentPane().add(panel11, "North");getContentPane().add(panel22, "South");}class InitJBCimplements ActionListener {public void actionPerformed(ActionEvent e) {try{function();}catch(NumberFormatException e1){JOptionPane.showMessageDialog(null,"请输入正确的参数","error",JOptionPane.ERROR_MESSAGE);}fcfs.setEnabled(true);sjpf.setEnabled(true);hrrn.setEnabled(true);}}void function() throws NumberFormatException{for (int i = 0; i < 5; i++) {jcb[i].name = process_name[i];try{jcb[i].enterTimes =Integer.parseInt(field_entertime[i].getText());jcb[i].needTimes =Integer.parseInt(field_needtime[i].getText());}catch(NumberFormatException e){throw e;}}for (int j = 0, i = 0; j < 5; j++) {field_txt[i].setText(jcb[j].name);i++;field_txt[i].setText(String.valueOf(jcb[j].enterTimes)); i++;field_txt[i].setText(String.valueOf(jcb[j].needTimes)); i++;field_txt[i].setText(String.valueOf(jcb[j].costTimes)); i++;field_txt[i].setText(jcb[j].state);i++;}}class Clear implements ActionListener{public void actionPerformed(ActionEvent e){for (int i = 0; i < 5; i++) {jcb[i].costTimes=0;jcb[i].enterTimes=0;jcb[i].needTimes=0;jcb[i].startTimes=0;field_needtime[i].setText("");field_entertime[i].setText("");}for(int i=0;i<30;i++){field_txt[i].setText("");}for (int i = 0; i < 40; i++) {field_after[i].setText("");}fcfs.setEnabled(false);sjpf.setEnabled(false);hrrn.setEnabled(false);}}class Fcfsimplements ActionListener {public void actionPerformed(ActionEvent e) {try {sjpf.setEnabled(false);hrrn.setEnabled(false);use(1);sjpf.setEnabled(true);hrrn.setEnabled(true);}catch (Exception e1) {e1.getMessage();}}}class Sjfimplements ActionListener {public void actionPerformed(ActionEvent e) {try {fcfs.setEnabled(false);hrrn.setEnabled(false);use(2);fcfs.setEnabled(true);hrrn.setEnabled(true);}catch (Exception e1) {e1.getMessage();}}}class Hrn implements ActionListener{public void actionPerformed(ActionEvent e) {try {fcfs.setEnabled(false);sjpf.setEnabled(false);use(3);fcfs.setEnabled(true);sjpf.setEnabled(true);}catch (Exception e1) {e1.getMessage();}}}void use(int pram) throws ng.InterruptedException { int a[] = {0, 1, 2, 3, 4};int temp, n = 5, time = 0;int visit[]={0,0,0,0,0};int overtime=0;int k1=0;int min=0;boolean go=false;DecimalFormat df=new DecimalFormat("0.00");////////////////////////FCFS////////////////////////////////// if(pram==1){for(int j=0;j<5;j++){ temp=1000;for(int i=0;i<5;i++){if(temp>jcb[i].enterTimes&&visit[i]==0){k1=i;temp=jcb[i].enterTimes;}}visit[k1]=1;a[j]=k1;}}/////////////////////////SJPF//////////////////////////////////// if(pram==2){int k=0;double temp0=0;for(int m=0;m<5;m++){go=false;for(int i=0;i<5;i++){if(visit[i]==0){//visit[]用来标记jcb是否已经被排序if(temp0==0){if(overtime==0){for(int b=0;b<5;b++){//查找进入时间最短的短作业if(b==0){min=jcb[b].enterTimes;}if(min==jcb[b].enterTimes){if(jcb[k1].needTimes>jcb[b].needTimes){k1=b;}}if(min>jcb[b].enterTimes){min = jcb[b].enterTimes;k1=b;}}a[0]=k1;//因为overtime=0 所以将k1赋给a[0]表明第k1个作业最先运行visit[k1]=1;go=true;//go标志用来第一个作业与其他的作业overtime=jcb[k1].enterTimes+jcb[k1].needTimes;//overtime用来表示当前系统已经用了的时间break;}temp0=jcb[i].needTimes;//用needtime来比较谁优先k=i;}double x=jcb[i].needTimes;//找到时间最小的置换将作业号赋给kif(temp0>x&&jcb[i].enterTimes<overtime){temp0=x;k=i;}}}if(go==false){a[m]=k;visit[k]=1;if(overtime<jcb[k].enterTimes){//处理当前一个作业结束时,后面的作业还没有到的情况overtime = jcb[k].enterTimes + jcb[k].needTimes;}overtime = overtime + jcb[k].needTimes;//跟新overtimetemp0=0;}// run=run+need;}///////////////////////////HRRN//////////////////////////}if(pram==3){int k=0;double temp0=0;for(int m=0;m<5;m++){go=false;for(int i=0;i<5;i++){if(visit[i]==0){if(temp0==0){if(overtime==0){for(int b=0;b<5;b++){if(b==0){min=jcb[b].enterTimes;}if(min>jcb[b].enterTimes){min = jcb[b].enterTimes;k1=b;}}a[0]=k1;visit[k1]=1;go=true;overtime=jcb[k1].enterTimes+jcb[k1].needTimes;break;}temp0=(double)(overtime-jcb[i].enterTimes)/jcb[i].needTimes+1.0; k=i;}doublex=(double)(overtime-jcb[i].enterTimes)/jcb[i].needTimes+1.0;if(temp0<x){temp0=x;k=i;}}}if(go==false){a[m]=k;visit[k]=1;if(temp0-1.0<0){//处理当前一个作业结束时,后面的作业还没有到的情况 overtime = jcb[k].enterTimes + jcb[k].needTimes;}overtime = overtime + jcb[k].needTimes;temp0=0;}// run=run+need;}}double total_zhou=0;double total_dzhou=0;for (int j = 0, i = 0; j < 5; j++) {field_after[i].setText(jcb[a[j]].name);i++;field_after[i].setText(String.valueOf(jcb[a[j]].enterTimes));i++;field_after[i].setText(String.valueOf(jcb[a[j]].needTimes));i++;if (j == 0) {jcb[a[j]].startTimes = jcb[a[j]].enterTimes;field_after[i].setText(String.valueOf(jcb[a[j]].startTimes)); i++;}else {if(jcb[a[j - 1]].startTimes +jcb[a[j-1]].needTimes>jcb[a[j]].enterTimes)jcb[a[j]].startTimes = jcb[a[j - 1]].startTimes +jcb[a[j-1]].needTimes;elsejcb[a[j]].startTimes=jcb[a[j]].enterTimes;field_after[i].setText(String.valueOf(jcb[a[j]].startTimes)); i++;}field_after[i].setText(String.valueOf(jcb[a[j]].startTimes +jcb[a[j]].needTimes)); i++;field_after[i].setText(String.valueOf(jcb[a[j]].needTimes));i++;int overtime1 = jcb[a[j]].startTimes + jcb[a[j]].needTimes - jcb[a[j]].enterTimes;total_zhou=total_zhou+overtime1;field_after[i].setText(String.valueOf(overtime1)); i++;total_dzhou=(double)overtime1/jcb[a[j]].needTimes + total_dzhou;field_after[i].setText(String.valueOf( df.format((double)overtime1/jc b[a[j]].needTimes))); i++;}foot.setText("作业平均周转时间为"+String.valueOf(df.format(total_zhou/5))+" 作业平均带权周转时间为"+String.valueOf(df.format(total_dzhou/5)));}public static void main(String [] args){JApplet applet=new Task();JFrame frame = new JFrame("daniel");frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.getContentPane().add(applet);frame.setVisible(true);}}(3)运行结果及分析a.作业调度程序运行后初始状态如下图2-1;b.输入测试数据后确定,数据进入队列,并激活FCFS、SJPF、HRRN三个按键,如下图2-2;c. 点击FCFS,进行FCFS算法作业调度,结果如下图2-3;d. 点击SJPF,进行SJPF算法作业调度,结果如下图2-3;e. 点击HRRH,进行HRRH算法作业调度,结果如下图2-3;四、实验总结此次实验比较有挑战性,此次实验我依然选择了JA V A语言,在开始作这个实验时,有点不知从何入手,但经过参考了老师与网上的例子,虽然大多都是C语言的例子,但我反复的琢磨了很久,慢慢的消化了C语言中的思路,从中找到了突破口,从而进行以上的编写。

分支限界法解批处理作业调度问题java

分支限界法解批处理作业调度问题java

作业调度问题是指在多道程序系统中,根据各道程序的特点和系统的资源状况,合理地安排各道程序的执行顺序。

而分支限界法是一种解决排列、组合、0-1背包等问题的常用技术,可以有效地解决作业调度问题。

本文将结合Java语言,介绍如何使用分支限界法来解决作业调度问题。

一、作业调度问题的基本概念1. 作业调度问题的定义作业调度是指计算机系统对各种作业的安排和分配,以便使计算机系统有效地利用资源,提高各类作业的完成时间和各项资源的利用率。

2. 作业调度问题的类型作业调度问题主要分为单机调度和并行机调度两种类型。

其中单机调度是指一个作业在一台机器上进行处理,而并行机调度是指多个作业在多台机器上进行处理。

3. 作业调度问题的目标作业调度问题的主要目标是减少作业的等待时间,提高系统吞吐量,提高资源利用率,减少作业的周转时间等。

二、分支限界法的基本原理1. 分支限界法的概念分支限界法是一种剪枝技术,通过遍历搜索所有可能的解空间,并在搜索过程中剪掉某些明显不可能得到最优解的分支,从而有效地降低了搜索空间的规模。

2. 分支限界法的特点分支限界法在搜索过程中,通过剪枝操作,能够大大降低搜索空间的规模,提高搜索效率。

在解决NP难问题时,分支限界法通常能够得到较为满意的解。

3. 分支限界法的应用分支限界法被广泛应用于排列、组合、0-1背包、作业调度等各种组合优化问题的求解过程中,具有较高的实用性和效率。

三、分支限界法解决作业调度问题的具体步骤1. 确定问题的数学模型需要将作业调度问题转化为数学模型,例如采用Gantt图或者某种数学表达形式来描述作业的调度顺序和资源分配情况。

2. 设计合适的状态空间树根据问题的特点,设计合适的状态空间树来表示各种可能的作业调度方案,并利用分支限界法进行搜索。

3. 利用分支限界法进行搜索对设计好的状态空间树进行搜索,通过适当的剪枝操作,降低搜索空间的规模,提高搜索效率,直到找到最优解或者满意解为止。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
FlowShop fs=new FlowShop();
fs.ShowTest();
}
}
MyMath类
public class MyMath {
public void MyMath(){}
public static int[] swap(int[] x,int i,int j)
{
int ex;
ex=x[j];
f+=f2[i];
if(f<bestf)
{
MyMath.swap(x,i,j);
backtrack(i+1);
MyMath.swap(x,i,j);
}
f1-=m[x[j]][0];
f-=f2[i];
}
}
public void ShowTest()
{
n=3;
bestf=Integer.MAX_VALUE;
static int []bestx; //当前最优作业调度;
static int []f2; //机器2完成处理时间;
private void backtrack(int i)
{
if(i>n)
{
for (int j=1;j<=n;j++)
{
bestx[j]=x[j];
System.out.print(x[j]+" ");
System.out.println("当前最优值:"+bestf);
System.out.println("当前最优作业调度");
for(int i=1;i<=n;i++)
{
System.out.print(bestx[i]+" ");
}
}
public static void main(String[] args)
2 4 3 1 5
每条深度优先搜索结果为:77
2 4 1 3 5
每条深度优先搜索结果为:76
当前最优值:76
当前最优作业调度
2 4 1 3 5
代码
FlowShop类
public class FlowShop
{
static int n, //作业数;
f1, //机器1完成处理时间;
f,ห้องสมุดไป่ตู้//完成时间和;
bestf; //当前最优值;
static int [][]m; //各作业所需的处理时间;
static int []x; //当前作业调度;
x[j]=x[i];
x[i]=ex;
return x;
}
}
运行结果
当有三个作业,它们在机器一和机器二上的时间分别需要{{2,1},{3,1},{2,3}}时,运行结果为
1 2 3
每条深度优先搜索结果为:19
1 3 2
每条深度优先搜索结果为:18
当前最优值:18
当前最优作业调度
13 2
当有五个作业,它们在机器一和机器二上的时间分别需要{{6,4},{1,4},{3,7}{4,5}{8,2}}时,运行结果为
f1=0;
f=0;
int [][]m={{0,0},{2,1},{3,1},{2,3}};
int []x={0,1,2,3};
int []bestx={0,1,2,3};
f2=new int[4];
this.m = m;
this.x=x;
this.bestx=bestx;
this.f2=f2;
backtrack(1);
1 2 3 4 5
每条深度优先搜索结果为:99
1 2 3 5 4
每条深度优先搜索结果为:96
1 2 4 5 3
每条深度优先搜索结果为:93
2 1 3 4 5
每条深度优先搜索结果为:82
2 1 3 5 4
每条深度优先搜索结果为:81
2 1 4 3 5
每条深度优先搜索结果为:80
2 3 1 4 5
每条深度优先搜索结果为:78
}
System.out.println();
bestf=f;
System.out.println("每条深度优先搜索结果为:"+bestf);
}
else
for(int j=i;j<=n;j++)
{
f1+=m[x[j]][0];
f2[i]=((f2[i-1]>f1)? f2[i-1]:f1)+m[x[j]][1];
相关文档
最新文档