栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

操作系统实现及其可视化实现(Java语言)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

操作系统实现及其可视化实现(Java语言)

本文将介绍操作系统常见的几种算法并给出实现方法,系统架构图如下:

如需源码请参见文章末尾链接

进程管理

        1.生产者消费者与读者写者

            生产者消费者问题其主要实现就是模拟进程之间的同步与互斥,首先需要设置3个令牌(信号量),即:Empty、Full、mutex(互斥)。

             生产者首先需判断获取空的缓冲池,判断是否有空间生产(Empty.acquire());有空间后紧接着就是获取互斥信号量mutex,当获取到mutex就能对临界区进行修改,完成相应的生产任务,记录型信号量增加(即生产,count++)。在随即等待一段时间后(现代计算机CUP处理速度较快,wait是为了能使我们能够看清流程)退出剩余区,即mutex.release()。最后增加一个Full空间(Full..release())。

           消费者与之类似,其不同点仅在于其进入临界区消费与退出时的判断逻辑为:是否有空间(产品)消费和增加一个Empty空间(Empty.release())。

           常见的进程调度在java中一般使用令牌+进程锁+LinkedList实现基本同步互斥问题,生产者消费者实现核心代码如下:

try
{
    synchronized(this){
        Random random = new Random();
        wait(random.nextInt(500));
        ProderAndConsumer.insert3("生产者"+num+"打算生产");
        ProderAndConsumer.Pro.add(num+"打算生产");
        ProderAndConsumer.Empty.acquire();
        ProderAndConsumer.mutex.acquire();
        ProderAndConsumer.insert2("生产者"+num+"正在生产");
        ProderAndConsumer.Pro.remove(num+"打算生产");
        ProderAndConsumer.ing.add("生产者"+num+"正在生产");
        wait(random.nextInt(10000)+3000);
        ProderAndConsumer.count++;
        ProderAndConsumer.insert2("生产者"+num+"结束生产");
        ProderAndConsumer.insert3("生产者"+num+"完成生产");
        ProderAndConsumer.ing.remove("生产者"+num+"正在生产");
        wait(3000);
        ProderAndConsumer.fresh.acquire();
        ProderAndConsumer.refresh();//刷新页面,通过队列的信息刷新页面
        ProderAndConsumer.fresh.release();
        ProderAndConsumer.mutex.release();
        ProderAndConsumer.Full.release();
    }
} catch (InterruptedException e) {
    System.out.println("生产者"+num+"出现错误!");
    e.printStackTrace();
}

try {
    synchronized(this) {
        Random random = new Random();
        wait(random.nextInt(400));
        ProderAndConsumer.insert1("消费者"+num+"打算消费");
        ProderAndConsumer.Con.add(num+"打算消费");
        ProderAndConsumer.Full.acquire();
        ProderAndConsumer.mutex.acquire();
        ProderAndConsumer.insert2("消费者"+num+"正在消费");
        ProderAndConsumer.Con.remove(num+"打算消费");
        ProderAndConsumer.ing.add("消费者"+num+"正在消费");
        wait(random.nextInt(5000)+1500);
        ProderAndConsumer.count--;
        ProderAndConsumer.insert2("消费者"+num+"结束消费");
        ProderAndConsumer.ing.remove("消费者"+num+"正在消费");
        ProderAndConsumer.insert1("消费者"+num+"完成消费");
        wait(3000);
        ProderAndConsumer.fresh.acquire();              //实现刷新页面时,线程的互斥
        ProderAndConsumer.refresh();                    //刷新页面,通过队列的信息刷新页面
        ProderAndConsumer.fresh.release();
        ProderAndConsumer.mutex.release();
        ProderAndConsumer.Empty.release();
    }

} catch (InterruptedException e) {
    System.out.println("消费者"+num+"出现错误!");
    e.printStackTrace();
}

            读者写者问题是在生产者消费者问题的基础上改进而来,其不同点仅在于加入一个计数变量count来记录处于读写空间中读者的数量,实现读者可同时读文件,其核心代码如下:

try {
            synchronized(this)
            {
                Random random = new Random();
                wait(random.nextInt(500));
                ReadAndWrite.insert1("读者"+num+"打算读文件");

                ReadAndWrite.Re.add(num+"打算读文件");

                ReadAndWrite.w.acquire();           //实现写优先
                ReadAndWrite.mutex.acquire();       //防止读者之间同步访问count,读者互斥访问count
                if(ReadAndWrite.count==0)
                    ReadAndWrite.rw.acquire();      //实现读写互斥
                ReadAndWrite.count++;               //我只要有东西正在读你,你就不许给我写东西,实现多读者同步的关键
                ReadAndWrite.mutex.release();
                ReadAndWrite.w.release();

                //以下为读文件的阶段
                ReadAndWrite.insert2("读者"+num+"正在读文件");
                ReadAndWrite.ing.add("读者"+num+"正在读文件");
                wait(random.nextInt(5000)+1500);
                ReadAndWrite.insert2("读者"+num+"结束读文件");
                ReadAndWrite.insert1("读者"+num+"完成读文件");
                ReadAndWrite.ing.remove("读者"+num+"正在读文件");
                ReadAndWrite.Re.remove(num+"打算读文件");
                //以上为读文件的阶段

                wait(3000);
                ReadAndWrite.fresh.acquire();        //实现刷新页面时,线程的互斥
                ReadAndWrite.refresh();              //刷新页面,通过队列的信息刷新页面
                ReadAndWrite.fresh.release();

                ReadAndWrite.mutex.acquire();
                ReadAndWrite.count--;           //文件读完了,读完一个出来一个,count--了
                if(ReadAndWrite.count==0)
                    ReadAndWrite.rw.release();
                ReadAndWrite.mutex.release();
            }

        } catch (InterruptedException e) {
            System.out.println("读者"+num+"出现错误!");
            e.printStackTrace();
        }



    try {
            synchronized(this) {
                Random random = new Random();
                wait(random.nextInt(500));
                ReadAndWrite.insert3("写者"+num+"打算写文件");
                ReadAndWrite.Wr.add(num+"打算写文件");
                ReadAndWrite.w.acquire();
                ReadAndWrite.rw.acquire();
                ReadAndWrite.insert2("写者"+num+"正在写文件");
                ReadAndWrite.ing.add("写者"+num+"正在写文件");
                wait(random.nextInt(10000)+3000);
                ReadAndWrite.insert2("写者"+num+"结束写文件");

                ReadAndWrite.insert3("写者"+num+"完成写文件");
                ReadAndWrite.ing.remove("写者"+num+"正在写文件");
                ReadAndWrite.Wr.remove(num+"打算写文件");

                wait(3000);
                ReadAndWrite.fresh.acquire();
                ReadAndWrite.refresh();//刷新页面,通过队列的信息刷新页面
                ReadAndWrite.fresh.release();

                ReadAndWrite.rw.release();
                ReadAndWrite.w.release();
            }
        } catch (InterruptedException e) {
            System.out.println("写者"+num+"出现错误!");
            e.printStackTrace();
        }

         运行界面:

        2.银行家算法

          银行家算法基于安全性算法实现,其目的是避免死锁方法中允许进程动态地申请资源,但系统在进行资源分配之前,应先计算此次分配资源的安全性,若分配不会导致系统进入不安全状态,则分配,否则等待。为实现银行家算法,系统必须设置若干数据结构。

int[][] Allocation = new int[ab][res];
		int[][] Max = new int[ab][res];
		int[][] Need = new int[ab][res];
		int[] Available = new int[res];
		int[] alloc_avail = new int[res];		//可用资源数

        安全性算法:

        设置工作向量Work,有m个元素,表示系统中的剩余可用资源数目。在执行安全性算法开始时,Work=Available。

  1.    初始化安全序列为空。
  2. 从Need矩阵中找到符合下面条件的行:该行对应的进程不在安全序列中,而且该行小于等于Work向量,找到后,把对应的进程加入安全序列;若找不到,则执行步骤4。
  3. 进程Pi进入安全序列后,可顺利执行,直至完成,并释放分配给它的资源,因此应执行Work=Work+Allocation[i],其中Allocation[i]表示进程Pi代表的在Allocation矩阵中对应的行,返回步骤2。
  4. 若此时安全序列中已有所有进程,则系统处于安全状态,否则系统处于不安全状态(不安全状态不意味着一定会发生死锁)。          

        核心代码如下:

while(true) {
			f=0;
			if(ip==ab) ip=0;
			if(unsafe_chk[ip]==1 && tnp<=1) {
				f=1;
				break;
			}
			if(process_complete[ip] == 1) {
				ip++;
				continue;
			} else {
				for(c=0;c 

实现结果:

 

 

 

实现源码资源链接:实现源码资源链接https://download.csdn.net/download/zxl316616/85656014

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/981520.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号