作业批处理调度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用法(原创实用版)目录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框架提供的一个批处理任务调度组件,可以用于实现定时调度任务的执行。
以下是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 写的源代码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多级反馈队列调度算法的实现方式,以及我个人对该主题的理解和观点。
1. 多级反馈队列调度算法概述多级反馈队列调度算法是一种基于时间片轮转的调度方法,它将系统中的任务分为多个子队列,并为每个队列分配不同的优先级。
任务按照优先级顺序执行,同时具有就绪状态的任务会进入相应的队列中等待执行。
当一个任务的时间片用完后,如果任务还未执行完,则会被放入下一个较低优先级的队列中继续等待执行。
2. Java实现多级反馈队列调度算法在Java中实现多级反馈队列调度算法,可以通过使用线程、队列和调度器等相关类和接口来完成。
需要创建多个队列来存储不同优先级的任务,然后使用线程来模拟任务的执行过程。
通过调度器来监控和管理不同队列中任务的执行顺序和时间片的分配,最终实现多级反馈队列调度算法的功能。
3. 个人观点和理解对于多级反馈队列调度算法的实现,我认为在Java中可以充分利用面向对象的特性和多线程的优势来完成。
通过创建任务类、队列类和调度器类等对象,可以更清晰地表达算法的逻辑和实现方式。
Java语言本身对于线程的支持和管理也能够很好地满足多级反馈队列调度算法的需求,使得实现起来更加灵活和高效。
总结回顾在本文中,我深入探讨了Java多级反馈队列调度算法的实现方式,通过分析算法的结构和逻辑,以及在Java语言中的具体实现方式,希望能够帮助读者更好地理解和掌握该调度算法。
通过本次撰写,我对Java多级反馈队列调度算法有了更深入的了解,并且对于在Java中实现该算法的方式和优势有了更清晰的认识。
我相信,在实际工作和项目中,能够更好地应用和运用这一调度算法,提高系统的效率和性能。
操作系统实验报告-批处理系统的作业调度
#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作业调度
实验二、作业调度模拟程序一、实验目的(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
作业调度问题是指在多道程序系统中,根据各道程序的特点和系统的资源状况,合理地安排各道程序的执行顺序。
而分支限界法是一种解决排列、组合、0-1背包等问题的常用技术,可以有效地解决作业调度问题。
本文将结合Java语言,介绍如何使用分支限界法来解决作业调度问题。
一、作业调度问题的基本概念1. 作业调度问题的定义作业调度是指计算机系统对各种作业的安排和分配,以便使计算机系统有效地利用资源,提高各类作业的完成时间和各项资源的利用率。
2. 作业调度问题的类型作业调度问题主要分为单机调度和并行机调度两种类型。
其中单机调度是指一个作业在一台机器上进行处理,而并行机调度是指多个作业在多台机器上进行处理。
3. 作业调度问题的目标作业调度问题的主要目标是减少作业的等待时间,提高系统吞吐量,提高资源利用率,减少作业的周转时间等。
二、分支限界法的基本原理1. 分支限界法的概念分支限界法是一种剪枝技术,通过遍历搜索所有可能的解空间,并在搜索过程中剪掉某些明显不可能得到最优解的分支,从而有效地降低了搜索空间的规模。
2. 分支限界法的特点分支限界法在搜索过程中,通过剪枝操作,能够大大降低搜索空间的规模,提高搜索效率。
在解决NP难问题时,分支限界法通常能够得到较为满意的解。
3. 分支限界法的应用分支限界法被广泛应用于排列、组合、0-1背包、作业调度等各种组合优化问题的求解过程中,具有较高的实用性和效率。
三、分支限界法解决作业调度问题的具体步骤1. 确定问题的数学模型需要将作业调度问题转化为数学模型,例如采用Gantt图或者某种数学表达形式来描述作业的调度顺序和资源分配情况。
2. 设计合适的状态空间树根据问题的特点,设计合适的状态空间树来表示各种可能的作业调度方案,并利用分支限界法进行搜索。
3. 利用分支限界法进行搜索对设计好的状态空间树进行搜索,通过适当的剪枝操作,降低搜索空间的规模,提高搜索效率,直到找到最优解或者满意解为止。
批处理任务表设计 java
批处理任务表设计java设计批处理任务表的Java 程序涉及到数据库的操作、任务调度、以及可能的多线程处理。
下面是一个简单的批处理任务表设计的Java 代码示例,使用了JDBC 连接数据库,并结合Quartz Scheduler 进行任务调度。
在示例中,我们将使用MySQL 数据库作为例子,你需要根据你的实际情况修改数据库连接信息。
import org.quartz.*;import org.quartz.impl.StdSchedulerFactory;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.time.LocalDateTime;public class BatchTaskScheduler {public static void main(String[] args) throws SchedulerException {// 初始化调度器Scheduler scheduler =StdSchedulerFactory.getDefaultScheduler();scheduler.start();// 从数据库获取批处理任务列表try (Connection connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/your_databa se", "your_username", "your_password")) {String query = "SELECT * FROM batch_tasks";try (PreparedStatement preparedStatement = connection.prepareStatement(query)) {ResultSet resultSet =preparedStatement.executeQuery();while (resultSet.next()) {// 从数据库中读取任务信息String taskId = resultSet.getString("task_id");String taskName =resultSet.getString("task_name");String cronExpression =resultSet.getString("cron_expression");// 创建任务JobDetail job =JobBuilder.newJob(BatchTaskJob.class).withIdentity(taskId, "batchTasks").usingJobData("taskName", taskName).build();// 创建触发器Trigger trigger = TriggerBuilder.newTrigger().withIdentity(taskId + "Trigger", "batchTasks").withSchedule(CronScheduleBuilder.cr onSchedule(cronExpression)).build();// 将任务和触发器加入调度器scheduler.scheduleJob(job, trigger);}}} catch (Exception e) {e.printStackTrace();}}}class BatchTaskJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {// 获取任务数据JobDataMap dataMap =jobExecutionContext.getJobDetail().getJobDataMap();String taskName = dataMap.getString("taskName");// 执行批处理任务System.out.println("Executing batch task: " + taskName + " at " + LocalDateTime.now());// 此处可以添加具体的批处理任务逻辑}}在这个示例中,我们使用Quartz Scheduler 进行任务调度,通过JDBC 连接数据库读取批处理任务表的信息,并创建相应的任务和触发器。
批处理系统中的作业调度
批处理系统中作业调度(2008-06-02 10:40:34) 转载标签:学习操作系统代码文化批处理系统中作业调度:#include"stdlib.h"#include"string.h"#include"iostream.h" typedef struct cj {char name[6];int length;int printer;int tape;int runtime;int waittime;struct cj *next;}cj;cj *head;int tape,printer;long memory;void shedule(){float xk,k;cj *p,*q,*s,*t;do{p=head;q=s=NULL;k=0;while(p!=NULL){if(p->length<=memory&&p->tape<=tape&&p->printer<=printer) {xk=(float)(p->waittime)/p->runtime;if(q==NULL||xk>k){k=xk;q=p;t=s;}}s=p;p=p->next;}if(q!=NULL){if(t==NULL)head=head->next;elset->next=q->next;memory=memory-q->length;tape=tape-q->tape;printer=printer-q->printer;cout<<"选中作业的作业名:"<<q->name<<"\n";}}while(q!=NULL);}void main(){int size,tcount,pcount,wtime,rtime;char name[6];cj *p;memory=65536;printer=2;tape=4;head=NULL;cout<<"输入作业相关数据(以作业大小为负数停止输入):\n";cout<<"输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"; cin>>name>>size>>tcount>>pcount>>wtime>>rtime;while(size!=-1){p=(cj*)malloc(sizeof(cj));strcpy(p->name,name);p->length=size;p->printer=pcount;p->tape=tcount;p->runtime=rtime;p->waittime=wtime;p->next=head;head=p;cout<<"输入作业名、作业大小、磁带机数、打印机数、等待时间、估计执行时间\n"; cin>>name>>size>>tcount>>pcount>>wtime>>rtime;}shedule();}操作系统批处理系统的作业调度模拟2007-01-16 07:15 P.M.花了一天半的时间才编好~~希望对有这个需要的朋友能用的上!声明一下~我是用win tc编写的,如果用tc的话可能有时会无法运行,原因我还没弄清楚。
批处理系统的作业调度
批处理系统的作业调度一、实验目的1.加深对作业概念的理解。
2.深入了解批处理系统如何组织作业、管理作业和调度作业。
二、实验预备知识1.作业的概念。
2.作业的创建。
3.作业的调度。
三、实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业控制块的内容,作业控制块的组成方式;然后完成作业调度;最后编写主函数对所做工作进行测试。
四、提示与讲解操作系统根据允许并行工作的道数和一定的算法从系统中选取若干作业把它们装入主存储器,使它们有机会获得处理器运行,这项工作被称为“作业调度”。
实现这部分功能的程序就是“作业调度程序”。
作业调度的实现主要有两个问题,一个是如何将系统中的作业组织起来;另一个是如何进行作业调度。
为了将系统中的作业组织起来,需要为每个进入系统的作业建立档案以记录和作业相关的信息,例如作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息存储器中的位置、指向下一个作业控制块的指针等信息。
这个记录作业相关信息的数据块称为作业控制块(JCB),并将系统中等待作业调度的作业控制块组织成一个队列,这个队列称为后备队列。
一个作业全部信息进入系统后,就为其建立作业控制块,并挂入后备队列。
当进行作业调度时,从后备队列中查找选择作业。
由于实验中没有实际作业,作业控制块中的信息内容只使用了实验中需要的数据。
作业控制块中首先应该包括作业名;其次是作业所需资源,根据需要,实验中只包括需要主存的大小(采用可移动的动态分区方式管理主存,作业大小就是需要主存的大小)、需要打印机的数量和需要磁带机的数量;采用响应比作业调度算法,为了计算响应比,还需要有作业的估计执行时间、作业在系统中的等待时间;另外,指向下一个作业控制块的指针必不可少。
实验中,作业控制块及队列的数据结构定义如下:typedef struct jcb {char name[4]; //作业名int length; //作业长度,所需主存大小int printer; //作业执行所需打印机的数量int tape; //作业所需磁带机的数量int runtime; //作业估计执行时间int waittime; 作业在系统中的等待时间int next; //指向下一个作业控制块的指针}JCB //作业控制块类型定义存放作业控制块的区域:define n 10 //假定系统中可容纳的作业数量为nJCB jobtable[10]; //作业表int jobcount ; //系统内现有作业数量将作业控制块组织成一个队列,实验中采用静态链表的方式模拟作业的后备队列,如下图所示。
操作系统实验-CPU进程调度和内存分配_java版
操作系统实验第一期项目开发实现实验名称EXP.1 CPU SchedulingExp.2 Allocation & Reclaim实验内容一,选择一个调度算法,实现处理机调度;二,处理机调度过程中,主存储器空间的分配和回收;实验目的一,多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机。
本实验模拟实现处理机调度,以加深了解处理机调度的工作;二,帮助了解在不同的存储管理方式下,应怎样实现主存空间的分配和回收;实验题目一,(1)设计一个按照优先权调度算法实现处理机调度的程序;(2)设计按时间片轮转实现处理机调度的程序;二,在可变分区管理方式下,采用最先适应算法实现主存空间的分配和回收;实验要求一,(a),PCB内容:进程名/PID;要求运行时间(单位时间);优先权;状态;PCB 指针;——(因课程内容原因,这个指针在设计中没用)1,可随机输入若干进程,并按优先权排序;2,从就绪队列首选进程运行:优先权-1/ 要求运行时间-1;要求运行时间=0时,撤销该进程;3,重新排序,进行下一轮调度;(b),最好采用图形界面;(c),可随时增加进程;(d),规定道数,设置后备队列和挂起状态。
若内存中进程数少于规定道数,可自动从后备队列调度一作业进入。
被挂起进程如=入挂起队列,设置解挂功能用于将指定挂起进程解挂入就绪队列;(e),每次调度后,显示各进程状态;二,(a),自行假设主存空间大小,预设操作系统所占大小并构造未分分区表;表目内容:起址、长度、状态(未分/空表目)(b),结合实验一,PCB增加为:{PID,要求运行时间,优先权,状态,所需内存大小,主存起始位置,PCB指针(失效)};(C)采用最先适应算法分配主存空间;(D),进程完成后,回收主存,并与相邻空闲分区合并;实验过程及分析1,初步设计:2,详细设计:(a),操作系统知识回顾:(1)作业进入内存中,由CPU分配产生PCB属性,并通过PCB记录进程状态,实验即以PCB代表进程模拟调度过程;(2)在多道系统中,多道系统中,当就绪进程数大于处理机数时,须按照某种策略决定哪些进程优先占用处理机,本实验采用优先级;(3),进程调度时,规定若就绪队列进程数少于6个,则自动从后备队列调入一个作业;(4),系统会将占有较多资源、预期结果不符合要求的进程自动挂起,并回收所占资源,而本实验设置为手动挂起;(5),在适宜条件下,系统会将挂起的进程自动解挂,而且只解挂到就绪队列;本实验为简化操作,设置为手动解挂,若解挂条件合适(即CPU各种资源可用),则解挂到就绪队列,并分配内存;若解挂条件不适宜,则解挂至后备队列,但不分配内存(实际上这是不对的,因为作业进入内存,由CPU标记PCB后,不能撤销PCB再返回内存,除非该进程执行结束,但本程序为体现解挂的意思,还是错误地设计为可以解挂到后备队列,读者需注意,这个功能可以在代码中注销,另外也希望有高手可以改进);(b),实验程序设计:(1),本实验采用java语言编程,并实现GUI界面显示;(2),为体现java语言面对对象程序设计的特点,实验设计为ProcessPCB、MemoryItem类封装PCB和所分配的内存各自的属性与方法;用ProcessRecords、MemoryRecords类封装数组方法;用SingleCPUScheduling实现GUI界面显示;(3),ProcessPCB类中,定义PCB的进程名、要求运行时间、优先级、状态、主存起始位置、所需内存大小这6个属性,并定义各属性的get和set方法,定义equals 方法用于对比类的属性,定义toString方法得到类属性的字符串,定义run方法封装优先权-1/ 要求运行时间-1的过程;MemoryItem类中,定义可分分区表每一可分记录的主存起始位置、内存大小及其get和set方法,定义toString方法得到可在界面显示的字符串;(4),ProcessRecords封装PCB数组的添加元素addItem和删除元素removeItem 方法,并构造函数getItem通过参数ProcessPCB和String查找数组元素,定义getNumberOfItems取数组大小,定义getItemsPriorities方法取所有数组元素的toString方法用于界面显示,定义iterator方法取得数组的迭代器;MemoryItem类中,定义Memory的内存起始位置和所需内存大小、、、、、、(5),MemoryRecords用同样的设计思想封装以MemoryItem为数组元素的各属性和方法;(6)SingleCPUScheduling类继承JFrame类,实现界面化显示;与上面相对应,实例化ProcessRecords(3次)和MemoryRecords(1次)作为私有变量,分别作为后备队列、就绪队列、挂起队列和内存可分分区表;在界面设计中,设计后备队列、挂起队列(附带解挂umount按钮)、就绪队列(附带挂起suspend按钮)可分分区表列表显示框,设置PCB添加框,附带添加至后备队列(addToBackup)、添加至就绪队列(addToReady)按钮,以及CPU当前执行状态显示框、系统日志显示框,和开始调度(systemStart)按钮,优先级和时间片单选按钮,以及时间片显示标签和文本编辑框;(7)界面设计详解;后备队列显示框用于显示已添加至后备队列的ProcessRecords 属性信息,其中主存起始位置默认为-1,表示未分配;挂起队列显示框用于显示从就绪队列挂起的PCB,其中属性“主存起始位置”(MemoryBase)将由非负数变为-1,表示挂起后收回内存;就绪队列显示框中显示就绪队列属性,其中“主存起始位置”均为非负,表示一分配内存;PCB信息添加框分列PCB6个属性显示标签和可编辑文本框,和添加按钮,用于添加PCB;系统日志显示框附属时间片显示标签和可编辑文本编辑框,可由用户决定时间片大小;对于实验一,界面如下:以上由SingleCPUScheduling001.java(另需ProcessPCB.java和PCBRdecords.java)(8)附属功能添加完善;最重要的是为程序添加线程,使程序能以停顿一段时间的频率自动运行;后备队列、挂起队列添加total显示标签和不可编辑文本显示框,用于显示各自数组中元素数目,挂起队列附属删除(remove)按钮,可删除挂起队列中的元素;后备、挂起、就绪队列均添加监听器,用于响应用户单击操作,可以在PCB信息添加框显示用户单击的那一条PCB的信息;PCB信息添加框附属reset按钮,用于一键清空信息框中信息,方便输入;系统日志面板附属系统暂停(systemPause)和系统重置(systemReset)按钮,分别用于暂停运行(方便用户观察当前运行结果)和重置系统(方便用户重复使用程序,免去关闭后重启本程序的麻烦);最终界面如图:实验结果报告级分析1,程序完成了实验所有的基本要求;2,本程序还存在一些技术上的问题,使得程序不能尽善尽美;如,PCB信息添加框没有“随机置入就绪队列”功能,添加PCB信息仍显得繁琐;就绪队列的挂起功能在程序自动运行时,存在反应异常(反应延迟或直接无反映);可分分区表只显示了当前可分的内存,没有显示已分的PCB及其对应内存使用情况,且没有利用图形和丰富的颜色来更好的展示;时间片设计还需要改进,使用效率不高;系统重置功能存在响应延迟的问题;另外,界面不够美观;还需要不断改进;实验感想通过这次实验,我对操作系统的进程调度和内存分配管理有了更加深入的了解,对操作系统内部的工作原理有了进一步的认识;通过编程,也巩固了我的程序设计和代码编写的能力,实验过程中遇到的各种问题以及解决问题的过程与方法,都是我获益匪浅;同时,程序的不完善,也将促使我在课程之后,继续学习、理解课程内容,并尽一切努力不断完善程序,做到尽善尽美;程序代码完整版(初学java,菜鸟级别,当然是将所学的全部照办照抄,实为臃肿,可为初学者引以为戒,注意代码质量!)这里谨贴出十分臃肿的代码,仅供初学者交流经验,重在开发的思想,了解开发的流程,而01版(精简版)代码在后面;ProcessPCB.javapackage src;public class ProcessPCB {// backupBAK 后备 ready 就绪 suspend 挂起 memory内存private String PID;private int RequiredTime;// private String Priority;private int Priority;private String Status;private int MwmoryBase = 0000;private int MemoryLimit;// private String PCBPointer;public ProcessPCB(String initpID, int initRTime, int initpriority, String status, int initBase, int initLimit) {this.PID = initpID;this.RequiredTime = initRTime;this.Priority = initpriority;this.Status = status;this.MwmoryBase = initBase;this.MemoryLimit = initLimit;}public String getPID() {if(this.PID == null)return " ";elsereturn this.PID;}public void setPID(String pid) {if(pid == null)this.PID = " ";elsethis.PID = pid;}public int getRequiredTime() {return this.RequiredTime;}public void setRequiredTime(int time) {this.RequiredTime = time;}public int getPriority() {return this.Priority;}public void setPriority(int priority) {this.Priority = priority;}public String getStatus() {if(this.Status == null)return" ";elsereturn this.Status;}public void setStatues(String statues) {if(statues == null)this.Status = " ";elsethis.Status = statues;}public int getMemoryBase() {return this.MwmoryBase;}public void setMemoryBase(int base) {this.MwmoryBase = base;}public int getMemoryLimit() {return this.MemoryLimit;}public void setMemoryLimit(int limit) {this.MemoryLimit = limit;}public boolean equals(ProcessPCB pcb) {if(pcb.getPID() == this.getPID()) {return true;}else return false;}public String toString() {return this.getPID() + "_" + this.getRequiredTime() + "_" + this.getPriority() + "_"+ this.getStatus() + "_" + this.getMemoryBase() + "_" + this.getMemoryLimit() + "\n";public void run() {this.RequiredTime = this.RequiredTime-1;this.Priority = this.Priority-1;}}MemoryItem.javapackage src;public class MemoryItem {private int memoryBase=0;private int memoryLimit=0;private int availableStatus=0;public MemoryItem(int initMemoryBase, int initMemoryLimit) { this.memoryBase = initMemoryBase;this.memoryLimit = initMemoryLimit;}public int getMemoryBase() {return this.memoryBase;}public void setMemoryBase(int base) {this.memoryBase = base;}public int getMemoryLimit() {return this.memoryLimit;}public void setMemoryLimit(int limit) {this.memoryLimit = limit;}public int getStatus() {return this.availableStatus;}public void setStatus(int status) {this.memoryBase = status;}public String toString() {return this.getMemoryBase() + "_" + this.getMemoryLimit() + "\n";}}PCBRecords.javapackage src;import java.util.ArrayList;import java.util.Iterator;public class PCBRecords implements Iterable<ProcessPCB> { private ArrayList<ProcessPCB> PCBItems;public ArrayList<ProcessPCB> getPCBItems() {return this.PCBItems;}public PCBRecords() {this.PCBItems = new ArrayList<ProcessPCB>();}public void addItem(ProcessPCB PcbItem) {this.PCBItems.add(PcbItem);}public void removeItem(ProcessPCB PCbItem) {this.PCBItems.remove(PCbItem);}public ProcessPCB getItem(ProcessPCB processPCB) {for (ProcessPCB pCbItem : this.PCBItems) {if (pCbItem.equals(processPCB)) {return pCbItem;}}return null;}public ProcessPCB getItem(String pid) {for (ProcessPCB pcBItem : this.PCBItems) {if (pcBItem.getPID().equals(pid)) {return pcBItem;}}return null;}public int getNumberOfItems() {return this.PCBItems.size();}public String[] getItemsProperties() {String itemsProperties[] = new String[getNumberOfItems()];int i = 0;for(Iterator iterator1 = PCBItems.iterator(); iterator1.hasNext();){ProcessPCB stu_Item = (ProcessPCB)iterator1.next();itemsProperties[i++] = stu_Item.toString();}return itemsProperties;}public Iterator<ProcessPCB> iterator() {return this.PCBItems.iterator();}}MemoryRecords.javapackage src;import java.util.ArrayList;import java.util.Iterator;public class MemoryRecords implements Iterable<MemoryItem> { private ArrayList<MemoryItem> memoryItems;public Iterator<MemoryItem> iterator() {// TODO Auto-generated method stubreturn this.memoryItems.iterator();}public ArrayList<MemoryItem> getMemoryItems() { return this.memoryItems;}public MemoryRecords() {this.memoryItems = new ArrayList<MemoryItem>();}public void addItem(MemoryItem newMemoryItem) { this.memoryItems.add(newMemoryItem);}public void removeItem(MemoryItem momoryItem) { this.memoryItems.remove(momoryItem);}public MemoryItem getMomoryItem(MemoryItem item) { for(MemoryItem mItem : this.memoryItems) {if(mItem.equals(item)) {return mItem;}}return null;}public MemoryItem getMemoryItem(int base) {for(MemoryItem mItem : this.memoryItems) {if(mItem.getMemoryBase() == base) {return mItem;}}return null;}public int getNumberOfItems() {return this.memoryItems.size();}public String[] getItemsProperties() {String itemsProperties[] = new String[getNumberOfItems()];int i=0;for(Iterator iterator1 = this.memoryItems.iterator(); iterator1.hasNext(); ) {MemoryItem mmItem = (MemoryItem) iterator1.next();itemsProperties[i++] = mmItem.toString();//????}//System.out.println(itemsProperties + "\n");if(itemsProperties == null) {itemsProperties[0] = " ";}return itemsProperties;}}SingleCPUSchedulingGUI001.Javaimport java.util.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;import javax.swing.event.*;import src.SingleCPUSchedulingGUI001.AddToBAKListener;import src.SingleCPUSchedulingGUI001.AddToReadyListener;import src.SingleCPUSchedulingGUI001.RemoveListener;import src.SingleCPUSchedulingGUI001.ResetListener;import src.SingleCPUSchedulingGUI001.ResetSystemListener;import src.SingleCPUSchedulingGUI001.StartSystemListener;import src.SingleCPUSchedulingGUI001.SuspendListener;import src.SingleCPUSchedulingGUI001.SystemPauseListener;import src.SingleCPUSchedulingGUI001.UmountListener;import src.SingleCPUSchedulingGUI001.priotiryListener;import src.SingleCPUSchedulingGUI001.timeslicListener;import java.io.*;import java.text.*;public class SingleCPUSchedulingGUI001 extends JFrame {private int systemStatues; //注意static 属性/*define 0--system prepare status--system reset and re-prepare 1--system start 2--system pause 3--system stop*//* Standar error stream */static private PrintWriter stdErr = new PrintWriter(System.err, true);static private int WIDTH = 600, HEIGHT = 700; // the size of the Frame 主面板/* 各列表对应的面板规格*//* 对应各名词释义backupBAK 后备ready 就绪suspend 挂起memory内存*/ static private int BackupBAK_CELL_SIZE = 250, BackupBAK_LIST_ROWS = 10; //后备队列static private int Suspend_CELL_SIZE = 250, Suspend_LIST_ROWS = 10; //挂起队列static private int Ready_CELL_SIZE = 200, Ready_LIST_ROWS = 6; //就绪队列static private int CPU_ROWS = 10, CPU_COLS = 22; //CPU面板static private int STATUS_ROWS = 8, STATUS_COLS = 30; //系统状态面板private int timeslice = 1; //设置时间片大小private int systemStatus=0; //设置系统状态0——系统预备状态,等待开始,1——系统运行状态,2——系统暂停状态static private int TOTAL__TEXTFIELD_SIZE = 10; // Size total text field 记录各队列元素个数private JList backupList, suspendList, readyList; //各队列相对应的数组列表// 进程添加框中的"添加至后备队列","添加至就绪队列","重置"Buttonprivate JButton addToBAKButton, addToReadyButton, resetButton;//就绪队列框中的"挂起",挂起队列框中的"解挂","删除"Buttonprivate JButton suspendButton, umountButton, removeButton;//Status面板中的"启动系统","重置系统"Buttonprivate JButton startButton, pauseButton, resetSyatemButton;//优先级和时间片单选钮及时间片显示框private JRadioButton priorityJRB, timesliceJRB;private JLabel timesliceSizeLabel;private JTextField timesliceJtf;//后备面板、进程添加面板、挂起面板、内存面板private JPanel backupBAKPanel, PCBItemPanel, suspendedPanel;//后备队列、挂起队列元素总数标签private JLabel backupTotalLabel, suspendTotalLabel;//进程信息标签进程编号PID,所需运行时间requiredTime,优先级priority,当前状态statues,内存中的基址base,所需内存大小limitprivate JLabel PIDLabel, requiredTimeLabel, priorityLabel, statuesLabel;//后备队列、挂起队列元素总数文本框(不可编辑)private JTextField backupTotalTextField, suspendTotalTextField;//进程信息文本框PID(可编辑),requiredTime(可编辑),priority(可编辑),status(不可编辑),base(不可编辑),limit(可编辑)private JTextField PIDTextField, requiredTimeTextField, priorityTextField, statusTextField;//CPU状态显示文本域(不可编辑),status信息文本域(用于现实程序每一步的操作和影响,不可编辑)private JTextArea CPUTextArea, statuesTextArea;//后备队列PCB数组,就绪、挂起,——内存(可分分区表)PCBRecords backupPCB, readyPCB, suspendedPCB;public static void main(String[] args) throws IOException {// TODO Auto-generated method stubnew SingleCPUSchedulingGUI001().initFrame();}public void initFrame() {backupList = new JList();backupList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);backupList.setVisibleRowCount(BackupBAK_LIST_ROWS);backupList.setFixedCellWidth(BackupBAK_CELL_SIZE);suspendList = new JList();suspendList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);suspendList.setVisibleRowCount(Suspend_LIST_ROWS);suspendList.setFixedCellWidth(Suspend_CELL_SIZE);readyList = new JList();readyList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);readyList.setVisibleRowCount(Ready_LIST_ROWS);readyList.setFixedCellWidth(Ready_CELL_SIZE);suspendButton = new JButton("Suspend");addToBAKButton = new JButton("AddToBAK");addToReadyButton = new JButton("AddToReady");resetButton = new JButton("Reset");umountButton = new JButton("Umount");removeButton = new JButton("Remove");startButton = new JButton("StartSchuliding");pauseButton = new JButton("Pause");resetSyatemButton = new JButton("ResetSystem");priorityJRB = new JRadioButton("Priority", true);timesliceJRB = new JRadioButton("Timeslice");backupTotalLabel = new JLabel("Total:");backupTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);backupTotalTextField.setEditable(false);suspendTotalLabel = new JLabel("Total:");suspendTotalTextField = new JTextField("0", TOTAL__TEXTFIELD_SIZE);suspendTotalTextField.setEditable(false);timesliceSizeLabel = new JLabel("Timeslice");timesliceJtf = new JTextField("3", 5);timesliceJtf.setEditable(true);CPUTextArea = new JTextArea(CPU_ROWS, CPU_COLS);CPUTextArea.setEditable(false);statuesTextArea = new JTextArea(STATUS_ROWS, STATUS_COLS);statuesTextArea.setEditable(false);/* north panel*/// JPanel northPanel = new JPanel(new BorderLayout());JPanel northPanel = new JPanel(new GridLayout(1, 3));// JPanel north = new JPanel(new BorderLayout());// ProcessPCB item information PanelPCBItemPanel = new JPanel(new BorderLayout());PCBItemPanel.setBorder(BorderFactory.createTitledBorder("PCBItem Information"));JPanel PCBItemButtonJPanel = new JPanel(new GridLayout(3, 1));PCBItemButtonJPanel.add(addToBAKButton);PCBItemButtonJPanel.add(addToReadyButton);PCBItemButtonJPanel.add(resetButton);PCBItemPanel.add(this.initPCBItemPanel(), BorderLayout.CENTER);PCBItemPanel.add(PCBItemButtonJPanel, BorderLayout.SOUTH);//backupBAKList PanelbackupBAKPanel = new JPanel(new BorderLayout());backupBAKPanel.setBorder(BorderFactory.createTitledBorder("BackupList"));JPanel backupTotalPAnel = new JPanel();backupTotalPAnel.add(backupTotalLabel);backupTotalPAnel.add(backupTotalTextField);backupBAKPanel.add (new JScrollPane(backupList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);backupBAKPanel.add(backupTotalPAnel, BorderLayout.SOUTH);// north.add(backupBAKPanel, BorderLayout.WEST);// north.add(PCBItemPanel, BorderLayout.CENTER);// SuspendList PanelsuspendedPanel = new JPanel(new BorderLayout());suspendedPanel.setBorder(BorderFactory.createTitledBorder("SuspendList"));JPanel suspendedTotalPAnel = new JPanel();suspendedTotalPAnel.add(suspendTotalLabel);suspendedTotalPAnel.add(suspendTotalTextField);JPanel suspendComponentPanel = new JPanel(new GridLayout(1, 2));suspendComponentPanel.add(umountButton);suspendComponentPanel.add(removeButton);suspendedPanel.add (suspendedTotalPAnel, BorderLayout.NORTH);suspendedPanel.add (new JScrollPane(suspendList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED), BorderLayout.CENTER);suspendedPanel.add(suspendComponentPanel, BorderLayout.SOUTH);// northPanel.add(north, BorderLayout.CENTER);// northPanel.add(suspendedPanel, BorderLayout.EAST);northPanel.add(backupBAKPanel);northPanel.add(PCBItemPanel);northPanel.add(suspendedPanel);/* center Panel*/JPanel centrelPanel = new JPanel(new BorderLayout());// JPanel centrelPanel = new JPanel(new GridLayout(1, 3));// readyList panelJPanel readyListPanel = new JPanel(new BorderLayout());readyListPanel.setBorder(BorderFactory.createTitledBorder("ReadyList"));readyListPanel.add (new JScrollPane(readyList,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));//, BorderLayout.CENTERreadyListPanel.add (suspendButton, BorderLayout.SOUTH);// CPU panelJPanel CPUPanel = new JPanel();CPUPanel.setBorder(BorderFactory.createTitledBorder("CPU"));CPUPanel.add (new JScrollPane(CPUTextArea,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED));centrelPanel.add(readyListPanel, BorderLayout.WEST);centrelPanel.add(CPUPanel, BorderLayout.CENTER);/*statues panel*/JPanel southPanel = new JPanel(new BorderLayout());JPanel statuesPanel = new JPanel();statuesPanel.setBorder(BorderFactory.createTitledBorder("Statues"));statuesPanel.add (new JScrollPane(statuesTextArea,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED)); //, BorderLayout.CENTER //statuesPanel.setSize(400, 100);//statuesPanel.setPreferredSize(new Dimension(400, 10));JPanel systemContralButtonPanel = new JPanel(new GridLayout(6, 1));systemContralButtonPanel.setBorder(BorderFactory.createTitledBorder("systemContral"));ButtonGroup group = new ButtonGroup();group.add(priorityJRB);group.add(timesliceJRB);JPanel porityPanel = new JPanel(new GridLayout(1, 2));porityPanel.add(timesliceSizeLabel);porityPanel.add(timesliceJtf);systemContralButtonPanel.add(priorityJRB);systemContralButtonPanel.add(timesliceJRB);systemContralButtonPanel.add(porityPanel);systemContralButtonPanel.add(startButton);systemContralButtonPanel.add(pauseButton);systemContralButtonPanel.add(resetSyatemButton);southPanel.add(statuesPanel, BorderLayout.CENTER);southPanel.add(systemContralButtonPanel, BorderLayout.EAST);// arrange panels in windowsetLayout(new BorderLayout());add(northPanel, BorderLayout.NORTH);add(centrelPanel, BorderLayout.CENTER);add(southPanel, BorderLayout.SOUTH); //statuesPanel// start listening for list and buttons eventsaddToBAKButton.addActionListener(new AddToBAKListener());addToReadyButton.addActionListener(new AddToReadyListener());resetButton.addActionListener(new ResetListener());suspendButton.addActionListener(new SuspendListener());umountButton.addActionListener(new UmountListener());removeButton.addActionListener(new RemoveListener());startButton.addActionListener(new StartSystemListener());pauseButton.addActionListener(new SystemPauseListener());resetSyatemButton.addActionListener(new ResetSystemListener());priorityJRB.addActionListener(new priotiryListener());timesliceJRB.addActionListener(new timeslicListener());backupPCB = new PCBRecords();readyPCB = new PCBRecords();suspendedPCB = new PCBRecords();backupList.setListData(backupPCB.getItemsProperties());readyList.setListData(readyPCB.getItemsProperties());suspendList.setListData(suspendedPCB.getItemsProperties());this.setTitle("CPUSchudling");this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(WIDTH, HEIGHT);this.setResizable(true);this.setVisible(true);this.setLocation(200, 10);}public JPanel initPCBItemPanel() {JPanel iniPCBItemJPanel = new JPanel(new BorderLayout());JPanel iniNamePanel = new JPanel(new GridLayout(4, 1));JPanel iniValuePanel = new JPanel(new GridLayout(4, 1));PIDLabel = new JLabel("PID:");requiredTimeLabel = new JLabel("RequiredTime:");priorityLabel = new JLabel("Priority:");statuesLabel = new JLabel("Statues:");iniNamePanel.add(PIDLabel);iniNamePanel.add(requiredTimeLabel);iniNamePanel.add(priorityLabel);iniNamePanel.add(statuesLabel);PIDTextField = new JTextField("", 10);PIDTextField.setEditable(true);requiredTimeTextField = new JTextField("", 10);requiredTimeTextField.setEditable(true);priorityTextField = new JTextField("", 10);priorityTextField.setEditable(true);statusTextField = new JTextField("", 10);statusTextField.setEditable(false);iniValuePanel.add(PIDTextField);iniValuePanel.add(requiredTimeTextField);iniValuePanel.add(priorityTextField);iniValuePanel.add(statusTextField);iniPCBItemJPanel.add(iniNamePanel, BorderLayout.WEST);iniPCBItemJPanel.add(iniValuePanel, BorderLayout.CENTER);return iniPCBItemJPanel;}public int readInteger(String s) {int num = -1;try {num = Integer.parseInt(s);} catch(NumberFormatException numberformatexception) {statuesTextArea.append("Please input a positive integer!\n");num = -999;}return num;}public void addToBackupList(String newID, int s1, int s2, String s) {ProcessPCB item = backupPCB.getItem(newID);if(item != null) {statuesTextArea.append("The PCB " + newID + " has existed in Backup List!\n"+ "you need to modify the PID of the selected PCB!\n");while(item != null) {newID = s + newID;item = backupPCB.getItem(newID);}}ProcessPCB newPCB = new ProcessPCB(newID, s1, s2, "Waiting");backupPCB.addItem(newPCB);backupList.setListData(backupPCB.getItemsProperties());backupTotalTextField.setText(Integer.toString(backupPCB.getNumberOfItems()));}public void addToReadyList(String nowID, int s1, int s2, String s) {ProcessPCB item = readyPCB.getItem(nowID);if(item != null) {statuesTextArea.append("The PCB " + nowID + " has existed in Ready List!\n"+ "you need to modify the PID of the selected PCB!\n");while(item != null) {nowID = s + nowID;item = backupPCB.getItem(nowID);}}ProcessPCB newPCB = new ProcessPCB(nowID, s1, s2, "Ready");readyPCB.addItem(newPCB);sortReadyPCB();readyList.setListData(readyPCB.getItemsProperties());}class AddToBAKListener implements ActionListener {public void actionPerformed(ActionEvent event) {String newID = PIDTextField.getText();String newTime = requiredTimeTextField.getText();String newPriority = priorityTextField.getText();int s1 = 0, s2 = 0, tag1=-1, tag2=-1;if(newTime != null){s1 = readInteger(newTime);if(s1 > 0.0) tag1 = 1;else statuesTextArea.append("The neededTime must be a positive integer.\n");}if(newPriority != null){s2 = readInteger(newPriority);if(s1 != -999) tag2 = 1;else statuesTextArea.append("The priority must be an integer.\n");}if(tag1 ==1 && tag2 == 1 ) {if(newID == null) {statuesTextArea.append("The value of ID mustn't be null!\n");} else {addToBackupList(newID, s1, s2, "B");statuesTextArea.append("The PCB record item has been added to BackupList!\n");reset();}}}}class AddToReadyListener implements ActionListener {public void actionPerformed(ActionEvent event) {String nowID = PIDTextField.getText();String time = requiredTimeTextField.getText();String priority = priorityTextField.getText();int s1 = 0, s2 = 0;int tag1 = -1, tag2 = -1;if(time != null){s1 = readInteger(time);if(s1 > 0.0) tag1=1;else statuesTextArea.append("The neededTime must be a positive integer.\n");}if(priority != null){s2 = readInteger(priority);if(s2 != -999) tag2=1;else statuesTextArea.append("The priority must be an integer.\n");}if(tag1 ==1 && tag2 == 1) {if(nowID == null) {statuesTextArea.append("The value of ID mustn't be null!\n");} else {if(readyPCB.getNumberOfItems() < 6) {addToReadyList(nowID, s1, s2, "R");statuesTextArea.append("The student record item has been added to ReadyList!\n");} else {statuesTextArea.append("The ReadyList was full! The new ProcessPCB will be added to BackupList!\n");addToBackupList(nowID, s1, s2, "b");statuesTextArea.append("The student record item has been added to BackupList!\n");}reset();}}}}public void reset() {PIDTextField.setText("");requiredTimeTextField.setText("");priorityTextField.setText("");statusTextField.setText("");}/*** This inner class processes <code>resetButton</code> events.*/class ResetListener implements ActionListener {public void actionPerformed(ActionEvent event) {reset();}}/*** This inner class processes <code>suspendButton</code> events.*///注:在挂起时,不会触发进程调度,而是在点击"startSyatemJButton"时才会出发进程调度class SuspendListener implements ActionListener {/*** Removes an order item from the current order.** @param event the event object.*/public void actionPerformed(ActionEvent event) {String selectedReadyItem = null;String pid = "";if(readyPCB.getNumberOfItems() == 0){statuesTextArea.append("The readyList is empty!\n");} else {selectedReadyItem = (String) readyList.getSelectedValue();if(selectedReadyItem == null) {statuesTextArea.append("Please select an item from the ready list!\n");} else{StringTokenizer stringtokenizer = new StringTokenizer(selectedReadyItem, "_");pid = stringtokenizer.nextToken();ProcessPCB selectedItem = readyPCB.getItem(pid);if(selectedItem == null) {statuesTextArea.append("No student recorditem of Num " + pid + " is founded!\n");} else {ProcessPCB boolTtem = suspendedPCB.getItem(pid);if(boolTtem != null) {statuesTextArea.append("The PCB " + pid + " has existed in Suspend List!\n"+ "you need to modify the PID of the selected PCB!\n");while(boolTtem != null) {pid = "X" + pid;boolTtem = suspendedPCB.getItem(pid);}}ProcessPCB newPcb = new ProcessPCB(pid, selectedItem.getRequiredTime(),selectedItem.getPriority(),"Suspended");suspendedPCB.addItem(newPcb);readyPCB.removeItem(selectedItem);sortReadyPCB(); //注意考虑一下suspendList.setListData(suspendedPCB.getItemsProperties());readyList.setListData(readyPCB.getItemsProperties());statuesTextArea.append("The product has been suspended!\n"); suspendTotalTextField.setText(Integer.toString(suspendedPCB.getNumberOfItems()));}}}}}public void sortReadyPCB() {PCBRecords currentReadyPCB = new PCBRecords();int num = readyPCB.getNumberOfItems();if(num > 0) {for(int i=num; i>=1; i--) {Iterator readyIterator = readyPCB.iterator();ProcessPCB currentItem = (ProcessPCB) readyIterator.next();for( ; readyIterator.hasNext(); ) {ProcessPCB nowItem = (ProcessPCB) readyIterator.next();if(currentItem.getPriority() < nowItem.getPriority()) {currentItem = null;。
批处理系统的作业调度java
实验批处理系统的作业调度一、实验目的(1)加深对作业概念的理解;(2)深入了解批处理系统如何组织作业、管理作业和调度作业。
二、预备知识(1).三、实验内容编写程序完成批处理系统中的作业调度,要求采用响应比高者优先的作业调度算法。
实验具体包括:首先确定作业块的内容和组成方式;然后完成作业调度;最后编写主函数,对所做工作进行测试。
import java.util.Scanner;public class JCB {public String name; //作业名public int length; //作业长度public int print; //打印机数量public int tape; //磁带机数量public int runTime;public int waitTime;public int next; //指针}class Action{public final int n=10; //后备队列中JCB的最大数量JCB[] jTable=new JCB[n]; //作业表public int jCount; //作业表中当前作业数量public int head; //作业表头指针//初始化函数public void Init(){head=-1;jCount=0;}//入队函数public void pushQueue(JCB jcb){if(jCount>=n){System.out.println("队列已满!不能再加入!");return ;}if(head==-1)head=0;// System.out.println(jTable[jCount]);jTable[jCount]=new JCB();jTable[jCount].length=jcb.length;jTable[jCount].name=;jTable[jCount].print=jcb.print;jTable[jCount].tape=jcb.tape;jTable[jCount].runTime=jcb.runTime;jTable[jCount].waitTime=jcb.waitTime;jTable[jCount].next=-1;jCount++;}//出队函数public void popQueue(int num){if(jCount==0){System.out.println("空的队列!不能出队!");return ;}if(num>=jCount){System.out.println("队列中不存在该元素!");return ;}if(jCount==1){head=-1;jTable[0].next=-1;jCount=0;}else{jTable[num-1].next=jTable[num].next;jTable[num].next=-1;jCount--;}}public int memory=64*1024; //主存大小64MBpublic int tape=4; //磁带机数量public int print=2; //打印机数量//作业调度函数public void dispatch(){int currJcb,maxJcb;double currJcbRate,maxJcbRate;while(head!=-1){currJcb=maxJcb=head;currJcbRate=maxJcbRate=0;//找出响应比最大的作业while(true){//找出满足资源的作业if(jTable[currJcb].length<=memory&&jTable[currJcb].tape<=tape&&jTable [currJcb].print<=print){//计算响应比currJcbRate=(double)jTable[currJcb].waitTime/jTable[currJcb].runTime;if(currJcbRate>maxJcbRate){maxJcbRate=currJcbRate;maxJcb=currJcb;}}if(jTable[currJcb].next==-1){break;}else{currJcb=jTable[currJcb].next;}}//输出响应比最大的作业、分配资源if(maxJcbRate!=0){memory-=jTable[maxJcb].length;tape-=jTable[maxJcb].tape;tape-=jTable[maxJcb].print;System.out.println("选中的作业的作业名为:"+jTable[maxJcb].name);popQueue(maxJcb);}}}public static void main(String[] args) {String name;int length;int print;int tape;int runTime;int waitTime;int count; //记录输入作业数量JCB jcb =new JCB(); //临时作业变量System.out.println("请输入作业相关信息,以作业名为Q为输入结束。
作业调度实例(全部代码)
源代码:#include <stdio.h>#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))#define NULL 0int n;float T1=0,T2=0;int times=0;struct jcb //作业控制块{char name[10]; //作业名int reachtime; //作业到达时间int starttime; //作业开始时间int needtime; //作业需要运行的时间float super; //作业的响应比int finishtime; //作业完成时间float cycletime; //作业周转时间float cltime; //作业带权周转时间char state; //作业状态struct jcb *next; //结构体指针}*ready=NULL,*p,*q;typedef struct jcb JCB;void inize() //初始化界面{printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t单道批处理作业调度系统\n");printf("\t\t*********************************************\t\t\n"); printf("\n\n\n\t\t\t\t\t09软件+电子商务2班\n");printf("\t\t\t\t\t\t黄才旺\n\n");printf("\n\n\n\t\t请按任意键进入主菜单:");getch();}void inital() //建立作业控制块队列,先将其排成先来先服务的模式队列{int i;printf("\n输入作业数:");scanf("%d",&n);for(i=0;i<n;i++){p=getpch(JCB);printf("\n输入作业名:");scanf("%s",p->name);getch();p->reachtime=i;printf("作业默认到达时间:%d",i);printf("\n输入作业需运行时间:");scanf("%d",&p->needtime);p->state='W';p->next=NULL;if(ready==NULL) ready=q=p;else{q->next=p;q=p;}}}void disp(JCB* q,int m) //显示作业运行后的周转时间及带权周转时间等{if(m==3) //显示高响应比算法调度作业后的运行情况 {printf("\n作业%s正在运行,估计其运行情况:\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \t相应比 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);printf(" %f\n",q->super);getch();}else // 显示先来先服务,最短作业优先算法调度后作业的运行情况{printf("\n作业%s正在运行,估计其运行情况:\n",q->name);printf("\n 开始运行时刻 \t 完成时刻 \t 周转时间 \t 带权周转时间 \n");printf(" %d \t",q->starttime);printf(" %d \t",q->finishtime);printf(" %f \t",q->cycletime);printf(" %f\t",q->cltime);getch();}}void running(JCB *p,int m) //运行作业{if(p==ready) //先将要运行的作业从队列中分离出来{ready=p->next;p->next=NULL;}else{q=ready;while(q->next!=p) q=q->next;q->next=p->next;}p->starttime=times;//计算作业运行后的完成时间,周转时间等等 p->state='R';p->finishtime=p->starttime+p->needtime;p->cycletime=(float)(p->finishtime-p->reachtime);p->cltime=(float)(p->cycletime/p->needtime);T1+=p->cycletime;T2+=p->cltime;disp(p,m); //调用disp()函数,显示作业运行情况 times+=p->needtime;p->state='F';printf("\n%s 作业已完成!\n请按任意键继续...\n",p->name);free(p); //释放运行后的作业getch();}void super() //计算队列中作业的高响应比{JCB *padv;padv=ready;do{if(padv->state=='W'&&padv->reachtime<=times)padv->super=(float)(times-padv->reachtime+padv->needtime)/padv->n eedtime;padv=padv->next;}while(padv!=NULL);}void final() //最后打印作业的平均周转时间,平均带权周转时间{float s,t;t=T1/n;s=T2/n;getch();printf("\n\n作业已经全部完成!");printf("\n%d个作业的平均周转时间是:%f",n,t);printf("\n%d个作业的平均带权周转时间是:%f\n\n\n",n,s);}void hrn(int m) //高响应比算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;super();do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->super>min->super) min=p; p=p->next;}while(p!=NULL);if(iden){i--;times++;if(times>1000){printf("\nruntime is too long...error...");getch();} }else{running(min,m); //调用running()函数 }} //forfinal(); //调用running()函数}void sjf(int m) // 最短作业优先算法{JCB *min;int i,iden;system("cls");inital();for(i=0;i<n;i++){p=min=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times)if(iden){min=p;iden=0;}else if(p->needtime<min->needtime) min=p;p=p->next;}while(p!=NULL) ;if(iden) {i--;times++;if(times>100){printf("\nruntime is too long...error");getch();} }else{running(min,m); //调用running()函数}} //forfinal(); //调用running()函数}void fcfs(int m) //先来先服务算法{int i,iden;system("cls");inital();for(i=0;i<n;i++){p=ready;iden=1;do{if(p->state=='W'&&p->reachtime<=times) iden=0;if(iden)p=p->next;}while(p!=NULL&&iden) ;if(iden){i--;printf("\n没有满足要求的进程,需等待");times++;if(times>100){printf("\n时间过长");getch();}}else{running(p,m); //调用running()函数}}final(); //调用running()函数}void mune(){int m;system("cls");printf("\n\n\t\t*********************************************\t\t\n"); printf("\t\t\t\t作业调度主菜单\n");printf("\t\t*********************************************\t\t\n");printf("\n\n\n\t\t\t1.先来先服务算法");printf("\n\t\t\t2.最短作业优先算法");printf("\n\t\t\t3.响应比高者优先算法");printf("\n\t\t\t0.退出程序");printf("\n\n\t\t\t\t选择算法:");scanf("%d",&m);switch(m){case 1:fcfs(m);getch();system("cls");mune();break;case 2:sjf(m);getch();system("cls");mune();break;case 3:hrn(m);getch();system("cls");mune();break;case 0:system("cls");break;default:printf("选择错误,重新选择.");getch();system("cls");mune();}}main() //主函数{inize();mune();}选择1进入“先来先服务算法”作业调度:选择2进入“最短作业优先算法”作业调度:选择3进入“响应比高者优先算法”作业调度:。
01背包问题and批处理作业调度问题
一01背包问题/*这里是综述int c;//背包容量int n; //物品数int *w;//物品重量数组int *p;//物品价值数组int cw;//当前重量int cp;//当前价值int bestp;//当前最优值int *bestx;//当前最优解int *x;//当前解int Knap::Bound(int i)//计算上界void Knap::Backtrack(int i)//回溯函数int Knapsack(int p[],int w[],int c,int n) //为Knap::Backtrack初始化*/class Knap//{friend int Knapsack(int p[],int w[],int c,int n );//定义一个友联函数背包函数public:private:int Bound(int i);void Backtrack(int i);int c;//背包容量int n; //物品数int *w;//物品重量数组int *p;//物品价值数组int cw;//当前重量int cp;//当前价值int bestp;//当前最优值int *bestx;//当前最优解int *x;//当前解};int Knap::Bound(int i)//计算上界{ int cleft=c-cw;//剩余容量int b=cp;while(i<=n&&w[i]<=cleft)//以物品单位重量价值递减序装入物品cleft-=w[i]; b+=p[i]; i++;//装满背包if(i<=n)b+=p[i]/w[i]*cleft;return b;}void Knap::Backtrack(int i)//定义一个回溯函数{ if(i>n){ if(bestp<cp){ for(int j=1;j<=n;j++)bestx[j]=x[j];bestp=cp;}}if(cw+w[i]<=c) //搜索左子树{ x[i]=1; cw+=w[i]; cp+=p[i]; Backtrack(i+1); cw-=w[i]; cp-=p[i];} if(Bound(i+1)>bestp)//搜索右子树{x[i]=0; Backtrack(i+1);}}class Object//定义物品的类,封装数据{friend int Knapsack(int p[],int w[],int c,int n);public:int operator<=(Object a)const{return (d>=a.d);}private:int ID;float d;};int Knapsack(int p[],int w[],int c,int n)//为K nap::Backtrack初始化,解决背包函数,//主要是这个,{int W=0; int P=0; int i=1;Object *Q=new Object[n];for(i=1;i<=n;i++){Q[i-1].ID=i; Q[i-1].d=1.0*p[i]/w[i];P+=p[i]; W+=w[i];}if(W<=c)return P;//装入所有物品float f;//依物品单位重量排序for(i=0;i<n;i++)for(int j=i;j<n;j++){if(Q[i].d<Q[j].d){f=Q[i].d; Q[i].d=Q[j].d; Q[j].d=f;}}Knap K;K.p = new int[n+1]; K.w = new int[n+1];K.x = new int[n+1]; K.bestx = new int[n+1];K.x[0]=0; K.bestx[0]=0;for( i=1;i<=n;i++)K.p[i]=p[Q[i-1].ID]; K.w[i]=w[Q[i-1].ID];K.cp=0; K.cw=0; K.c=c; K.n=n; K.bestp=0;K.Backtrack(1); //回溯搜索delete [] Q;delete [] K.w;delete [] K.p;return K.bestp;}二:批处理作业调度问题#define MAX 999999//排列树问题,规模O(n!),通过剪枝实现回溯算法,减小解空间树规模class Flowshop{private:int firstTime;//机器最后完成时间int secondTime;//机器最后完成时间int totalTime;//记录递归过程中的机器时间和int bestTime;//最佳调度下的机器时间和int *first;//记录每个任务在机器完成需要的时间int *second;//记录每个任务在机器完成需要的时间int *x;//记录递归过程中的解int *bestX;//记录最佳调度下的解int num;//任务的数量public://构造函数Flowshop(int num){firstTime=0;//机器最后完成时间secondTime=0;//机器最后完成时间totalTime=0;//初始化递归过程的调度时间和为 bestTime=MAX;//初始化最佳时间无穷大this->num=num;first=new int[num+1];second=new int[num+1];bestX=new int[num+1];x=new int[num+1];for(int i=1;i<=num;i++){x[i]=i;}}void bestFlowshop() //调用回溯算法{flowshop(1);}void flowshop(int i) //回溯核心算法{if(i>num){if(totalTime<bestTime){bestTime=totalTime;for(int j=1;j<=num;j++){bestX[j]=x[j];}}return;}//排列树的回溯算法框架for(int k=i;k<=num;k++){swap(i,k);firstTime+=first[x[i]];int temp=secondTime;if(firstTime>=temp){secondTime=firstTime+second[x[i]];totalTime+=secondTime;flowshop(i+1);totalTime-=secondTime;secondTime=temp;}else{secondTime=temp+second[x[i]];totalTime+=secondTime;flowshop(i+1);totalTime-=secondTime;secondTime=temp;}firstTime-=first[x[i]];swap(i,k);}}以下不是核心内容,可以忽略.void swap(int i,int j) //交换函数{ int temp=x[i];x[i]=x[j];x[j]=temp;}void input() //输入数据{int i=1;while(i<=num){cout<<"输入第"<<i<<"个任务的机器时间"<<endl; cin>>first[i];cout<<"输入第"<<i<<"个任务的机器时间"<<endl; cin>>second[i];++i;}}void display() //打印结果{int i=1;while(i<=num){cout<<"第"<<i<<"个任务:"<<bestX[i]<<endl;++i;}cout<<"最优调度时间和:"<<bestTime<<endl;}};void main(){Flowshop test(3);//三个任务test.input();//输入三个任务的时间test.bestFlowshop();//调用回溯算法找到最优调度解test.display();//打印结果}。
批处理作业调度(回溯)
批处理作业调度(回溯).算法设计例题:批处理作业调度(回溯)memory limit: 5000KB time limit: 2000MSaccept: 13 submit: 33Description给定n个作业的集合J = { J1,J2,…,Jn }。
每一个作业Ji都有两项任务分别在两台机器上完成。
每个作业必须先由机器1处理,然后由机器2处理。
作业Ji需要机器j的处理时间为tji,其实i=1,2,…,n,j=1,2。
对于一个确定的作业调度,设Fji是作业i在机器j上完成处理的时间。
所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业,制定最佳作业调度方案,使其完成时间和达到最小。
Input输入的第一个为测试样例的个数T(T < 120 ),接下来有T个测试样例。
每个测试样例的第一行是作业个数n(n ≤7 ),接下来n行,每行两个整数t1i 和t2i ,分别表示当前作业在机器1和机器2上的处理时间。
(0 ≤t1i , t2i ≤100 )Output对应每个测试样例输出两行,第一行格式为"Case #: M",其中'#'表示第几个测试样例(从1开始计),M为最佳作业调度的时间和。
第二行为n个以空格分隔的整数,表示最佳作业调度方案中各作业执行顺序的序号。
Sample Input132 13 12 3Sample OutputCase 1: 181 3 2源代码:#include<cstdio>#include<cstring>class FlowShop{public:int n, //作业数f1, //机器1完成处理时间f, //完成时间和bestf, //当前最优值m[35][3], //各作业所需处理时间x[35], //当前作业调度bestx[35], //当前最优作业调度f2[35]; //机器2完成处理时间void swap(int &a,int &b){int c=a;a=b;b=c;}int play(){f1=0;f=0;bestf=0x3f3f3f3f;int i;for(i=0;i<=n;++i)x[i]=i,f2[i]=0;backtrack(1);return bestf;}void backtrack(int i){if(i>n){for(int j=1;j<=n;++j)bestx[j]=x[j];bestf=f;}else{for(int j=i;j<=n;++j){f1+=m[x[j]][1];f2[i]=((f2[i-1]>f1)?f2[i-1]:f1)+m[x[j]][2];f+=f2[i];if(f<bestf){swap(x[i],x[j]);backtrack(i+1);swap(x[i],x[j]);}f1-=m[x[j]][1];f-=f2[i];}}}};int main(){int T,cas=1;scanf("%d",&T);while(T--){FlowShop p;scanf("%d",&p.n);int i;for(i=1;i<=p.n;++i)scanf("%d %d",&p.m[i][1],&p.m[i][2]);printf("Case %d: %d\n",cas++,p.play());for(i=1;i<=p.n;++i){if(i!=1) putchar(' ');printf("%d",p.bestx[i]);}puts("");}return 0;}。
Java调用批处理程序
Java调用批处理或可执行文件用Java编写应用时,有时需要在程序中调用另一个现成的可执行程序或系统命令,这时可以通过组合使用Java提供的Runtime类和Process类的方法实现。
下面是一种比较典型的程序模式:■ ■■Process process = Runtime.getRuntime().exec(".\\p.exe");process.waitfor();在上面的程序中,第一行的p.exe ”是要执行的程序名,Runtime.getRuntime()返回当前应用程序的Runtime对象,该对象的exec()方法指示Java虚拟机创建一个子进程执行指定的可执行程序,并返回与该子进程对应的Process对象实例。
通过Process可以控制该子进程的执行或获取该子进程的信息。
第二条语句的目的等待子进程完成再往下执行。
但在windows平■台上,如果处理不当,有时并不能得到预期的结果。
下面是笔者在实际编程中总结的几种需要注意的情况:1、执行DOS的内部命令如果要执行一条DOS内部命令,有两种方法。
一种方法是把命令解释器包含在exec()的参数中。
例如,执行dir命令,在NT上,可写成exec("cmd.exe /c dir"),在windows 95/98 下,可写成“ command.exe /c dir,其中参数“ /&”示命令执行后关闭Dos立即关闭窗口。
另一种方法是,把内部命令放在一个批命令my_dir.bat 文件中,在Java程序中写成exec("my_dir.bat")。
如果仅仅写成exec("dir") , Java虚拟机则会报运行时错误。
前一种方法要保证程序的可移植性,需要在程序中读取运行的操作系统平台, 以调用不同的命令解释器。
后一种方法则不需要做更多的处理。
2、打开一个不可执行的文件打开一个不可执行的文件,但该文件存在关联的应用程序,则可以有两种方式。
java batch案例
java batch案例Java Batch是一种用于批处理处理大量数据的Java技术。
它允许开发人员创建可以自动化执行的作业,这些作业可以在预定的时间间隔内运行,并且可以在后台运行而不影响前台用户的操作。
下面是一些关于Java Batch案例的示例:1. 邮件发送批处理:开发一个Java Batch程序,定期从数据库中获取待发送的邮件信息,然后使用Java Mail API发送这些邮件。
2. 数据清洗批处理:开发一个Java Batch程序,从原始数据源中提取数据,对数据进行清洗和转换,并将清洗后的数据存储到目标数据源中。
3. 数据备份批处理:开发一个Java Batch程序,定期从数据库中提取数据,并将数据备份到另一个存储位置,以防止数据丢失。
4. 数据导入批处理:开发一个Java Batch程序,从外部文件(如CSV或Excel)中读取数据,并将数据导入到数据库中。
5. 数据报表生成批处理:开发一个Java Batch程序,根据预定的时间表,从数据库中提取数据,并生成报表并保存到指定的位置。
6. 日志分析批处理:开发一个Java Batch程序,定期读取日志文件,分析日志内容并生成统计报告。
7. 数据转换批处理:开发一个Java Batch程序,将一个数据格式转换为另一个数据格式,例如将XML格式转换为JSON格式。
8. 数据分析批处理:开发一个Java Batch程序,从大量数据中提取有用的信息,并进行数据分析和统计。
9. 文件处理批处理:开发一个Java Batch程序,定期读取指定文件夹中的文件,并对文件进行处理,例如移动、删除或重命名文件。
10. 数据同步批处理:开发一个Java Batch程序,将两个或多个数据源中的数据进行同步,以确保数据的一致性。
这些案例只是Java Batch的一小部分应用场景,实际上,Java Batch可以应用于各种需要批量处理大量数据的场景。
通过使用Java Batch,开发人员可以更高效地处理数据,并且可以通过自动化作业来减少手动操作的工作量。
使用Java创建任务调度器
使用Java创建任务调度器-一个实战教程任务调度器是一种有用的工具,它可以用于计划和执行定期任务,例如定时备份、定时数据清理等。
在这个实战博客中,我们将创建一个Java任务调度器,演示如何使用Java编程语言和任务调度库来计划和执行定时任务。
以下是本实战博客的主要内容:项目概述准备工作创建Java项目添加任务调度库设计任务实现任务调度器总结让我们开始吧!1. 项目概述在本项目中,我们将创建一个简单的Java任务调度器应用程序,它包括以下主要功能:允许用户定义并计划定时任务。
执行定时任务,例如定时备份文件或定时发送电子邮件。
提供任务日志和状态报告。
我们将使用Java编程语言和Quartz任务调度库来构建这个任务调度器应用程序。
2. 准备工作在开始之前,确保您的开发环境已设置好。
我们将使用Java编程语言和Quartz任务调度库来构建任务调度器应用程序,不需要额外的工具或库。
3. 创建Java项目首先,创建一个新的Java项目,您可以使用任何Java集成开发环境(IDE)来完成此操作。
在项目中,我们将创建Java类来实现任务调度器应用程序。
4. 添加任务调度库为了实现任务调度功能,我们需要引入一个任务调度库。
在本示例中,我们将使用Quartz 任务调度库,它是一个功能强大且广泛使用的任务调度库。
您可以在Maven项目的pom.xml文件中添加以下依赖:xmlCopy code<dependencies><dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.3.2</version></dependency></dependencies>请根据您的项目需求和IDE选择合适的方法来引入库。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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];