声明进程类progress：

public class progress {
	int runtime;	//进程运行时间
	String name;	//进程号码
	int arrivaltime;	//进程到达时间
	String state = "No arrival";	//进程状态，默认未到达
	int psfinishtime = -1;	//进程完成时间，-1：未完成
}

 （一）、读取进程数据方式：通过绝对路径中的读取progress.txt文件内容，文件中每行记录一个进程的相关信息，依次为：进程名 name、进程到达时间 arrivaltime、进程运行时间 runtime，文本文件内容如下：

（二）、进程的到达问题：除了到达时间为0的进程直接进入就绪状态，其他未到达进程按照进程到达的时间通过冒泡排序从小到大排序，每次运行完当前进程后只需判断队首进程的到达时间是否为当前时间，是则取出该进程并进入就绪进程队列（进入就绪状态），并比较下一个未到达进程的到达时间，否则不对未到达进程队列进行操作；

（三）、计算周转时间、带权周转时间；

时间片调度程序源代码如下：

/**
 * Java实现时间片轮转法
 */
import java.util.*;
import java.io.*;

public class timeSlice_scheduling {
	public static  List<progress> pro_N = new ArrayList<>();    //未到达队列
	public static  List<progress> pro_R = new ArrayList<>();    //就绪队列
	public static List<progress> pro_F = new ArrayList<>();	    //完成进程队列
	public static void initlist() {
		System.out.println("======================设置进程=======================");
		try {
			int check = 0;
			File f = new File("G:/Java/progress.txt");
			FileInputStream fis = new FileInputStream(f);
			BufferedReader br = new BufferedReader(new InputStreamReader(fis));
			String line = null;
			while ((line = br.readLine()) != null) {	//循环逐行读取txt文件内容
				progress Progress = new progress();
				progress ps_finish = new progress();
				String[] pss = line.split(" ");
				Progress.name = pss[0];
				ps_finish.name = pss[0];
				Progress.arrivaltime = Integer.parseInt(pss[1]);
				ps_finish.arrivaltime = Integer.parseInt(pss[1]);
				Progress.runtime = Integer.parseInt(pss[2]);
				ps_finish.runtime = Integer.parseInt(pss[2]);
				pro_F.add(ps_finish);
				if(Progress.arrivaltime == 0) {
					Progress.state = "Ready";
					pro_R.add(Progress);
				}
				else {
					pro_N.add(Progress);
				}
				check++;
			}
			System.out.println("进程数：\t" + check);
			br.close();
		}catch(IOException e) {
			e.printStackTrace();
		}
	}
	 static void show(List<progress> lps) {	//显示当前进程链表
		if(lps.isEmpty())				//if进程链表为空
			return;
		System.out.println("进程名\t到达时间\t运行时间\t状态" );
		for(int i =0;i<lps.size();i++) {	//循环输出当前每个进程的情况
			System.out.println(lps.get(i).name+"\t"+lps.get(i).arrivaltime+"\t"+
					lps.get(i).runtime+"\t"+lps.get(i).state);
		}
		System.out.println();
	}
	
	 static void sort(List<progress> lp) {//arrival到达时间 先->后 冒泡排序
		progress p = new progress();
		for(int i=0;i<lp.size();i++) {
			for(int j = i+1;j<lp.size();j++) {
				if(lp.get(i).arrivaltime > lp.get(j).arrivaltime) {
					p = lp.get(i);
					lp.set(i,lp.get(j));
					lp.set(j, p);
				}
			}
		}
	}
	 static void run(List<progress> p_R,List<progress> p_N) {	//执行进程调度
		int time = 0;
		if(p_R.isEmpty() & p_N.isEmpty()) {	//不存在进程
			System.out.println("无进程运行！");
			return;
		}
		
		while(!p_R.isEmpty() || !p_N.isEmpty()) {	//就绪队列不为空，或未到达队列不为空
			System.out.println("--------------------《"+(time+1)+"》时刻进程中的队列情况--------------------");
			System.out.println("进程号\t运行时间\t状态");
			if(!p_R.isEmpty()) {					//就绪队列不空
				time++;			//系统总运行时间+1
				progress p = new progress();
				for(int i=0;i<p_R.size();i++) {		//遍历当前就绪进程
					System.out.print(p_R.get(i).name+"\t"+p_R.get(i).runtime);
					if(i == 0)
						System.out.println("\tRuning");
					else {
						System.out.println("\t"+p_R.get(i).state);
					}
				}
				p_R.get(0).runtime--;		//该进程运行时间-1
				if(p_R.get(0).runtime == 0) {//进程运行完成
					p_R.get(0).state = "Complete!";
					System.out.println("\t-----< "+time+" >时刻【"+p_R.get(0).name+"】进程完成！-----");
					for(int i=0;i<pro_F.size();i++) {
						if(p_R.get(0).name == pro_F.get(i).name)
							pro_F.get(i).psfinishtime = time;
					}
					p_R.remove(0);		//已完成进程退出
					
				}
				else {		//进程未完成
					if(p_R.size()>1) {
						p = p_R.get(0);
						p_R.remove(0);
						p_R.add(p);
					}else {
						
					}
				}
			}
			
			while(!p_N.isEmpty() && time==p_N.get(0).arrivaltime) {		//未到达队列不为空，且time时刻有进程到达
				System.out.println("\t\t### <" +time + "> 时间片【" + p_N.get(0).name +
						 "】进程状态转变:No arrival->Ready ###" );
				p_N.get(0).state = "Ready";
				p_R.add(p_N.get(0));
				p_N.remove(0);
			}
			if(p_R.isEmpty() && !p_N.isEmpty()) {					//就绪队列为空，且未到达队列不为空
					if(time < p_N.get(0).arrivaltime)
						time++;
				System.out.println("\t********* <" + time + "> 时间片 空转  ********\n");
			}
			System.out.println("\n");
		}
	}
	 static void cal(List<progress> fp) {
		 System.out.println("#######################周转时间测试#########################");
		 double avg_cyctime = 0.00;	//平均周转时间
		 double avg_rightcyctime = 0.00;	//平均带权周转时间
		 System.out.println("进程名\t到达时间\t运行时间\t结束时间\t周转时间\t带权周转时间");
		 for(int i=0;i<pro_F.size();i++) {
			 int cyctime = pro_F.get(i).psfinishtime - pro_F.get(i).arrivaltime;//周转时间
			 double rightcyctime = (double)cyctime/pro_F.get(i).runtime;	//带权周转时间
			 avg_cyctime +=cyctime;
			 avg_rightcyctime += rightcyctime;
			 System.out.println(pro_F.get(i).name + "\t" + pro_F.get(i).arrivaltime + "\t" +
					 pro_F.get(i).runtime + "\t" + pro_F.get(i).psfinishtime +"\t" + cyctime +
					 "\t" + String.format("%.4f", rightcyctime));
		 }
		 System.out.print("平均周转时间：" + String.format("%.4f", avg_cyctime/pro_F.size()) + "\t");
		 System.out.println("平均带权周转时间：" + String.format("%.4f", avg_rightcyctime/pro_F.size()));
	 }
	public static void main(String arg[]) {
		initlist();				//初始化队列
		System.out.println("====================<未到达进程>====================");
		show(pro_N);	
		System.out.println("=====================<就绪进程>=====================");
		show(pro_R);		
		sort(pro_N);			
		run(pro_R,pro_N);	
		System.out.println("=======================================END=======================================");
		cal(pro_F);
	}
}