进程调度算法java

Ⅰ java进程调度中为什么进程名都是1

摘要 Linux2.4版本使用的调度算法的时间复杂度为O(n)，其主要原理是通过轮询所有可运行任务列表，然后挑选一个最合适的任务运行，所以其时间复杂度与可运行任务队列的长度成正比。

Ⅱ Java调度算法 来个大神写程序 选择一个调度算法，实现处理器调度。

public class CLSS_ch2 {

public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if (i % 10 == 3)
continue;
sum += i;
}
System.out.println(sum);
}
}
计算机图形技术组的成员在1993年开发出了 Lua。它被设计成为脚本语言，是一种不可获取的过程式编程语言，以简单而强大而闻名。

Ⅲ 优先级调度算法如何用JAVA实现

在多线程时,可以手动去设置每个线程的优先级setPriority(int newPriority)
更改线程的优先级。

Ⅳ 求磁盘调度算法scan算法的java代码

1、先来先服务算法（FCFS）First Come First Service
这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
先来先服务 （125）86.147.91.177.94.150.102.175.130

[java] view plain print?

Ⅳ 求一个先来先服务调度算法的程序 java编的

import java.util.ArrayList;
import java.util.List;

public class Question {
// 调度总站
class DiaoDuZhan{
private List<Client> list;
public Client getClient(){ // 获得客户
if(list != null && list.size() > 0){
Client client = list.get(0);
list.remove(client);
return client;
}else{
return null;
}
}
public void addClient(Client client){
if(list == null){
list = new ArrayList<Client>();
}
list.add(client);
}
}
// 客户
interface Client{
public void setService(Service service);
public Service getSerive();
}
// 服务
interface Service{
public void doService();
}
// 服务员
class waiter{
DiaoDuZhan diaozhan;
public DiaoDuZhan getDiaozhan() {
return diaozhan;
}
public void setDiaozhan(DiaoDuZhan diaozhan) {
this.diaozhan = diaozhan;
}
public void doNext(){
Client client = diaozhan.getClient();
if(client != null)
client.getSerive().doService();
}
}
}

Ⅵ 急求！！！ 进程调度算法模拟 java实现，c++也行

我有内存调度的 FIFO、LRU和OPT的，要发给你。

Ⅶ 我想要一个java编的进程的调度算法,先进先出算法.

这个用的是RR不是FIFO，改改就行了嘿嘿

public class Scheler extends Thread

{

public Scheler(){

timeSlice = DEFAULT_TIME_SLICE;

queue = new Circularlist();

}

public Scheler(int quantum){

timeSlice = quantum;

queue = new Circularlist();

}

public addThread(Thread t) {

t.setPriority(2);

queue.additem(t);

}

private void schelerSleep() {

try{

Thread.sleep(timeSlice );

} catch (InterruptedException e){};

}

public void run(){

Thread current;

This.setpriority(6);

While (true) {

// get the next thread

current = (Thread)qeue.getnext();

if ( (current != null) && (current.isAlive()) ){

current.setPriority(4);

schelerSleep();

current.setPriority(2)

}

}

}

private CircularList queue;

private int timeSlice;

private static final int DEFAULT_TIME_SLICE = 1000;

}

public class TesScheler

{

public static void main()String args[]) {

Thread.currentThread().setpriority(Thread.Max_Priority);

Schelar CPUSchelar = new Scheler ();

CPUSchelar.start()

TestThread t1 = new TestThread("Thread 1");

t1.start()

CpuSchelar.addThread(t1);

TestThread t2 = new TestThread("Thread 2");

t2.start()

CpuSchelar.addThread(t2);

TestThread t3 = new TestThread("Thread 1");

t3.start()

CpuSchelar.addThread(t3);

}

}

Ⅷ 用JAVA实现时间片轮转调度算法

不会吧，应该不会有用Java管理进程的吧。Java语言是不可预知的，比如说垃圾回收系统不受程序员控制，没法子做底层开发、管理进程的。

Ⅸ 求一个基于优先级的时间片轮转调度算法。实在是不太会做了，没思路。要求java 要求： （1）设系统

cpu进程调度模拟
四个队列是优先级队列（优先级高的在前面）
可以使用结构体做队列的节点
时间片轮转就是指定一个执行时间，时间一到就处理下一个进程，将当前进程进行状态转换（也就是换着状态需要向其放入相应的队列中，优先级队列）

理清头绪的话程序不算太复杂但也很麻烦

Ⅹ ）用C语言（或其它语言，如Java）编程实现对N个进程采用某种进程调度算法（如动态优先权调度

公众：类PrivilegeProcess {
公共静态无效的主要（字串[] args）{

MyQueue的MyQueue的新MyQueue的（）;/ /声明队列

印刷电路板[PCB = {新的PCB（001 ，8,1），新的PCB（002,7,9），新的PCB（003,3,8），新的PCB（004,1,7），新的PCB（005,7,4）};
> PCB段=新的PCB（）;

（INT I = 0; <pcb.length; + +）{/ /初始化先进行排序，选择排序这里使用的是高优先级的一线队

（J =我; <pcb.length; J + +）{

（PCB [I]。特权<PCB [J]。特权）{

段= PCB [1];

PCB [I] = PCB [J];

PCB [J] =段;

}

}

}

体系。通过out.println（“入队后第一时间的进程的顺序：”）;

（INT I = 0; <pcb.length; + +）{

的System.out调用println（第一次入队＃程序名称：“+ PCB [我]。名称+ totaltime：”+ PCB [I]。totaltime +“的”特权“+ PCB [我]。特权）; }

（）;

myqueue.start（PCB）;

}

}

类MyQueue的{

INT指数= 0;

PCB [] PC =新的PCB [5];

PCB [] PC1 =新的PCB [4];

PCB温度=新的PCB（） BR />公共无效排队（PCB工艺）{/ /排队算法

（指数== 5）{

（“出界！”）;

返回

}

PC [索引] =进程;

指数+ +;

}

公共：PCB DEQUEUE（）{/ /出队算法（索引== 0）

返回空;

（INT I = 0; <pc1.length; + +）{

PC1 [I] = PC [ +1];

}

指数 -

温度= PC [0];

（INT I = 0; <pc1.length; + +）{ BR /> PC [I] = PC1 [I];

}

回报条件;

}

公共无效启动（PCB [] PC）{/ /进程表算法

（PC [0]。isNotFinish ==真| | PC [1 isNotFinish ==真| | PC [2 isNotFinish ==真| | PC [3]。时isNotFinish ==真| | PC [4]。isNotFinish ==）{

/ / *注：| |运算符都是假的，所有的表达式结果为假，否则真

（INT I = 0; <PC长度; + +）{

PC [I]。运行（这一点）; />} 的System.out.println（）;

（INT I = 0; <pc.length; + +）{/ /处理每个运行一次运行的时间片的长度重新排序优先一旦

（J =我; <pc.length; J + +）{

如果（PC [I]特权<PC [J]。特权）{

温度= PC [I];

PC [I] = PC [J];

PC [J] =温度;

}

}

}

}

}

}

类PCB {/ /声明过程级

和int名，totaltime ，运行时特权;

布尔isNotFinish的;

公众PCB（）{

}

公开PCB（名称，诠释totaltime特权）{

this.name =的名称;/ /进程名

this.totaltime = totaltime ;/ /

this.privilege =特权;/ /总时间优先 this.runtime = 2 ;/ /时间片值是2

this.isNotFinish =真;/ /是否执行完成

（“初始值：程序名称：”+名+“totaltime：”+ totaltime +“特权”+特权）;

System.out的。调用println（）;

}

MyQueue的MQ公共无效的run（）{/ /处理的基础上实施的时间片算法

（totalTime> 1）{ totaltime =运行;/ /总时间大于1，总时间=总时间 - 时间片

特权 -

（“程序名称：”+姓名+“ remaintime：“+ +”特权“+特权）; totaltime

的} else if（totaltime == 1）{

totaltime - ;/ /总时间为1时，执行时间为1
>特权 -

（“程序名称：”+姓名+“remaintime：”+ totaltime +“特权”+特权）;

}其他{

isNotFinish =假;/ / 0，将isNotFinish标志设置为假

}

如果（isNotFinish ==真）{br mq.deQueue（）;

mq.enQueue（本）;

}

}
}