电梯调度算法java

千次阅读

2021-03-03 17:19:01

电梯调度算法设计

题目：电梯调度算法
以金川校区电力大楼中间的4部电梯为例。（也可自行设定参数）
(1)建筑共有25层，其中含有地下一层。
(2)建筑内部设有4部电梯。
(3)中间两部电梯内部有25个按钮，其中包括开门按钮、关门按钮和楼层按钮，编号为-1，1，2，3，4…24。外侧两部电梯内部有11个按钮，其中包括开门按钮、关门按钮和楼层按钮，编号为-1，1，2，3，4…10。
(4)中间两部电梯设置为联动模式，外侧两部电梯设置为联动模式。

要求：
1.设计电梯调度算法，使电梯可对乘客的呼叫作出正确反应。
2.电梯运行效率高。
3.考虑特定的运行需求，如设置2－5层电梯不停等。
4.封装以上算法，实现可视化运行界面。【加分点】

时间表格

时间	成员	分工内容
2021年3月3日 A.M.	李渊博	设计程序思路，编写博客
2021年3月3日 A.M.	陈鹏昊	设计程序思路
2021年3月3日 P.M.	李渊博	一起讨轮设计方案，包括应用使用语言，应用设计界面，电梯运行算法实现决定使用Java作为编译语言，GUI界面设计
2021年3月3日 P.M.	陈鹏昊	一起讨轮设计方案，包括应用使用语言，应用设计界面，电梯运行算法实现决定使用Java作为编译语言，GUI界面设计
2021年3月5日 A.M.	李渊博	编写电梯上下运行核心代码
2021年3月5日 A.M.	陈鹏昊	编写Elevator运行界面
2021年3月8日 A.M.	李渊博	合并代码，进行功能测试
2021年3月8日 A.M.	陈鹏昊	多个电梯代码设计

电梯算法有些复杂，进行一半发现属于多线程。。没有进行学习

此前工程结束，项目宣告暂停。

下面是一部电梯的残疾代码希望大佬进行指正，在学习多线程之后完善此项目。

package attribute;

public class Elevator extends Floor {
	private int number;
	private int GoFloor;
	private int state = 0;
	
	public Elevator() {
		super();
	}
	
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}

	public int getGoFloor() {
		return GoFloor;
	}
	public void setGoFloor(int goFloor) {
		GoFloor = goFloor;
	}
	public int getState() {
		return state;
	}
	public void setState(int state) {
		this.state = state;
	}
	
	public int ElevatorDown(int gofloor) {//下楼
		this.setGoFloor(gofloor);
		this.setNowFloor(this.getNowFloor()-1);
		return this.getNowFloor();
	}
	
	public int ElevatorUp(int gofloor){//上楼
		this.setGoFloor(gofloor);
		this.setNowFloor(this.getNowFloor()+1);
		return this.getNowFloor();
	}
}

package attribute;

public class Floor {
	private int NowFloor = 1;
	private int MaxFloor = 25;
	private int MinFloor = -1;
	
	public Floor() {
		
	} 
	
	public void FloorNo1() {
		if(NowFloor == 0)
			NowFloor = MinFloor;
	}
	public int getMaxFloor() {
		return MaxFloor;
	}
	public int getNowFloor() {
		return NowFloor;
	}
	public void setNowFloor(int nowFloor) {
		NowFloor = nowFloor;
	}
	public int getMinFloor() {
		return MinFloor;
	}
	
}

package operate;

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
import attribute.Elevator;

public class Elevator1{
    Elevator el = new Elevator();
   	public void Dianti1hao() { 
   		JButton b1 = new JButton("-1");     //-1
   	    JButton b2 = new JButton("1");		//1
   	    JButton b3 = new JButton("2");		//2
   	    JButton b4 = new JButton("3");		//3
   	    JButton b5 = new JButton("4");		//4
   	    JButton b6 = new JButton("5");		//5
   	    JButton b7 = new JButton("6");		//6
   	    JButton b8 = new JButton("7");		//7
   	    JButton b9 = new JButton("8");		//8
   	    JButton open1 = new JButton("开");  //开
   	    JButton close1 = new JButton("关"); //关
   	    JLabel light1 = new JLabel(); 
   	    JLabel c1 = new JLabel("-1");
   	    JLabel c2 = new JLabel(" 1");
   	    JLabel c3 = new JLabel(" 2");
   	    JLabel c4 = new JLabel(" 3");
   	    JLabel c5 = new JLabel(" 4");
   	    JLabel c6 = new JLabel(" 5");
   	    JLabel c7 = new JLabel(" 6");
   	    JLabel c8 = new JLabel(" 7");
   	    JLabel c9 = new JLabel(" 8");
    	JFrame jframe = new JFrame("1号电梯内部");
        jframe.setBounds(100,100,700,600);
        jframe.setVisible(true);
        jframe.setLayout(null);					//无布局管理设置
        jframe.setResizable(false);				//禁止最大化
        
        JPanel jpanel1 =new JPanel();							//电梯按钮
        jpanel1.setBorder(BorderFactory.createEtchedBorder());  //设置panel边框
        jpanel1.setLayout(null);
        jpanel1.setBounds(50,80,205, 400);
        JLabel jl2 = new JLabel("当前楼层:");						
        jl2.setBounds(5,310,55,25);
        jpanel1.add(jl2);
        	JTextField jl2k = new JTextField("1");						//当前楼层 取名为jl2k
    		jl2k.setBounds(60,310,35,35);
    		jpanel1.add(jl2k);
    		jl2k.setBorder(BorderFactory.createLineBorder(Color.black));
    		jl2k.setFont(new java.awt.Font("Dialog", 1, 25));	//层数字体设置，25为字体大小
        JLabel jl3 = new JLabel("前往楼层:");						
        jl3.setBounds(100,310,55,23);
        jpanel1.add(jl3);
        	JTextField jl3k = new JTextField("");						//前往楼层 取名为jl3k
        	jl3k.setBounds(155,310,35,35);
        	jpanel1.add(jl3k);
        	jl3k.setBorder(BorderFactory.createLineBorder(Color.black));
        	jl3k.setFont(new java.awt.Font("Dialog", 1, 25));
        
        JPanel jpanel2 =new JPanel();							//电梯标号 
        jpanel2.setLayout(null);
        jpanel2.setBounds(120,45, 150, 70);
        JLabel jl1 = new JLabel("1号电梯");						
        jl1.setBounds(0,0,80,30);
        jpanel2.add(jl1);
        jl1.setFont(new java.awt.Font("Dialog", 1, 20));

        
        
        
        
        
        
        JPanel jpanel3 =new JPanel();							//电梯运行模拟
        jpanel3.setLayout(null);
        jpanel3.setBounds( 300,50,350, 500);
        jpanel3.setBorder(BorderFactory.createEtchedBorder());
        JLabel jl5 = new JLabel("电梯运行模拟");						
        jl5.setBounds(0,0,75,23);
        jpanel3.add(jl5);
        
        
        
        
        															//-1层方块 “ c1 ”（电梯层数模拟）
        c1.setBounds(60,478,20,20);									
        c1.setFont(new java.awt.Font("Dialog", 1, 15));
        c1.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c1);
        
        															//1层方块 “ c2 ”
        c2.setBounds(60,458,20,20);									
        c2.setFont(new java.awt.Font("Dialog", 1, 14));	
        c2.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c2);
        c2.setOpaque(true);											//初始为1楼
        c2.setBackground(Color.GREEN);
        
        															//2层方块 “ c3 ”
        c3.setBounds(60,438,20,20);									
        c3.setFont(new java.awt.Font("Dialog", 1, 15));
        c3.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c3);
        
        															//3层方块 “ c4 ”
        c4.setBounds(60,418,20,20);									
        c4.setFont(new java.awt.Font("Dialog", 1, 15));
        c4.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c4);
        
        															//4层方块 “ c5 ”
        c5.setBounds(60,398,20,20);									
        c5.setFont(new java.awt.Font("Dialog", 1, 15));
        c5.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c5);
        
        															//5层方块 “ c6 ”
        c6.setBounds(60,378,20,20);									
        c6.setFont(new java.awt.Font("Dialog", 1, 15));
        c6.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c6);
        
        															//6层方块 “ c7 ”
        c7.setBounds(60,358,20,20);									
        c7.setFont(new java.awt.Font("Dialog", 1, 15));
        c7.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c7);
        
        															//7层方块 “ c8 ”
        c8.setBounds(60,338,20,20);									
        c8.setFont(new java.awt.Font("Dialog", 1, 15));
        c8.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c8);
        
        															//8层方块 “ c9 ”
        c9.setBounds(60,318,20,20);									
        c9.setFont(new java.awt.Font("Dialog", 1, 15));
        c9.setBorder(BorderFactory.createLineBorder(Color.black));
        jpanel3.add(c9);

        
      
        								
        light1.setOpaque(true); 				//灯设置
        light1.setBackground(Color.GREEN);
        light1.setBorder(BorderFactory.createLineBorder(Color.black));
        

        
        
        b1.setBounds(5, 5, 45, 45);
        b2.setBounds(55, 5, 45, 45);
        b3.setBounds(105, 5, 45, 45);
        b4.setBounds(155, 5, 45, 45);
        b5.setBounds(5, 55, 45, 45);
        b6.setBounds(55, 55, 45, 45);
        b7.setBounds(105, 55, 45, 45);
        b8.setBounds(155, 55, 45, 45);
        b9.setBounds(5, 105, 45, 45);
        open1.setBounds(5, 255, 60, 45);
        close1.setBounds(140, 255, 60, 45);
        light1.setBounds(93, 270, 20, 20);

        jpanel1.add(b1);
        jpanel1.add(b2);
        jpanel1.add(b3);
        jpanel1.add(b4);
        jpanel1.add(b5);
        jpanel1.add(b6);
        jpanel1.add(b7);
        jpanel1.add(b8);
        jpanel1.add(b9);
        jpanel1.add(open1);
        jpanel1.add(close1);
        jpanel1.add(light1);
        
        jframe.add(jpanel1);
        jframe.add(jpanel2);
        jframe.add(jpanel3);

          
          open1.addActionListener(new ActionListener() {		//按钮监听器
              public void actionPerformed(ActionEvent e) {
                	light1.setBackground(Color.green);
                	
                	
              }

          });
          close1.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
                	light1.setBackground(Color.red);
                	
                	
              }

          });
          b1.addActionListener(new ActionListener(){
              public void actionPerformed(ActionEvent e) {
                	//将前往楼层改为-1楼
            	  el.setGoFloor(-1);  
            	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层         	  	
            	  	if(el.getGoFloor()<el.getNowFloor()) {
            	  		while(el.getGoFloor()<el.getNowFloor()) {
            	  			try {
								Thread.sleep(1 * 1000);
							} catch (InterruptedException e1) {
								// TODO Auto-generated catch block
								e1.printStackTrace();
							}
            	  			el.ElevatorDown(-1);
            	  			jl3k.setText(String.valueOf(el.getGoFloor()));
            	  			el.FloorNo1();
            	  			jl2k.setText(String.valueOf(el.getNowFloor()));
            	  			
            	  		}
            	  		
            	  	}else {
            	  		while(el.getGoFloor()>el.getNowFloor()) {
            	  			try {
								Thread.sleep(1 * 1000);
							} catch (InterruptedException e1) {
								// TODO Auto-generated catch block
								e1.printStackTrace();
							}
            	  			el.ElevatorUp(-1);
            	  			jl3k.setText(String.valueOf(el.getGoFloor()));
            	  			
            	  			jl2k.setText(String.valueOf(el.getNowFloor()));
            	  			
            	  		}
            	  		            	  	
            	  		
            	  	}
            	  
            	  }
            	  else {
            		  jl2k.setText(String.valueOf(el.getNowFloor()));
            	  }
              }
          });
          
          b2.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
            	  el.setGoFloor(1); 
          	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层         	  	          	  	
          	  	if(el.getGoFloor()<el.getNowFloor()) {
          	  		while(el.getGoFloor()<el.getNowFloor()) {
          	  		try {
						Thread.sleep(1 * 1000);
					} catch (InterruptedException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
          	  			el.ElevatorDown(1);
          	  			jl3k.setText(String.valueOf(el.getGoFloor()));
          	  			jl2k.setText(String.valueOf(el.getNowFloor()));
          	  			
          	  		}
          	  		
          	  		
          	  	}
          	  	else {
          	  		while(el.getGoFloor()>el.getNowFloor()) {
          	  		try {
						Thread.sleep(1 * 1000);
					} catch (InterruptedException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
          	  			el.ElevatorUp(1);
          	  			jl3k.setText(String.valueOf(el.getGoFloor()));
          	  			jl2k.setText(String.valueOf(el.getNowFloor()));
          	  			
          	  		}
          	  		            	  	
          	  		
          	  	}
          	  	return;
          	  
          	  }
          	  else {
          		  jl2k.setText(String.valueOf(el.getNowFloor()));
          	  }            
              }
          });
          b3.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
            	  el.setGoFloor(2); 
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  		try {
							Thread.sleep(1 * 1000);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
              	  			el.ElevatorDown(2);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			
              	  		}
              	  		return;
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  		try {
							Thread.sleep(1 * 1000);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
              	  			el.ElevatorUp(2);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  	return;
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
              }
          });
          b4.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
            	  el.setGoFloor(3); 
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层        	  	
              	  if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  		try {
							Thread.sleep(1 * 1000);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
              	  			el.ElevatorDown(3);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			
              	  		}
              	  	
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  		try {
							Thread.sleep(1 * 1000);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
              	  			el.ElevatorUp(3);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
              }
          });
          b5.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {
            	  el.setGoFloor(4);  
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  	         	  	
              	  	if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  			el.ElevatorDown(4);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  			el.ElevatorUp(4);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
                	
              }
          });
          b6.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {

            	  el.setGoFloor(5);  
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  	         	  	
              	  	if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  			el.ElevatorDown(5);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  			el.ElevatorUp(5);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
                	
              
                	
              }
          });
          b7.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {

            	  el.setGoFloor(6);  
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  	         	  	
              	  	if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  			el.ElevatorDown(6);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  			el.ElevatorUp(6);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
                	
              
                	
              }
          });
          b8.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {

            	  el.setGoFloor(7);  
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  	         	  	
              	  	if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  			el.ElevatorDown(7);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  			el.ElevatorUp(7);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
                	
              
                	
              }
          });
          b9.addActionListener(new ActionListener() {
              public void actionPerformed(ActionEvent e) {

            	  el.setGoFloor(8);  
              	  if(el.getGoFloor()!=el.getNowFloor()) {//电梯不在当前楼层
              	  	         	  	
              	  	if(el.getGoFloor()<el.getNowFloor()) {
              	  		while(el.getGoFloor()<el.getNowFloor()) {
              	  			el.ElevatorDown(8);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		
              	  	}
              	  	else {
              	  		while(el.getGoFloor()>el.getNowFloor()) {
              	  			el.ElevatorUp(8);
              	  			jl3k.setText(String.valueOf(el.getGoFloor()));
              	  			
              	  			jl2k.setText(String.valueOf(el.getNowFloor()));
              	  			try {
    								Thread.sleep(1 * 1000);
    							} catch (InterruptedException e1) {
    								// TODO Auto-generated catch block
    								e1.printStackTrace();
    							}
              	  		}
              	  		            	  	
              	  		
              	  	}
              	  
              	  }
              	  else {
              		  jl2k.setText(String.valueOf(el.getNowFloor()));
              	  }            
                  
                	
              }
          });
          
         jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//实现关闭窗口
    
    }
   	

    public static void main(String[] args) {
    	(new Elevator1()).Dianti1hao();
    	
//        if(1号电梯楼层x==y) {					//（仅为想法）动态改变表示电梯位置 -1楼时另外考虑
//        	c(y).setBackground(null);
//        	c(y-2).setBackground(null);
//        	c(y-1).setBackground(Color.GREEN);       	
//        }
    	
    }
    
}

开始准备设计更明白更直白的楼层灯显示，无奈技术水平不足，只能暂放。

心得

作为小白，通过这次失败认识到自己的不足。意识到命名方面还有不足，应多学习代码，将代码表达的简洁明了。学习新的算法，新的知识，将自己的代码编写能力不断提高！

更多相关内容

电梯调度算法 4 Java版
2010-11-06 12:33:40

用Java写的电梯调度算法4，模拟操作系统的进程调度，图形界面

收起

Java实现电梯调度算法

千次阅读 2018-12-15 15:35:40

Java实现电梯调度算法功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义...

Java实现电梯调度算法

电梯算法简介

当磁头正在由里向外移动时，电梯调度算法所选择的下一个访问对象应是其欲访问的磁道，既在当前磁道之外，又是距离最近的。这样由里向外地访问，直至再无更外的磁道需要访问时，才将磁臂换向，由外向里移动。这时，同样也是每次选择在当前磁道之内，且距离最近的进程来调度。 ——摘自百度百科
网上大多将电梯调度算法和扫描算法看作同一个算法，我们老师讲的时候将它们作了区分。扫描算法：需要扫描到该方向的最后一个磁盘才能返回，电梯算法则只要扫描到该方向欲访问的最后一个磁道就可以返回。
例如：磁盘有200个柱面，编号为0-199，当前移动臂在143号柱面上，向0方向移动。请求访问序列：86，147，91，177，94，150，102。
电梯调度算法访问的磁道面顺序为：102，94，91，86，147，150，177。
扫描算法访问的磁道面顺序为：102，94，91，86，0，147，150，177。

题目

假定一个磁盘有200个柱面，编号为0一199，在完成了磁道125外的请求后，当前正在磁道143处为一个请求服务。若请求队列的先后顺序为86，147，91，177，94，150，102，175，130。采用电梯调度算法写出磁头移动的顺序，并计算存取臂移动总量。

代码实现

我用java实现的是界面化，这样运行的时候大概可能看起来比较直观吧

定义柱面类Cylinder.java

public class Cylinder {
   //柱面号
   public int number;
   //初始化
   public Cylinder(int number) {
   	this.number = number;
   }
}

主类Elevator.java

界面初始化：

TextField tf1;
TextField tf2;
//显示界面的TextField队列
private ArrayList<TextField> textFields = new ArrayList<TextField>();
public void showUI(){
		//窗口初始化
		javax.swing.JFrame window  = new javax.swing.JFrame();
		window.setSize(800, 1000);
		window.setTitle("电梯算法");
		window.setDefaultCloseOperation(3);
		window.setLocationRelativeTo(null);
		JPanel jPanel = new JPanel();
		jPanel.setPreferredSize(new Dimension(0, 100));
		jPanel.setBackground(Color.white);
		Label l1 = new Label("Previews:");
		Label l2 = new Label("Now:");
		tf1 = new TextField("143");
		tf2 = new TextField("125");
		jPanel.add(l1);
		jPanel.add(tf1);
		jPanel.add(l2);
		jPanel.add(tf2);
		Button button1 = new Button("START");
		button1.setPreferredSize(new Dimension(100, 60));
		jPanel.add(button1);
		Button button = new Button("NEXT");
		button.setPreferredSize(new Dimension(100, 60));
		jPanel.add(button);
		JPanel jPanel2 = new JPanel();
		//设置网格布局
		GridLayout gridLayout = new GridLayout(10,20,0,3);
		jPanel2.setLayout(gridLayout);
		//添加TextView作为柱面
		for(int i=0;i<200;++i){
			TextField textField = new TextField(""+i);
			jPanel2.add(textField, gridLayout);
			textFields.add(textField);
		}
		jPanel2.setBackground(Color.blue);
		window.add(jPanel,BorderLayout.NORTH);
		window.add(jPanel2, BorderLayout.CENTER);
		window.setVisible(true);
		button.addActionListener(this);
		button1.addActionListener(this);
	}

调用showUI()方法后，显示的窗口是这样的：效果图
初始化访问序列

//存储柱面号的数组
private int a[] = new int[]{86,147,91,165,177,94,150,102,175,130};
//这个后面会用到
int b[] = new int[]{86,147,91,177,94,150,102,165,175,130};
//需要访问柱面的队列
private ArrayList<Cylinder> cylinderlist = new ArrayList<Cylinder>();
//初始化访问的柱面
public void init(){
	cylinderlist = new ArrayList<Cylinder>();
	for(int i=0;i<a.length;++i){
		Cylinder cylinder = new Cylinder(a[i]);
		cylinderlist.add(cylinder);
	}
	//使用匿名类排序
	Collections.sort(cylinderlist, new Comparator<Cylinder>() {
		public int compare(Cylinder h1, Cylinder h2) {
	        	return h1.number-h2.number;
	         }
	   	});
	//将要访问的柱面设为红色
	for(int i=0;i<b.length;++i){
		textFields.get(b[i]).setBackground(Color.RED);
		}
	//当前柱面号设为灰色
	textFields.get(now).setBackground(Color.gray);
}

寻找下一个要访问的柱面号
如果现在是向外移动（向199号方向移动），选择大于当前柱面号的访问者中柱面号最小者

private int now = 125;//当前柱面号
private int previews =143;//之前完成的柱面号服务请求
public void findMin(){
	//赋值给完成的柱面号
	previews = now;
	//之前已经用匿名类排序后，只要选择队列中该位置的后一个元素就可以了
	int no = 0;
	for(int i=cylinderlist.size()-1;i>=0;--i){
		Cylinder cylinder = cylinderlist.get(i);
		if(cylinder.number>=now)no = i;
	}
	Cylinder c = cylinderlist.get(no);
	//访问到后将选中的柱面移除访问序列
	cylinderlist.remove(no);
	//将选中的柱面号赋值给当前移动臂在的位置
	now = c.number;
}

如果现在是向里移动（向0号方向移动），选择小于当前柱面号的访问者中柱面号最大者，类似

public void findMax(){
	previews = now;
	int no = 0;
	for(int i=0;i<cylinderlist.size();++i){
		Cylinder cylinder = cylinderlist.get(i);
		if(cylinder.number<=now)no = i;
	}
	Cylinder c = cylinderlist.get(no);
	cylinderlist.remove(no);
	now = c.number;
}

改变图形界面移动的颜色

public void display(){
	//判断如果是向里移动
	if(previews-now<0){
		//循环为之前完成的柱面号至当前柱面号
		for(int k=previews;k<now;++k){
			//将当前TextField的颜色置为灰色
			TextField textField2 = textFields.get(k+1);
			textField2.setBackground(Color.GRAY);
			//将刚才访问过的TextField颜色置为白色
			TextField textField = textFields.get(k);
			textField.setBackground(Color.WHITE);
			//休眠时间，可以调整移动的速度
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	//与上面类似
	if(previews-now>0){
		for(int k=previews;k>now;--k){
			TextField textField2 = textFields.get(k-1);
			textField2.setBackground(Color.GRAY);
			TextField textField = textFields.get(k);
			textField.setBackground(Color.WHITE);
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

为按钮加点击事件

public void actionPerformed(ActionEvent e) {
	//获取点击事件
	String event = e.getActionCommand();
	//判断点击了哪个按钮
	switch (event) {
	case "NEXT":
		if(cylinderlist.size()>0){
			//向外移动调用findMin()方法
			if ((now-previews)>0&&now!=199){
				findMin();
			//输出看一下结果
			System.out.println("previews:"+previews+" now:"+now);
			//显示效果
			display();
			}else {
				//向里移动调用findMax()方法
				findMax();
				System.out.println("previews:"+previews+" now:"+now);
				display();
				}
		}else{
			System.out.println("已完成");
		}
		break;
	case "START":
		//获取文本框中的数字
		previews = Integer.parseInt(tf1.getText());
		now = Integer.parseInt(tf2.getText());	
		//初始化
		init();
		System.out.println(now+" "+previews);
		break;
		default:
			break;
		}
	}

调用方法

public static void main(String[] args) {
		Elevator elevator = new Elevator();
		elevator.showUI();
	}

到这所有的代码就写完了，加起来不会超过200行。如果嫌点击太慢，可以弄个循环，循环次数为访问队列的长度。想计算总共移动的量，可以定义一个变量，初始值定义为0，每次移动的时候增加|now-previews|。

效果图

gif
Console

收起

展开全文

图形界面

电梯调度算法总结
2021-03-13 21:00:33

二：初步构想阶段我们先尝试解决最核心的问题，即电梯的调度算法问题，初步构思是这样的，电梯根据当前控制器内所要到的楼层信息判断是向下运行或向上运行，并向上或向下运行至控制器内楼层的最大或最小值，期间出现...

一：任务要求

本次的程序任务和要求如上图所示，需要有4部电梯同时运行，每部电梯都有自己的限制且被同一控制器所控制，希望有图形显示效果，本次的任务我们组已经完成，关于编程的历程与总结现在就一一道来。

二：初步构想阶段

我们先尝试解决最核心的问题，即电梯的调度算法问题，初步构思是这样的，电梯根据当前控制器内所要到的楼层信息判断是向下运行或向上运行，并向上或向下运行至控制器内楼层的最大或最小值，期间出现的所有楼层信息都加入到控制器内，若有比最值更大或更小的信息不予理会，只是加入控制器中，每到一楼层就判断控制器内是否有该楼层，有则在该层停留，并移除控制器内该层信息，无则继续运行，运行至最值处，重新从控制器内找出最值，并判断向上或向下运行，如此循环。当控制器内没有信息后，电梯等待一段时间后会回到初值处。

代码如下：

1 public void down()//定义一个下降函数便于复用

2 {3 for(;cout>=con.getmin();cout--)4 {5 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.black);6 if(con.getlist(this.mode).contains(cout))7 {8 con.remove(cout);9 System.out.println("到达"+cout+"层");10 changepeople();11 try{12 Thread.sleep(500);13 } catch(InterruptedException e) {14 //TODO Auto-generated catch block

15 e.printStackTrace();16 }17 if(cout==con.getmin())18 break;19 }20 if(cout==con.getmin())21 break;22 try{23 Thread.sleep(200);24 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.white);25 } catch(InterruptedException e) {26 //TODO Auto-generated catch block

27 e.printStackTrace();28 }29 }30 }31 public void run() //电梯运行算法主要运行函数

32 {33 while(true)34 {35 while(!con.getlist(this.mode).isEmpty())36 {37 con.setmami();38 if(con.getmax()>cout) //和下面的if组成判断电梯是否向上运行否则向下运行

39 {40 if(con.getmin()>cout||(con.getmax()-cout)<=(cout-con.getmin()))41 {42 for(;cout<=con.getmax();cout++)43 {44 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.black);45 if(con.getlist(this.mode).contains(cout))46 {47 con.remove(cout);48 System.out.println("到达"+cout+"层");49 changepeople();50 try{51 Thread.sleep(500);52 } catch(InterruptedException e) {53 //TODO Auto-generated catch block

54 e.printStackTrace();55 }56 if(cout==con.getmax())57 break;58 }59 if(cout==con.getmax())60 break;61 try{62 Thread.sleep(200);63 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.white);64 } catch(InterruptedException e) {65 //TODO Auto-generated catch block

66 e.printStackTrace();67 }68 }69 }70 else

71 down();72 }73 else //电梯向下运行的算法

74 down();75 }76 try{77 Thread.sleep(1000);78 } catch(InterruptedException e) {79 //TODO Auto-generated catch block

80 e.printStackTrace();}81 while(con.getlist(this.mode).isEmpty()&&cout!=incout) //无任务回到初始楼层的函数

82 {83 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.white);84 if(cout>incout)85 {86 cout--;87 vie.map.get(new Point(250-50*panmode,500-cout*20)).setBackground(Color.black);88 try{89 Thread.sleep(200);90 } catch(InterruptedException e) {91 //TODO Auto-generated catch block

92 e.printStackTrace();93 }94 }95 if(cout

103 e.printStackTrace();104 }105 }106 }107 }108 }109 }

我这里是从全部完成后的代码上截取出的算法部分，有图形显示的代码和一些实现其他功能的代码，初步构想时只是做出了算法，并在dos模拟。

三：开始构思整个代码结构

代码用java编写，需要一个控制器类型，一个电梯类型，此电梯类型需要能设置多个模式，并且实现多线程运行，最后还要定义一个图形的显示类。这只是初步构思，后面还要加入上人下人判断人数的方法。

各模块的代码如下：

1，主程序模块

1 public classThemin {2 public static voidmain(String[] args)3 {4 View vie=new View(); //图形界面对象

5 Contro con=new Contro(vie); //控制器对象

6 vie.setcon(con);7 Elevator ele1=new Elevator(con,vie); //一个电梯对象

8 ele1.setpeople(10); //设置电梯最大载人

9 ele1.setmode(0,0); //设置电梯模式

10 ele1.setinitcout(2); //设置电梯初始楼层

11 Elevator ele2=newElevator(con,vie);12 ele2.setpeople(20);13 ele2.setmode(0,3);14 ele2.setinitcout(5);15 Elevator ele3=newElevator(con,vie);16 ele3.setpeople(10);17 ele3.setmode(1,1);18 ele3.setinitcout(11);19 Elevator ele4=newElevator(con,vie);20 ele4.setpeople(10);21 ele4.setmode(2,2);22 ele4.setinitcout(8);23 (new Thread(ele1)).start(); //电梯运行

24 (newThread(ele2)).start();25 (newThread(ele3)).start();26 (newThread(ele4)).start();27 }28 }

创建图形对象，创建控制器对象，创建4个各种类型的电梯对象，开始运行。

2，控制模块

1 class Contro//控制模块类

2 {3 private ArrayList arr;//记录需要到达的楼层

4 private Integer max,min;//记录到达楼层的最大值，最小值

5 private ArrayList jarr;//设置一个存奇数楼层的表

6 private ArrayList darr;//存偶数楼层

7 View vie;8 Contro(View vie)//构造函数

9 {10 arr=new ArrayList();11 jarr=new ArrayList();12 darr=new ArrayList();13 max=0;14 min=0;15 this.vie=vie;16 }17 public void add(Integer i)//添加到达楼层

18 {19 if(i>=0&&i<=21)20 {21 if(!arr.contains(i))22 {23 vie.map.get(new Point(300,500-i*20)).setBackground(Color.red);24 arr.add(i);25 if(i%2==0)26 darr.add(i);27 else

28 jarr.add(i);29 }30 }31 }32 public void remove(Integer i)//取消一个任务楼层

33 {34 vie.map.get(new Point(300,500-i*20)).setBackground(Color.white);35 arr.remove(i);36 if(i%2==0)37 darr.remove(i);38 else

39 jarr.remove(i);40 }41 public void setmami()//根据当前信息设置最大值，最小值

42 {43 min=arr.get(0);44 max=arr.get(0);45 for(Integer in:arr)46 {47 if(in>max)48 max=in;49 if(in

54 {55 returnmin;56 }57 public Integer getmax()//得到最大楼层值

58 {59 returnmax;60 }61 public ArrayList getlist(int mode)//得到存储楼层信息的列表

62 {63 if(mode==0)64 returnarr;65 if(mode==1)66 returnjarr;67 if(mode==2)68 returndarr;69 else

70 return null;71 }72 }

这是控制模块的代码，方法有add()添加一个楼层信息，remove()取消一个楼层信息，getmin(),getmax()获取最小和最大楼层,getlist()获取控制信息的链表，setmami()根据当前信息求最大最小楼层。

3，电梯模块

1 class Elevator implements Runnable//一个电梯的类型，实现多线程

2 {3 private Integer cout,incout;//记录电梯位置

4 private int peoplecout; //记录电梯内人数

5 private int people; //电梯允许载人最大人数

6 int mode,panmode; //电梯的模式

7 View vie;8 Contro con;9 Elevator(Contro con,View vie)//构造函数

10 {11 this.con=con;12 this.vie=vie;13 this.peoplecout=0;//设置每个电梯初始人数为0

14 }15 public void setmode(int mode,int panmode)//设置电梯的模式 0全 1单 2双

16 {17 this.mode=mode;18 this.panmode=panmode;19 }20 public void setinitcout(Integer cout)//设置初始楼层

21 {22 this.incout=cout;23 this.cout=cout;24 vie.map.get(new Point(250-panmode*50,500-cout*20)).setBackground(Color.black);25 vie.map.get(new Point(250-panmode*50,60)).setText(peoplecout+"");26 }27 public void setpeople(int i)//设置最大载人的函数

28 {29 this.people=i;30 }31 public void changepeople()//到达某层后人的上下情况设置函数

32 {33

34 }35 public void down()//定义一个下降函数便于复用

36 {37

38 }39 }

由于代码有些长，一些方法的内部实现省略了，该电梯类首先要实现Runnable接口实现多线程,使多部电梯可以同时运行，setmode()设置电梯的模式，单楼层，双楼层，或全楼层，setinitcout()设置电梯的初始楼层,setpeople()设置电梯的最大载人数的函数,changepeople()电梯每到一层上下人数记录的函数,run()主运行函数。该类型定义时需要把图形界面对象，控制器对象传进来。

4，图形显示模块

1 class View extends JFrame //此类是电梯的图形显示类

2 {3 HashMap map=new HashMap();4 privateJPanel panel;5 Contro con;6 JDialog dia;7 JTextField uptex,downtex;8 intupcout,downcout;9 JButton jbu;10 private JButton contro=newJButton();11 View()12 {13 init();14 }15 public void init()//初始化

16 {17 this.setBounds(250,100,500,550);18 this.add(setpanel());19 this.setTitle("键盘0-9对应0-9层f1-f12对应10-21层");20 this.setdia();21 this.setResizable(false);22 myevent();23 this.setVisible(true);24 }25 public void setcon(Contro con)//控制模块传进来

26 {27 this.con=con;28 }29 public void setdia()//设置人数的窗口

30 {31

32 }33 public JPanel setpanel()//设置模板

34 {35

36 }37 public void getcout()//得到上下人数的函数

38 {39

40 }41 private void myevent()//所有监听器

42 {43

44 }45 }

上面是该电梯的图形显示类(内部实现已省略)，思路很简单，首先类继承JFarme,setpanel()设置模板,setdia()输入上下人数的弹出窗口,getcout()接收上下人数的窗口,myevent()所有的监听器，主要是监听键盘信息，键盘0-9对应电梯0-9层，f1-f12对应电梯10-21层。初步显示效果如下图,还没有添加电梯。最右边是楼层好，最上层是每部电梯的当前人数。

5，显示效果

添加电梯后及运行效果如下，每添加一个楼层信息对应的层数会变红,黑色代表电梯。效果还是很明显的

没添加电梯的显示效果

刚初始化完，没有添加控制信息，黑色代表电梯，最上部有当前人数的值。

添加控制信息后对应楼层变红，电梯会自动运行，可实时键盘添加控制信息。

到达一个任务楼层后会弹出窗口，输入上下车的人数，最上面的计数会变化，超出最大值要重新输入，小于0会直接抛出异常程序终止。

四，遇到问题的解决方法

1，输入上下人数窗口的弹出问题

在现实中，4部电梯的上下人是同时进行的，这可以实现，把记录人数的方法不设置同步就可以了，也就是程序运行时可能最多会弹出4个输入窗口，这虽然符合现实但不利于我们在程序里模拟电梯运行，而且4个窗口同时计数也会极大的增加程序的难度，所以我直接在变化人数的方法里设置了同步，一次只会弹出一个窗口，剩下的电梯人数变化时需要等待正在改变人数的电梯运行完才能变化，也就是说，一次只能一个电梯改变其内的人数，其后的电梯运行到任务楼层后只能停在原地等待，改变完的电梯会继续运动，这虽然和现实不符，但对于一个电梯模拟程序来说更便于使用。

2，键盘监听的问题

电梯楼层是0-21层，键盘所对应数字只有0-9，所以我选择用f1-f12代替10-21层，只需键盘监听到的值减去一个特定的数字就可完成。

五，不足之处

本打算实现实时控制，即实时搜索最大值最小值，实时判断控制信息是否为空，本以为很简单，只需每次添加控制信息时使其有序，这样实时取最前或最后面的值判断最大最小值就可以了，这种电梯我也实现了，在只有一个电梯时会很好的运行，然而在电梯变多后，因为一些并发问题使程序容易出现bug，没法解决故放弃，其间思考可能是移除电梯控制信息和判断电梯控制信息出现并发错误导致，同步代码后依然未解决。

六，总结

通过本次结对编程我学习到了很多，一个人的力量是有限的，尤其是在编程这种高度需要逻辑思维的事情上，多个人一起合作更容易解决程序漏洞，让程序尽可能完美，每个人的认知也是有局限的，多人合作更容易出来各种奇思妙想，让程序功能更加丰富多彩，结对编程也考验着我们的合作能力，这些都让我在这次编程中获得了极大的进步。

收起

展开全文
电梯调度编写(oo-java编程)
2021-02-12 21:25:51

第二单元的问题是写一个关于电梯调度的程序。...在这个单元中任务仍然被分为三个小任务：①完成单电梯(随时允许输入)②单电梯+(楼层增加负层，必须使用比先来先服务更加高效的算法)③多电梯调度(增加...

第二单元的问题是写一个关于电梯调度的程序。

需要模拟一个多线程实时电梯系统，从标准输入中输入请求信息，程序进行接收和处理，模拟电梯运行，将必要的运行信息通过输出接口进行输出。

主要锻炼学生的多线程程序编写能力。

由于需要实时的输入和输出，我们不得不采用多线程。

在这个单元中任务仍然被分为三个小任务：

①完成单电梯(随时允许输入)

②单电梯+(楼层增加负层，必须使用比先来先服务更加高效的算法)

③多电梯调度(增加重量限制、楼层停靠限制、换乘)

一、调度算法设计

单电梯的调度算法：

我在网上寻找调度算法后发现，网上大多的算法采用的都是静态算法，几乎没有动态算法。所以，我自己设计一个算法(或者说是参照实际使用中电梯的运转方式设计的算法)，如下：

①查看该楼层是否有请求(包括进电梯和出电梯)，有则开门转②，否则转③

② 让请求的人进出，并进行输出，所有请求进的人将这些人的出电梯请求同时加入电梯的请求序列中。关门转③

③沿电梯运动方向查看是否有任意类型的请求，如果有请求则向该方向运动一层转④，否则改变方向查看请求。如果在另一方向上有请求，则想这一方向移动一层转④。如果两个方向都没有请求则进程休息(wait)，等待唤醒，唤醒后转④。

④如果不在输入任何需求则结束，否则转①。

多电梯的调度算法：

多电梯我觉得可以在原来的基础上进行修改，在调度器分配请求时通过某种方式将请求分给不同的电梯，然后每台电梯按照单电梯的调度算法进行运行即可。由于本人的多电梯的调度算法效率比较低，所以这里就不多赘述，可以参考其他同学的多电梯调度算法。

二、程序分析

重要符号意义说明：

ev(G)基本复杂度是用来衡量程序非结构化程度的.

Iv(G)模块设计复杂度是用来衡量模块判定结构，即模块和其他模块的调用关系。

v(G)是用来衡量一个模块判定结构的复杂程度，数量上表现为独立路径的条数。

LOC: Line of Code

NCLOC:Non-Commented Line Of Code

P1

oo度量

LOC

NCLOC

方法个数

属性个数

Elevator

183

169

5

2

Main

9

9

1

0

Midlist

26

26

5

2

OrderClass

46

42

2

7

diagram类图

Sequence Diagram

P2

oo度量

LOC

NLOC

方法个数

属性个数

Elevator

219

206

10

7

Main

11

11

1

0

Midlist

33

33

6

2

OrderClass

46

62

2

5

diagram类图

Sequence Diagram

P3

oo度量

LOC

NLOC

方法个数

属性个数

Chart

62

62

5

1

Elevator

307

278

13

14

Entry

8

8

1

0

Main

12

12

1

0

Midlist

367

322

21

19

Orderlist

46

42

2

5

类图

Sequence Diagram

前面的时序图看着太复杂，而三次作业的结构大致一致，于是我做了一个简易版的sequence diagram。

优点：在第一次作业的时候就做好了基础的调度设计，是一个比较有效的设计，在随后的两次作业中修改的内容相对较少，也没有第一单元的重构情况，从类图上看，大体的结构并没有很大的变动。由于调度器不是一个进程，并发控制的难度比较低。

缺点：功能不够独立，在新需求出现时，常常要重新独立出一部分功能。设计时缺少借口等这类设计，导致一修改需求就会违背oo的设计SOLID原则。实际上第一次的设计从某种角度上来讲是存在瑕疵的，调度器不是一个进程，所以调度器在功能欲发复杂的情况下越来越庞大，但是却没有并行性，某种程度上限制了运行的性能。

三、多线程的协同和同步控制

在第一次作业中，需要考虑如何停下自己的程序，我采用的是让中间的管道传递一个状态，即输入端是否关闭，如果关闭则再电梯的所有请求处理完后停止进程。

在第二次作业中，实际上并没有太多的改变(因为我第一次就已经做了优化)，但是这次需要避免cpu轮循的问题。那么我在之前的基础上补充电梯wait的要求，应该是输入队列里没有东西，而且输入进程没有停止。

在第三次作业中，为了继承之前作业的架构，我并没有将调度器作为一个独立的进程。但是由于调度器中可能没有属于电梯的请求，这个时候电梯就应该wait，但是就算输入结束了也不能轻易的结束进程，因为有些人可能需要换乘(但这个需求可能还没有出现)。所以我做了下面一个表来处理这个相对复杂的问题。

电梯可以获得的请求

输入端

有无分割的请求

(换乘请求)

电梯动作

√

-

-

运行

×

√

-

sleep

×

-

√

sleep

×

√

√

结束

四、分析自己程序的bug

第一次作业中，程序结束的控制计较容易出bug，因为在程序结束输入的时候(ctrl+D)，仅凭借队列里是否有未服务的对象是不够的，还需要有一个判断标志，在电梯每次轮循后对输入是否结束进行判断，从而决定是否结束电梯线程。

第二次作业中，由于不能轮循(因为太占cpu时间)，所以必须使用wait/notify方法，这个时候需要考虑好线程有没有可能会死锁，如何才能保证不死锁以及如何控制线程结束。(这三个问题是第二次作业中比较重点的bug/问题)

第三次作业，由于程序难度的增加，程序的复杂，轮循和，进程意外退出，进程没有被唤醒再次成为问题的关键。在这一次中，我最后应该将轮循和进程退出可能的情况进行列表推演，当当靠脑子想这件事情是很不靠谱的！

五、寻找他人bug(我不做互测)

多线程中，PV操作及其重要，关于线程之间的变量必须synchronize，可以着重看这一部分的代码，而且各种状态的传播也会在这一部分中，这一部分代码是最容易出bug的。

根据这次多线程的特点，应该着重考虑多线程的死锁、轮循这两个问题，着重分析他人代码中占用的位置。而且多线程的bug不一定能够触发，所以可能要多试几次。

相比于第一单元，bug的查找更加困难，因为有一些bug是概率性出现的，所以在测试中可以能需要对一个测试样例输入多次(或者选择不同的时间节点输入)。

六、SOLID原则分析

S.O.L.I.D是面向对象设计和编程(OOD&OOP)中几个重要编码原则(Programming Priciple)的首字母缩写。

SRP原则分析：在三次作业中，各个类的职责区分的非常清楚，启动线程、调度器线程、电梯线层、请求输入线程都能找到对应的类。

OCP原则分析：在这三次作业中(特别是第三次作业)，我没有让三个电梯分别使用不同的策略(也就是说除了基础属性，其他他们都是相同的)，所以不存在违背OCP原则的问题。

LSP原则、DIP原则分析:基于这次作业的难度，没有进行抽象和继承。

ISP原则分析：在设计的过程中，我并没有特别在意接口这个问题，所以我觉得这个单元的作业，在这个方面是有问题的。

七、心得体会

这次多线程的作业，让我全面理解了多线程。虽然在不需要涉及各种相对复杂的锁，但是仍然让我在大体上理解了多线程编写所需要的注意点。我希望接下来能够对我的编码进行指引，增加代码的限制，让我的代码更加工业化(能适应企业的要求)。

收起

展开全文
电梯调度算法（java实现）
2009-11-10 18:16:06

电梯调度算法是用来模拟进程管理。一般操作系统课上会需要，哈哈

收起
驱动调度 java模拟电梯调度算法实现驱动调度
2011-12-14 14:38:08

操作系统中模拟驱动调度 java模拟电梯调度算法实现驱动调度

收起
磁盘调度算法java实现
热门讨论 2013-05-30 20:54:38

随机生成磁盘序列用java实现了FIFO、SSTF、SCAN和C-SCAN算法模拟磁盘调度有用户界面，有序列结果记录，有计算移动磁道数

收起
基于Java的移动臂磁盘调度算法（动态显示）
2019-01-07 09:12:40

使用Java实现操作系统中移动臂磁盘调度算法，包括先来先服务调度算法、最短寻找时间优先调度算法、电梯调度算法、单向扫描和双向扫描调度算法，有简单的图形用户界面和通过线程动态显示

收起
用Java写的电梯调度算法10
2010-11-06 12:49:57

用Java写的电梯调度算法10，操作系统课程作业，模拟进程的调度

收起
基于JAVA的电梯调度模拟
千次阅读 2018-12-24 11:16:00

一、项目要求概述1.1 项目目的通过控制电梯调度，实现操作系统调度过程学习特定环境下多线程编程的方法学习调度算法1.2 开发环境语言：java系统平台：全平台（具备java环境）IDE：Intellij IDEA产品呈现模式：jar包...

收起
编程之美--小飞--电梯调度算法 java实现
千次阅读 2013-10-05 11:15:31

* 编程之美小飞 电梯调度算法 * 在繁忙的时间，每次电梯从一层往上走时，我们只允许电梯停在其中的某一层。 * 所有乘客都从一楼上电梯，到达某层楼后，电梯听下来，所有乘客再从这里爬楼梯到自己...

收起
操作系统：Java模拟磁盘调度算法（先来先服务、最短寻道优先、电梯调度方法）
千次阅读 2020-06-08 09:48:54

* 代码功能：使用先来先服务、最短寻道优先、电梯调度方法进行调度。 * 求出平均移动道数。当前读写头在90号，向磁道号增加的方向移动。 * */ public class DiskScheduling { public static void main(String ...

收起
模拟电梯调度算法，实现对磁盘的驱动调度
2010-11-26 22:05:58

操作系统上机实验模拟电梯调度算法，实现对磁盘的驱动调度对磁盘进行移臂和旋转调度

收起
Java~操作系统实验模拟电梯调度算法，实现对磁盘的调度。
千次阅读 2020-06-16 12:48:48

模拟电梯调度算法，实现对磁盘的调度。实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器，负担着繁重的输入输出任务，在多道程序设计系统中，往往同时会有若干个要求...

收起
群控电梯调度算法
千次阅读 2021-01-11 22:11:14

Java面试笔试面经、Java技术每天学习一点公众号Java面试关注我不迷路1.传统电梯调度算法1.1先来先服务算法(FCFS)先来先服务(FCFS-First Come First S...

收起

人工智能编程语言
操作系统作业驱动调度用电梯调度算法 模拟
2011-12-14 15:10:54

本实验要求模拟设计一个去驱动调度程序，观察驱动调度程序的动态运行过程，采用电梯调度算法，实现对磁盘的读写管理。先假设有5个进程等待使用磁盘，用随机数模拟接受请求，确定程序的运行顺序。内附源码，实验流程...

收起
编程之美1.8：小飞的电梯调度算法
千次阅读 2016-12-02 13:52:10

问题：由于楼层并不高，在繁忙时段，每次电梯从一层往上走时，我们只允许停到其中某一层。...import java.util.Scanner;public class BeautyPro18 { /** * @param args */ public static void main(Strin

收起

编程之美
操作系统实验 Java模拟处理器调度存储管理磁盘移臂调度文件管理算法
2019-06-22 11:24:22

处理器调度算法: 先来先服务, 时间片轮转, 短作业优先, 最高响应比优先存储管理: FIFO, LRU 磁盘移臂调度: SSTF, SCAN 文件管理: 运用空闲盘块表的方式组织磁盘空间, 模拟文件的 create() 和 delete() 操作

收起
电梯调度算法
万次阅读 多人点赞 2018-06-17 18:01:10

它作为计算机系统的辅助存储器，担负着繁重的输入输出任务、在多道程序设计系统中，往往同时会有若干个要求访问磁盘的输入输出请求等待处理，这时我们就需要采用一种合适的调度算法来使各个进程对磁盘的访问时间最少...

收起
java实现的电梯调度
2012-11-30 20:37:10

操作系统项目，用java实现的电梯调度。五部电梯，可同时工作，模拟线程调度。操作系统项目，用java实现的电梯调度。五部电梯，可同时工作，模拟线程调度。操作系统项目，用java实现的电梯调度。五部电梯，可同时...

收起
yidongbi.zip(编写程序实现移动臂调度算法的模拟)
2019-06-24 19:12:22

能够实现先来先服务、最短寻找时间和电梯调度算法。先来先服务调度算法：只根据请求者的时间先后顺序，先请求的先得到服务。最短寻找时间优先调度算法：总是使寻找时间最短的请求最先得到服务，跟请求者的请求时间...

收起
操作系统----磁盘调度（电梯调度算法）
万次阅读 2019-01-04 21:36:47

模拟电梯调度算法，实现对磁盘的调度。二、实验目的磁盘是一种高速、大量旋转型、可直接存取的存储设备。它作为计算机系统的辅助存储器，负担着繁重的输入输出任务，在多道程序设计系统中，往往同时会有若干个要求...

收起
磁盘调度算法电梯调度
2010-03-16 21:16:58

为电梯调度算法，有程序和文档，可运行，操作系统课程设计。

收起
磁盘调度管理实验——移臂调度算法代码（Java）
2022-05-15 11:54:51

5.电梯调度算法代码如下： //测试例子 98 183 37 122 14 124 65 67 -1 //测试例子 98 183 37 122 14 124 65 67 -1 //测试例子 98 183 37 122 14 124 65 67 -1 //测试例子 98 183 37 122 14 124 65 67 -1 import ...

收起
编程之美之小飞的电梯调度算法（多种解法）---Java语言
2021-02-27 16:40:59

1.题目情景我们假设都是从一楼上电梯的，而至于讯电梯停在其中的某一层。即所有的乘客都从一楼上电梯，到达某层之后，电梯停下来，所有乘客再从这里爬楼梯到自己的目的层。在一楼的时候，每个乘客选择自己的目的层，...

收起
用Java写的电梯调度算法
2010-11-06 12:46:06

用Java写的电梯调度算法7，操作系统作业，模拟进程调度算法

收起