《计算机操作系统》之课程实验

《操作系统》课程实验报告 进程的创建控制实验 计算机操作系统 实验报告 进程的创建控制实验 阅读详情

进程与资源管理实验

框架设计

  • main类,是程序的Test Shell,主要实现了读取命令、语句转换和显示结果等功能。
  • PCB(进程管理块)类,用于进程的管理, 主要实现了进程的创建、进程的切换与调度以及进程信息的输出等功能。
  • Process类,定义了进程的数据结构,主要实现了删除进程、递归删除子进程树、销毁所有进程等功能。
  • Resource类,定义了资源的数据结构,主要实现了请求资源、释放资源、输出资源信息等功能。另外,该类对每一个资源管理和维护了对应的阻塞队列,当进程请求资源不足时,将进程加入对应的阻塞队列中。
  • Queue类,用于管理和维护进程队列,主要实现了3种优先级队列的入队、出队、删除等操作。

具体实现

main.java

import java.io.*;
import java.util.Scanner;

/**
 * @BelongsProject:OS-process
 * @BelongsPackage:PACKAGE_NAME
 * @Author:Uestc_Xiye
 * @CreateTime:2020-12-01 16:53:00
 */
public class main {
    private static final Pcb pcb=Pcb.getpcb();
    private static final Resource r1=new Resource(1,1);
    private static final Resource r2=new Resource(2,2);
    private static final Resource r3=new Resource(3,3);
    private static final Resource r4=new Resource(4,4);

    public static void main(String[] args) throws IOException
    {
        pcb.createProcess("init",0);
        System.out.print("init"+" ");
        if(args.length!=0)
        {
            loadFile(args[0]);
        }
        else
        {
            System.out.println();
            Scanner scanner=new Scanner(System.in);
            while(scanner.hasNextLine())
            {
                String input=scanner.nextLine();
                if(input.trim().equals(""))
                {
                    continue;
                }
                testShell(input);
            }
        }
    }

    public static void testShell(String input)
    {
        String[] commands=new String[]{input};
        for(String command:commands)
        {
            String[] cmds=command.split("\\s+");
            String options=cmds[0];
            switch(options)
            {
                case "cr":
                    if (cmds.length!=3)
                    {
                        System.out.println("Error! Please enter the legal parameters!");
                    }
                    else
                    {
                        String processName=cmds[1];
                        int priority=0;
                        try
                        {
                            priority=Integer.parseInt(cmds[2]);
                            if(priority<=0 || priority>2)
                            {
                                System.out.println("Error!Please enter the legal parameters!");
                                continue;
                            }
                        } catch (Exception e) {System.out.println("Error!Please enter the legal parameters!");}
                        if(pcb.isExistName(processName))
                        {
                            System.out.println("Error!Process "+processName+"already exists!Please select another process name!");
                            break;
                        }
                        pcb.createProcess(processName,priority);
                    }
                    break;
                case "de":
                    if(cmds.length!=2)
                    {
                        System.out.println("Error!Please enter the legal parameters!");
                    }
                    else
                    {
                        String processName=cmds[1];
                        Process process = pcb.findProcess(processName);
                        if(process==null)
                        {
                            System.out.println("Error!Process " + processName + "does not exist!");
                        }
                        else if(processName.equals("init"))
                        {
                            System.out.println("Error!You do not have permission to terminate the init process!");
                        }
                        else
                        {
                            process.destroy();
                        }
                    }
                    break;
                case "req":
                    if(cmds.length!=3)
                    {
                        System.out.println("Error!Please enter the legal parameters!");
                    }
                    else
                    {
                        String resourceName=cmds[1];
                        int need=0;
                        try
                        {
                            need=Integer.parseInt(cmds[2]);
                        } catch (Exception e) {System.out.println("Error!Please enter the legal parameters!");}
                        Process currentProcess=pcb.getcurrentProcess();
                        switch(resourceName)
                        {
                            case "R1":
                                r1.requestResource(currentProcess,need);
                                break;
                            case "R2":
                                r2.requestResource(currentProcess,need);
                                break;
                            case "R3":
                                r3.requestResource(currentProcess,need);
                                break;
                            case "R4":
                                r4.requestResource(currentProcess,need);
                                break;
                            default:
                                System.out.println("Error!Please enter the legal parameters!");
                        }
                    }
                    break;
                case "rel":
                    if(cmds.length!=3)
                    {
                        System.out.println("Error!Please enter the legal parameters!");
                    }
                    else
                    {
                        String resourceName=cmds[1];
                        int rel=0;
                        try
                        {
                            rel=Integer.parseInt(cmds[2]);
                        } catch (Exception e) {System.out.println("Error!Please enter the legal parameters!");}
                        Process currentProcess = pcb.getcurrentProcess();
                        switch(resourceName)
                        {
                            case "R1":
                                r1.releaseResource(currentProcess,rel);
                                break;
                            case "R2":
                                r2.releaseResource(currentProcess,rel);
                                break;
                            case "R3":
                                r3.releaseResource(currentProcess,rel);
                                break;
                            case "R4":
                                r4.releaseResource(currentProcess,rel);
                                break;
                            default:
                                System.out.println("Error!Please enter the legal parameters!");
                        }
                    }
                    break;
                case "to":
                    pcb.timeout();
                    break;
                case "lp":
                    if(cmds.length==1)
                    {
                        pcb.printProcessTree(pcb.findProcess("init"),0);
                    }
                    else if(cmds.length<3 || !cmds[1].equals("-p"))
                    {
                        System.out.println("Error!Please enter a legal parameter or command!");
                    }
                    else
                    {
                        String pName=cmds[2];
                        Process process=pcb.findProcess(pName);
                        if(process==null)
                        {
                            System.out.println("Error!Process "+pName+"does not exist!");
                        }
                        else
                        {
                            pcb.printProcessDetail(process);
                        }
                    }
                    break;
                case "lr":
                    r1.printStatus();
                    r2.printStatus();
                    r3.printStatus();
                    r4.printStatus();
                    break;
                case "exit":
                    System.out.println("Bye!");
                    System.exit(0);
                case "list":
                    pcb.printExistProcess();
                    break;
                default:
                    System.out.println("Error!Please enter the legal command!");
                    break;
            }
        }
        if(pcb.getcurrentProcess()!=null)
        {
            System.out.print(pcb.getcurrentProcess().getpName()+" ");
        }
    }

    private static void loadFile(String filePath) throws IOException
    {
        InputStream inputStream=new FileInputStream(filePath);
        LineNumberReader lineNumberReader=new LineNumberReader(new FileReader(filePath));
        String cmd=null;
        while((cmd=lineNumberReader.readLine())!=null)
        {
            if(!"".equals(cmd))
            {
                testShell(cmd);
            }
        }
    }

}

Pcb.java

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @BelongsProject:OS-process
 * @BelongsPackage:PACKAGE_NAME
 * @Author:Uestc_Xiye
 * @CreateTime:2020-12-01 16:52:29
 */
public class Pcb {
    /**
     * 变量说明
     * pcb: 进程控制块(Process Control Block)
     * readyQueue: 就绪队列
     * existProcess: 所有存活的进程,包括Running(运行状态),Blocked(阻塞状态),Ready(就绪状态)
     * currentProcess: 当前正在占用CPU的进程
     * pidGenerator: pid生成器,可以生成唯一的pid
     */
    private static final Pcb pcb=new Pcb();
    private static final Queue readyQueue=Queue.getreadyQueue();
    private static Map<String,Process> existProcess;
    private Process currentProcess;
    private AtomicInteger pidGenerator;

    private Pcb()
    {
        existProcess=new HashMap<>();
        pidGenerator=new AtomicInteger();
    }

    public Process createProcess(String processName,int priority)
    {
        Process currentProcess=pcb.getcurrentProcess();
        // 为新建进程分配pid,进程名,优先级,进程状态,资源,父进程和子进程等信息
        Process process=new Process(pcb.createpid(),processName,priority,Process.State.NEW,new ConcurrentHashMap<>(),currentProcess,new LinkedList<>());
        if(currentProcess!=null)
        {
            currentProcess.getchildren().add(process);
            process.setparent(currentProcess);
        }
        pcb.addexistProcess(process);
        readyQueue.addprocess(process);
        process.setstate(Process.State.READY);
        Pcb.scheduler();
        return process;
    }

    public static void scheduler()
    {
        Process currentProcess=pcb.getcurrentProcess();
        Process readyProcess=readyQueue.getprocess();
        if(readyProcess==null)
        {
            pcb.getcurrentProcess().setstate(Process.State.RUNNING);
            return;
        }
        else if(currentProcess==null)
        {
            readyQueue.deleteProcess(readyProcess);
            pcb.setcurrentProcess(readyProcess);
            readyProcess.setstate(Process.State.RUNNING);
            return;
        }
        else if(currentProcess.getstate()==Process.State.BLOCKED || currentProcess.getstate()==Process.State.TERMINATED)
        {
            readyQueue.deleteProcess(readyProcess);
            pcb.setcurrentProcess(readyProcess);
            readyProcess.setstate(Process.State.RUNNING);
        }
        else if(currentProcess.getstate()==Process.State.RUNNING)
        {
            if(currentProcess.getpriority()<readyProcess.getpriority())
            {
                preempt(readyProcess,currentProcess);
            }
        }
        else if(currentProcess.getstate()==Process.State.READY)
        {
            if(currentProcess.getpriority()<=readyProcess.getpriority())
            {
                preempt(readyProcess,currentProcess);
            }
            else
            {
                currentProcess.setstate(Process.State.RUNNING);
            }
        }
        return;
    }

    public static void preempt(Process readyProcess,Process currentProcess)
    {
        if(isExistName(currentProcess.getpName()))
        {
            readyQueue.addprocess(currentProcess);
            currentProcess.setstate(Process.State.READY);
            readyQueue.deleteProcess(readyProcess);
            pcb.setcurrentProcess(readyProcess);
            readyProcess.setstate(Process.State.RUNNING);
            return;
        }
    }

    public static void timeout()
    {
        pcb.getcurrentProcess().setstate(Process.State.READY);
        scheduler();
    }

    public void deleteexistProcess(Process process)
    {
        String name=process.getpName();
        existProcess.remove(name);
    }

    public void printProcessTree(Process process,int retract)
    {
        for (int i=0;i<retract;i++)
        {
            System.out.print("  ");
        }
        System.out.print("|-");
        printProcessDetail(process);
        List<Process> children=process.getchildren();
        for(Process child:children)
        {
            printProcessTree(child,retract+1);
        }
    }

    public void printProcessDetail(Process process)
    {
        System.out.print(process.getpName()+"(PID:"+process.getpid()+",进程状态:"+process.getstate()+",优先级:"+process.getpriority() + ",");
        if(process.getresourceMap().isEmpty())
        {
            System.out.println("(无资源占用))");
        }
        else
        {
            StringBuilder stringBuilder=new StringBuilder();
            stringBuilder.append("(");
            for(Map.Entry<Resource,Integer> entry:process.getresourceMap().entrySet())
            {
                Resource res=entry.getKey();
                int holdNum=entry.getValue();
                stringBuilder.append(",")
                             .append("R")
                             .append(res.getrid())
                             .append(":")
                             .append(holdNum);
            }
            stringBuilder.append(")");
            String result=stringBuilder.toString();
            System.out.println(result.replaceFirst(",",""));
        }
    }

    public void printExistProcess()
    {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("existList:[");
        for(Map.Entry<String,Process> entry:existProcess.entrySet())
        {
            String name=entry.getKey();
            String state=entry.getValue().getstate().toString();
            stringBuilder.append(",")
                         .append(name)
                         .append("(")
                         .append(state)
                         .append(")");
        }
        stringBuilder.append("]");
        String result=stringBuilder.toString();
        System.out.println(result.replaceFirst(",", ""));
    }

    public int createpid()
    {
        return pidGenerator.getAndIncrement();
    }

    public void addexistProcess(Process process)
    {
        existProcess.put(process.getpName(),process);
    }

    public static boolean isExistName(String name)
    {
        return existProcess.containsKey(name);
    }

    public Process findProcess(String processName)
    {
        for(Map.Entry<String, Process> entry:existProcess.entrySet())
        {
            if(processName.equals(entry.getKey()))
            {
                return entry.getValue();
            }
        }
        return null;
    }

    public void deleteProcess(Process process)
    {
    }

    public void setcurrentProcess(Process currentProcess)
    {
        this.currentProcess=currentProcess;
    }

    public void setPidGenerator(AtomicInteger pidGenerator)
    {
        this.pidGenerator=pidGenerator;
    }

    public static Pcb getpcb()
    {
        return pcb;
    }

    public Queue getreadyQueue()
    {
        return readyQueue;
    }

    public Map<String,Process> getexistProcess()
    {
        return existProcess;
    }

    public Process getcurrentProcess()
    {
        return currentProcess;
    }

    public AtomicInteger getPidGenerator()
    {
        return pidGenerator;
    }
}

Process.java

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @BelongsProject:OS-process
 * @BelongsPackage:PACKAGE_NAME
 * @Author:Uestc_Xiye
 * @CreateTime:2020-12-01 16:52:02
 */

public class Process {
    /**
     * 变量说明
     * pid: 进程的id,唯一
     * pName: 进程的名字
     * priority: 进程的优先级
     * state: 进程的状态,有五种,具体见于State中
     * blockedResource: 如果进程状态为阻塞的话,这个属性指向被阻塞的资源,否则为NULL
     * resourceMap: 进程持有的资源和相应数量
     * parent: 进程的父进程
     * children: 进程的子进程(们)
     */
    private int pid;
    private String pName;
    private int priority;
    private State state;
    private Resource blockedResource;
    private ConcurrentHashMap<Resource,Integer> resourceMap;
    private Process parent;
    private List<Process> children;

    private static final Pcb pcb=Pcb.getpcb();
    private static final Queue readyQueue=Queue.getreadyQueue();

    /**
     * 进程的五种状态
     * NEW: 新建状态
     * READY: 就绪状态
     * RUNNING: 执行状态
     * BLOCKED: 阻塞状态
     * TERMINATED: 终止状态
     */
    public enum State
    {
        NEW,READY,RUNNING,BLOCKED,TERMINATED
    }

    public Process(int pid,String pName,int priority,State state,ConcurrentHashMap<Resource,Integer> resourceMap,Process parent,List<Process> children)
    {
        this.pid=pid;
        this.pName=pName;
        this.priority=priority;
        this.state=state;
        this.resourceMap=resourceMap;
        this.parent=parent;
        this.children=children;
    }

    public void deleteChild(Process process)
    {
        for(Process child:children)
        {
            if(child==process)
            {
                children.remove(child);
                return;
            }
        }
    }

    public void deleteProcessTree()
    {
        if(!children.isEmpty())
        {
            for(int i=0;i<children.size();i++)
            {
                Process child=children.get(0);
                child.deleteProcessTree();// 递归删除子树
            }
        }
        // 对不同状态的进程处理

        // 若进程状态为终止状态,说明删除成功
        if(this.getstate()==State.TERMINATED)
        {
            pcb.deleteProcess(this);
            return;
        }
        // 若进程状态为就绪状态,则从就绪队列删除,修改其状态为终止状态
        else if(this.getstate()==State.READY)
        {
            readyQueue.deleteProcess(this);
            pcb.deleteProcess(this);
            this.setstate(State.TERMINATED);
        }
        // 若进程状态为阻塞状态,则从阻塞队列删除,修改其状态为终止状态
        else if(this.getstate()==State.BLOCKED)
        {
            Resource blockedResource=this.getblockedResource();
            blockedResource.deleteblockedProcess(this);
            pcb.deleteProcess(this);
            this.setstate(State.TERMINATED);
        }
        // 若进程状态为运行状态时直接终止,则修改其状态为终止状态
        else if(this.getstate()==State.RUNNING)
        {
            pcb.deleteProcess(this);
            this.setstate(State.TERMINATED);
        }
        // 清除进程的parent和child指针
        parent.deleteChild(this);
        parent=null;
        // 释放资源
        for(Resource resource:resourceMap.keySet())
        {
            resource.releaseResource(this);
        }
        return;
    }

    public void destroy()
    {
        deleteProcessTree();
        Pcb.scheduler();
        return;
    }

    public void setpid(int pid)
    {
        this.pid=pid;
    }

    public void setpName(String pName)
    {
        this.pName=pName;
    }

    public void setpriority(int priority)
    {
        this.priority=priority;
    }

    public void setstate(State state)
    {
        this.state=state;
    }

    public void setblockedResource(Resource blockedResource)
    {
        this.blockedResource=blockedResource;
    }

    public void setrMap(ConcurrentHashMap<Resource,Integer> resourceMap)
    {
        this.resourceMap=resourceMap;
    }

    public void setparent(Process parent)
    {
        this.parent=parent;
    }

    public void setchildren(List<Process> children)
    {
        this.children=children;
    }

    public int getpid()
    {
        return pid;
    }

    public String getpName()
    {
        return pName;
    }

    public int getpriority()
    {
        return priority;
    }

    public State getstate()
    {
        return state;
    }

    public Resource getblockedResource()
    {
        return blockedResource;
    }

    public ConcurrentHashMap<Resource,Integer> getresourceMap()
    {
        return resourceMap;
    }

    public Process getparent()
    {
        return parent;
    }

    public List<Process> getchildren()
    {
        return children;
    }

}

Resource.java

import java.util.Deque;
import java.util.LinkedList;
import java.util.Map;

/**
 * @BelongsProject:OS-process
 * @BelongsPackage:PACKAGE_NAME
 * @Author:Uestc_Xiye
 * @CreateTime:2020-12-01 16:51:48
 */
public class Resource {
    /**
     * 变量说明
     * rid: 资源的id,唯一
     * maxResource: 资源的最大数量
     * remainingResource: 剩余的资源的数量
     * blockedDeque: 在一个资源上阻塞的进程队列
     */
    private int rid;
    private int maxResource;
    private int remainingResource;
    private Deque<BlockedProcess> blockedDeque;
    private static final Pcb pcb=Pcb.getpcb();
    private static final Queue readyQueue=Queue.getreadyQueue();

    public class BlockedProcess
    {
        /**
         * 变量说明
         * process: 进程
         * need: 需要请求的资源数量
         */
        private Process process;
        private int need;

        public BlockedProcess(Process process,int need)
        {
            this.process=process;
            this.need=need;
        }

        public void setprocess(Process process)
        {
            this.process=process;
        }

        public void setneed(int need)
        {
            this.need=need;
        }

        public Process getprocess()
        {
            return process;
        }

        public int getneed()
        {
            return need;
        }
    }

    public Resource(int rid,int maxResource)
    {
        this.rid=rid;
        this.maxResource=maxResource;
        this.remainingResource=maxResource;
        blockedDeque=new LinkedList<>();
    }

    public void addremainingResource(int num)
    {
        this.remainingResource+=num;
    }

    public void deleteblockedProcess(Process process)
    {
        for(BlockedProcess blockedProcess:blockedDeque)
        {
            if(blockedProcess.getprocess()==process)
            {
                blockedDeque.remove(blockedProcess);
            }
        }
    }

    public void requestResource(Process process,int need)
    {
        // 若请求数量大于最大数量,则请求失败
        if(need>maxResource)
        {
            System.out.println("Request Resource Failed!");
            return;
        }
        // 对于非init进程,将该进程加入阻塞队列,并设置进程为阻塞状态
        else if(need>remainingResource && !"init".equals(process.getpName()))
        {
            blockedDeque.addLast(new BlockedProcess(process,need));
            process.setstate(Process.State.BLOCKED);
            process.setblockedResource(this);
            Pcb.scheduler();
            return;
        }
        // 对于init进程,不阻塞
        else if(need>remainingResource && "init".equals(process.getpName()))
        {
            return;
        }
        // 若可以正常分配资源,则剩余资源的数量减少,已分配资源的数量增加
        else
        {
            remainingResource-=need;
            Map<Resource,Integer> resourceMap=process.getresourceMap();
            if(resourceMap.containsKey(this))
            {
                Integer alreadyNum=resourceMap.get(this);
                resourceMap.put(this,alreadyNum+need);
            }
            else
            {
                resourceMap.put(this,need);
            }
        }
    }

    public void releaseResource(Process process)
    {
        int num=0;
        num=process.getresourceMap().remove(this);
        if(num==0)
        {
            return;
        }
        remainingResource+=num;
        while(!blockedDeque.isEmpty())
        {
            BlockedProcess blockedProcess = blockedDeque.peekFirst();
            int need=blockedProcess.getneed();
            // 若剩余资源数量大于need,则唤醒阻塞队列队头的一个进程
            if(remainingResource>= need)
            {
                Process readyProcess=blockedProcess.getprocess();
                requestResource(readyProcess,need);
                blockedDeque.removeFirst();
                readyQueue.addprocess(readyProcess);
                readyProcess.setstate(Process.State.READY);
                readyProcess.setblockedResource(null);
                // 若唤醒的进程优先级高于当前进程优先级,则抢占执行
                if(readyProcess.getpriority()>pcb.getcurrentProcess().getpriority())
                {
                    pcb.preempt(readyProcess,pcb.getcurrentProcess());
                }
            }
            else
            {
                break;
            }
        }
    }

    public void releaseResource(Process process,int num)
    {
        if(num==0)
        {
            return;
        }
        remainingResource+=num;
        while(!blockedDeque.isEmpty())
        {
            BlockedProcess blockedProcess = blockedDeque.peekFirst();
            int need=blockedProcess.getneed();
            // 若剩余资源数量大于need,则唤醒阻塞队列队头的一个进程
            if(remainingResource>= need)
            { 
                Process readyProcess=blockedProcess.getprocess();
                requestResource(readyProcess,need);
                blockedDeque.removeFirst();
                readyQueue.addprocess(readyProcess);
                readyProcess.setstate(Process.State.READY);
                readyProcess.setblockedResource(null);
                // 若唤醒的进程优先级高于当前进程优先级,则抢占执行
                if(readyProcess.getpriority()>pcb.getcurrentProcess().getpriority())
                { 
                    pcb.preempt(readyProcess,pcb.getcurrentProcess());
                }
            }
            else
            {
                break;
            }
        }
    }

    public void printStatus()
    {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("resource-").append(rid)
                     .append("{maxResource=").append(maxResource)
                     .append(",remainingResource:").append(remainingResource)
                     .append(",")
                     .append("blockedDeque[");
        for(BlockedProcess bProcess:blockedDeque)
        {
            stringBuilder.append(",{")
                         .append(bProcess.getprocess().getpName())
                         .append(":")
                         .append(bProcess.getneed())
                         .append("}");
        }
        stringBuilder.append("]}");
        String result=stringBuilder.toString();
        System.out.println(result.replace("[,", "["));
    }

    public void setrid(int rid)
    {
        this.rid=rid;
    }

    public void setmaxResource(int maxResource)
    {
        this.maxResource=maxResource;
    }

    public void setremainingResource(int remainingResource)
    {
        this.remainingResource=remainingResource;
    }

    public void setblockedDeque(Deque<BlockedProcess> blockedDeque)
    {
        this.blockedDeque=blockedDeque;
    }

    public int getrid()
    {
        return rid;
    }

    public int getmaxResource()
    {
        return maxResource;
    }

    public int getremainingResource()
    {
        return remainingResource;
    }

    public Deque<BlockedProcess> getblockedDeque()
    {
        return blockedDeque;
    }

}

Queue.java

import java.util.Deque;
import java.util.LinkedList;

/**
 * @BelongsProject:OS-process
 * @BelongsPackage:PACKAGE_NAME
 * @Author:Uestc_Xiye
 * @CreateTime:2020-12-01 16:51:38
 */
public class Queue {
    /**
     * deque: 不同优先级就绪队列组成数组
     * readyQueue: 就绪队列
     */
    private Deque<Process>[] deque;
    private static final Queue readyQueue=new Queue();

    private Queue()
    {
        //因为进程有3种不同优先级,所以构造3个就绪队列
        deque=new LinkedList[3];
        for(int i=0;i<3;i++)
        {
            deque[i]=new LinkedList<>();
        }
    }

    public void addprocess(Process process)
    {
        int priority=process.getpriority();
        Deque<Process> d=deque[priority];
        d.addLast(process);
    }

    public boolean deleteProcess(Process process)
    {
        int priority = process.getpriority();
        Deque<Process> d=deque[priority];
        return d.remove(process);
    }

    public static Queue getreadyQueue()
    {
        return readyQueue;
    }

    public Process getprocess()
    {
        for (int i=2;i>=0;i--)
        {
            Deque<Process> d=deque[i];
            if(!d.isEmpty())
            {
                return d.peekFirst();
            }
        }
        return null;
    }
}

把上述五个程序打包成Jar,打包方法见于IntelliJ IDEA 2020.1.3 封装jar包的方法及两个错误示例。

之后把实验数据与Jar放在同一目录下,在cmd调用下面的命令即可运行。

java -jar *.jar *.txt

在这里插入图片描述

虚拟内存综合实验

运行Bochs-2.5.1.exe,安装Bochs虚拟机。安装完成后,复制下列文件至安装根目录。
在这里插入图片描述
运行bochsdbg.exe,点击Load加载mybochssrc-hd.bxrc文件,再点击Start启动Bochs虚拟机。
在这里插入图片描述

Bochs虚拟机启动后,会出现两个窗口:Console窗口和Display窗口,如图17所示。Console窗口为Bochs命令输入窗口,Display窗口为Linux操作系统窗口。
在这里插入图片描述

在Console窗口输入命令:c,加载Linux操作系统。

在这里插入图片描述
继续输入命令:vi test.c,加载实验程序,输入命令: :wq,保存程序并退出。
在这里插入图片描述
输入命令:gcc -o test test.c编译程序,再输入命令:./test运行程序。
在这里插入图片描述

可以看出,程序运行至while(j)语句时,进入了死循环,所以没有继续运行后面的语句。

在Console窗口按下Ctrl+C,中断运行,输入sreg,查看段的具体信息。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

操作系统实验----线程的调度 优先级分为静态优先级和动态优先级,静态优先级(nice):内核不会修改它,不随时间而变化,除非用户通过系统调用setpriority进行修改;动态优先级(priority):内核根据线程使用CPU的状况、静态优先级nice和系统负荷计算出来,会随时间而变化。线程0(task0,它的ID=0)是一个特殊的线程,仅当没有其他可运行的线程时,才能调度task0运行!在文件“task.c”中的函数sys_task_create中初始化nice=0。在函数sys_task_create中初始化estcpu=0。 阅读详情

相关推荐

《计算机操作系统》第四版(汤小丹考研版) 全书知识梳理

写在前面: 这是一个不太完整的系列,因为时间原因所以只对个别几章进行了简单整理,回头有时间再继续补坑。 参考资料: 西安电子科技大学出版社 《计算机操作系统》第四版 汤小丹主编 (考研版) 王道考研《计算机操作系统》相关课程 同类梳理: 《数据库系统概论》第五版(王珊版)全书知识梳理 《计算机组成原理》第五版...

12 26 25 的博客 1万+

操作系统实验课

操作系统实验课

Tencovivid博客 679

【计算机操作系统】总览

1.1 操作系统的目标和作用 1.2 操作系统的发展过程 1.3 操作系统的基本特性 1.4 操作系统的主要功能 1.5 OS结构设计 习题2.1 前趋图和程序执行 2.2 进程的描述 2.3 进程控制 2.4 进程同步 2.5 经典进程的同步问题 2.6 进程通信 2.7 线程(Threads)的基本概念 2.8 线程的实现 习题3.1 处理机调度的层次和调度算法的目标 3.2 作业与作业调度 3.3 进程调度 3.4 实时调度 3.5 死锁概述 3.6 预防死锁 3.7 避免死锁 3.8 死锁的检测与解

AXDLMG7的优快云~ 1197

操作系统原理课程实验报告

操作系统原理课程实验报告,进程管理模拟和文件管理模拟

2301_76154383的博客 2147

操作系统实验报告

然后,消费者线程从缓冲区中取出编号为0的物品,并在每个循环中从缓冲区中取出下一个物品,直到缓冲区为空。这是因为,在生产者线程生产第19个物品之前,缓冲区已经满了,导致生产者线程进入休眠状态,直到消费者线程消费掉一些物品并释放出空余的槽位为止。当消费者线程消费了一些物品后,缓冲区就会变得不再满,这时生产者线程就会被唤醒,并开始继续生产物品。接着,父进程将两个子进程杀死,最后父进程结束。写者线程2开始执行,由于此时有读者线程持有读者锁,因此该写者线程需要等待所有读者线程完成读操作后才能进行写操作,即读者优先。

m0_64198455的博客 2246

操作系统实验课原代码

实验课代码,操作系统上机实验课具体代码。用linux实现的

华中科技大学操作系统实验课 实验四

(三)写一个完整的Linux驱动程序访问硬件并写应用程序进行测试 sudo rmmod hello make sudo insmod hello.ko gcc app.c -o app ./app /dev/hello sudo mknod /dev/hello c 255 0 #include <unistd.h> #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> #

Elsa的迷弟 3268

Windows 上安装 Everything:快速查找电脑上的文件

windows 快速查找文件

jhgj56的博客 1523

计算机网络进程管理实验报告,北方工业大学《计算机操作系统》实验报告——进程管理.doc...

北方工业大学《计算机操作系统》实验报告——进程管理实 验 报 告 书学 生 姓 名学 号班 级2012 — 2013 学年 第 一 学期《计算机操作系统》实验报告实验名称进程管理实验序号1实验日期2012年12月实验人一、实验目的和要求加深对进程概念的理解,明确进程和程序的区别进一步认识并发执行的实质分析进程争用资源的现象,学习解决进程互斥的方法了解Lin...

weixin_36452379的博客 603

高精度SAR ADC设计实战:从建模到版图的16位1MSPS实现

本文详细介绍了16位1MSPS高精度SAR ADC的设计过程,从建模到版图实现的完整流程。重点探讨了分段电容阵列设计、校准算法实现及版图匹配等关键技术,展示了如何在180nm工艺下实现92.5dB SNDR和109.6dB SFDR的高性能指标。文章特别强调了整数桥接电容设计对提升匹配精度的关键作用,为高精度模数转换器设计提供了实用参考。

weixin_33724046的博客 439

Mac上安装Label Studio

以上步骤详细说明了如何在Mac上通过Anaconda安装Label Studio。记得根据你的具体需求选择是否创建新的环境,并使用conda或pip进行安装。安装完成后,务必验证Label Studio是否成功运行。

g2526的博客 1959

计算机操作系统 进程管理报告,北方工业大学《计算机操作系统》实验报告进程管理.pdf...

北方工业大学北方工业大学实 验 报 告 书实 验 报 告 书学 生 姓 名学 生 姓 名学 号学 号班 级班 级—— 学年 第 一 学期2012 ...

weixin_39637457的博客 263

Latex | IEEE双栏排版中长公式的排版

IEEE双栏排版中,有时候公式过于长了,过宽,导致单栏排版不下。

qq_43466146的博客 1万+

计算机操作系统实验资源包:加深操作系统理解与实践

计算机操作系统实验资源包:加深操作系统理解与实践 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在现代计算机科学教育中,《计算机操作系统》是一门核心课程,它深入讲解了操作系统的基本原理和实现机制。为了帮助学生更好地理解和掌握这些概念,本项目提供了《计算机操作系统》实验资源包,包含课内实验报告、实验指导书以及相应的实验源码。通过实际编码和操作,学生可以加深对操作系统中进...

gitblog_06791的博客 415

Roboguide与TIA V16通讯

Roboguide与TIA V16通讯

haier123888的博客 2677

YOLO系列算法改进 | 主干改进篇 | 替换LSKNet主干特征提取网络 | 通过动态调整感受野自适应融合长程上下文,显著提升小目标与复杂背景下的检测精度!

YOLO系列算法改进 | 主干改进篇 | 替换LSKNet主干特征提取网络 | 通过动态调整感受野自适应融合长程上下文,显著提升小目标与复杂背景下的检测精度! (以YOLO26最新目标检测模型为基础,利用LSKNet替代Backbone)

2502_91881744的博客 214

计算机导论诺顿百度云,《计算机导论》教学大纲.pdf

《计算机导论》教学大纲课程类别:学科基础课程性质:必修英文名称:Introduction To Computers总 学 时:32 讲授学时:16 实验学时:16学 分:1.5先修课程:无适用专业:数学与应用数学(金融数学) 、自动化、通信工程开课单位:信息工程学院一、课程简介《计算机导论》是面向理工科所有专业本科生的一门先导基础课程。主要讲述计算机的特点、发展...

weixin_36277054的博客 653

【DaVinci Developer工具实战】03 -导入xml文件

本文档描述了 DaVinci Developer 导入数据的的具体功能 ,它适用于导入AUTOSAR SWC 模板【AUTOSAR XML 文件】 文件。

1993

《计算机操作系统》实验资源包

《计算机操作系统》实验资源包 去发现同类优质开源项目:https://gitcode.com/ 实验资料简介 本资源包包含了《计算机操作系统》课程的课内实验报告、实验指导书以及相应的实验源码,旨在通过实践操作加深学生对操作系统中进程同步控制原理的理解和应用。 实验基本信息 实验类别:课内实验 实验课程名称:计算机操作系统 实验室名称:计算机科学与技术专业实验室 实验课程编号:N02140113 ...

gitblog_06767的博客 349

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

计算机操作系统课程有什么关系,计算机操作系统课程教学大纲(洪联系)

计算机操作系统课程教学大纲(洪联系) (7页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!9.9 积分附件2:课程名称屮文:计算机操作系统英文:Computer Operating System课程编号8006600 学分/学时 54/3所属教研室计算机网络教研家先修课程高级语言程序设计(C++/C)、计算机体系结构/计算机组成原理、数据结构、编译 原...

weixin_32080327的博客 286

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

计算机操作系统指导书,《计算机操作系统》实验指导书

《计算机操作系统》实验指导书 计算机操作系统实验指导书 适用专业:计算机及相关专业 教 研 室:计算机教研室 计算机科学与技术学院 2009 年 9 月 前言 1. 实验课程简介 《计算机操作系统》是计算机科学与技术专业的骨干必修课。本课程的目的是使学生掌握现代计算机操作系统的基本原理、基本设计方法及实现技术,具有分析现行操作系统和设计、开发实际操作系统的基本能力。 操作系统实验是操作系统课程的重...

weixin_33328904的博客 409

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

西南科技大学计算机操作系统,《计算机操作系统综合实验》实验指导书.docx

《计算机操作系统综合实验》实验指导书ComputerScienceandTechnology西南科技大学(SouthWest University of Science and Technology)Experimental Instructor of Computer Operating System计算机操作系统 综合实验指导书应用教研室编写计算机科学与技术学院 二 00七年前言FOREWOR...

weixin_32593879的博客 1524

计算机操作系统学习计划

阅读教材第1章(《操作系统概述》)观看相关视频理解操作系统的目的和功能安装VirtualBox并尝试安装Linux。

南辞的博客 1761

计算机专业操作系统课程,《计算机操作系统》课程简介

《计算机操作系统》课程简介本课程是计算机专业的专业课程之一,着重介绍计算机系统的一个重要系统软件——操作系统。本课程详细阐述了操作系统如何管理计算机系统中的软件和硬件资源、合理组织计算机系统的工作流程、提供用户与计算机系统之间的软件接口等机制。授课内容包括操作系统的基本内容和概念、进程的概念以及通信和调度的方法、操作系统中各种资源的管理。最后通过实例——Linux操作系统,介绍Linux系统中的存...

weixin_42503456的博客 813

《计算机操作系统》大作业【参考代码解读】

注:前言、目录见 https://god-excious.blog.youkuaiyun.com/article/details/108428971 文章目录

God-Excious的博客 3306
上一篇: 人工智能
下一篇: 《Python语言程序设计》之第三次平时作业解析
UestcXiye
博客等级 码龄8年 9033粉丝 1306原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

UestcXiye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值