进程调度

package com.pcb.dao;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import com.pcb.dao.SortByPriNumber;
import com.pcb.entity.PCB;

/*******************************************************************************
 * 
 * @author Administrator
 * @description 进程调度
 */
public class ProcessScheduling {

	private static List<PCB> pcbList = new LinkedList<PCB>();// 创建进程列表

	// private static List<PCB> pcbQueue=new ArrayList<PCB>();//定义进程队列
	public static void main(String[] args) {
		initPCB();// 初始化进程控制块
		doWithPCB();// 进程处理
	}

	/**
	 * 进程初始化:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等
	 */
	@SuppressWarnings("unchecked")
	public static void initPCB() {

		Scanner io = new Scanner(System.in);

		System.out.println("请输入进程的相关信息：");
		System.out.println("进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态");
		String oper = "n";// 是否继续输入进程
		do {
			PCB pcb = new PCB();// 创建进程实例
			System.out.print("进程名：");
			pcb.setPcbName(io.next());
			System.out.print("优先数：");
			pcb.setPriNumber(io.nextInt());
			// System.out.println("到达时间");
			pcb.setArrivalTime(pcbList.size() + 1);
			System.out.println("需要时间：");
			pcb.setNeedTime(io.nextInt());
			pcb.setUsedTime(0);
			// pcb.setPcbState(1);
			pcb.setPcbState("Wait");
			pcbList.add(pcb);// 把进程实例添加到进程列表中
			System.out.print("是否继续输入进程(y|n)");
			oper = io.next();
		} while (oper.equals("y"));

		System.out.println("进程数：" + pcbList.size() + "个");
		Collections.sort(pcbList, new SortByPriNumber());// 根据优先数排列
		// showPCBList(pcbList);// 显示进程列表信息

	}

	@SuppressWarnings("unchecked")
	public static void doWithPCB() {

		/*
		 * int count = 0;// 就绪状态的进程个数； for (int i = 0; i < pcbList.size(); i++)
		 * { if (pcbList.get(i).getPcbState().equals("Wait")) { count++; } }
		 * 
		 * // 如果就绪队列为空结束进程 if (count == 0) { return; }
		 */
		while (pcbList.size() > 0) {

			Collections.sort(pcbList, new SortByPriNumber());// 根据优先数排序
			List<PCB> priNumPcbs = new LinkedList<PCB>();// 优先数相同的进程列表
			showPCBList(pcbList);
			PCB pcb = new PCB();// 创建进程实例
			pcb = pcbList.get(pcbList.size() - 1);// 取出优先数最高的进程
			int priorityNum=pcb.getUsedTime();//优先数
            int arrivalTime=pcb.getArrivalTime();//到达时间
			for (int i = 0; i < pcbList.size() - 1; i++) {
				PCB commonPriPcb = new PCB();// 相同优先数的进程
				commonPriPcb = pcbList.get(i);
				if (priorityNum==commonPriPcb.getPriNumber()) {
					priNumPcbs.add(commonPriPcb);
					Collections.sort(priNumPcbs, new SortByArrivalTime());// 根据到达时间排序(先来先服务)

				}
			}
			if (priNumPcbs.size() != 0) {
				pcb = priNumPcbs.get(0);// 获得优先数相同的到达时间最早的进程
				System.out.println("最早到达的" + pcb.getArrivalTime());
			}

			System.out.println("就绪队列" + pcb.getPcbName() + "进程投入运行");

			pcbList.remove(pcb);// 把进程就绪队列中调入运行
			pcb.setPcbState("Run");// 状态为运行状态
			pcb.setPriNumber(pcb.getPriNumber() - 1);// 优先级减一
			pcb.setUsedTime(pcb.getUsedTime() + 1);// 已用时间增加一个时间片刻
			System.out.println("进程名:" + pcb.getPcbName() + "\t优先数:"
					+ pcb.getPriNumber() + "\t到达时间:" + pcb.getArrivalTime()
					+ "\t需要时间" + pcb.getNeedTime() + "\t状态:"
					+ pcb.getPcbState());
			if (pcb.getUsedTime() != pcb.getNeedTime()) {// 如果运行进程已占用时间达到需要时间，不撤销该进程
				pcb.setPcbState("Wait");
				pcb.setArrivalTime(pcbList.size() + 1);// 到达时间
				pcbList.add(pcb);// 把该进程重新调入就绪队列

			}

		}

	}

	/**
	 * 显示进程列表信息
	 * 
	 * @param pcbList
	 */
	public static void showPCBList(List<PCB> pcbList) {
		System.out
				.println("--------------------------------------------------------------------------------");
		System.out.println("进程名\t\t优先数\t\t到达时间\t\t需要时间\t\t状态");
		/*
		 * 循环访问进程列表
		 */
		for (PCB p : pcbList) {
			System.out.println(p.getPcbName() + "\t\t" + p.getPriNumber()
					+ "\t\t" + p.getArrivalTime() + "\t\t" + p.getNeedTime()
					+ "\t\t" + p.getPcbState());
		}
		System.out.println();
	}
}

package com.pcb.dao;

import java.util.Comparator;

import com.pcb.entity.PCB;

public class Sort implements Comparator<Object> {
	public int compare(Object ob1, Object ob2) {
		PCB pcb1 = (PCB) ob1;
		PCB pcb2 = (PCB) ob2;
		if (pcb1.getPriNumber() > pcb2.getPriNumber()) {
			return 1;
		} else if (pcb1.getPriNumber() == pcb2.getPriNumber()) {
			if (pcb1.getArrivalTime() > pcb2.getArrivalTime()) {
				return 1;
			} else {
				return 0;
			}

		} else {
			return 0;
		}
	}

}

package com.pcb.entity;
import java.io.Serializable;

/***
 * 
 * @version 1.0
 * @author YYH
 * @description 进程控制块类    Process scheduling
 * 进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
 */
public class PCB implements Serializable {

	
	private static final long serialVersionUID = -4551627274875247089L;
	
	/**
	 * 进程名
	 */
	private String pcbName;
	public String getPcbName() {
		return pcbName;
	}
	public void setPcbName(String pcbName) {
		this.pcbName = pcbName;
	}
	
	/***
	 * priorityNumber优先数
	 */
	private int priNumber;
	public int getPriNumber() {
		return priNumber;
	}
	public void setPriNumber(int priNumber) {
		this.priNumber = priNumber;
	}
	
	/**
	 * 到达时间
	 */
	private int arrivalTime;
	public int getArrivalTime() {
		return arrivalTime;
	}
	public void setArrivalTime(int arrivalTime) {
		this.arrivalTime = arrivalTime;
	}
	
	/**
	 * 需要运行时间
	 */
	private int needTime;
	public int getNeedTime() {
		return needTime;
	}
	public void setNeedTime(int needTime) {
		this.needTime = needTime;
	}
	
	/**
	 * 已用时间
	 */
	private int usedTime;
	public int getUsedTime() {
		return usedTime;
	}
	public void setUsedTime(int usedTime) {
		this.usedTime = usedTime;
	}
	
	/**
	 * 进程状态 1:表示就绪状态  2：表示运行状态    3：表示完成状态
	 
	private int pcbState;
	public int getPcbState() {
		return pcbState;
	}
	public void setPcbState(int pcbState) {
		this.pcbState = pcbState;
	}
	*/
	/*
	 * 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
	 */
	private String pcbState;
	public String getPcbState() {
		return pcbState;
	}
	public void setPcbState(String pcbState) {
		this.pcbState = pcbState;
	}

}