① c语言popen的描述
popen() 函数 用 创建管道 的 方式 启动 一个 进程, 并调用 shell. 因为 管道 是被定义成 单向的, 所以 type 参数 只能 定义成 只读 或者 只写, 不能是 两者同时, 结果流 也相应的 是 只读 或者 只写.
command 参数 是 一个 字符串指针, 指向的 是 一个 以 null 结束符 结尾的字符串, 这个 字符串 包含 一个 shell 命令. 这个命令 被送到 /bin/sh 以 -c 参数 执行, 即由 shell 来执行. type 参数 也是 一个 指向 以 null 结束符 结尾的 字符串的指针, 这个字符串 必须是 'r' 或者 'w’ 来指明 是 读还是写.
popen() 函数 的 返回值 是 一个 普通的 标准I/O流, 它只能用 pclose() 函数 来关闭, 而不是 fclose(). 函数. 向 这个流 的 写入 被转化为 对 command 命令的 标准输入; 而 command 命令的 标准输出 则是和 调用 popen(), 函数 的 进程 相同，除非 这个 被command命令 自己 改变. 相反的, 读取 一个 “被popen了的” 流, 就相当于 读取 command 命令的 标准输出, 而 command 的 标准输入 则是和 调用 popen, 函数的 进程 相同.
注意, popen 函数的 输出流 默认是 被全缓冲的.
pclose 函数 等待 相关的进程 结束 并返回 一个 command 命令的 退出状态, 就像 wait4 函数 一样
② 关于进程
操作系统进程描述(1)
system process
进程文件：[system process] or [system process]
进程名称：Windows内存处理系统进程
描述：Windows页面内存管理进程，拥有0级优先。
是否为系统进程：是
alg.exe
进程文件：alg or alg.exe
进程名称：应用层网关服务
描述：这是一个应用层网关服务用于网络共享。
是否为系统进程：是
csrss.exe
进程文件：csrss or csrss.exe
进程名称：Client/Server Runtime Server Subsystem
描述：客户端服务子系统，用以控制Windows图形相关子系统。
是否为系统进程：是
ddhelp.exe
进程文件：ddhelp or ddhelp.exe
进程名称：DirectDraw Helper
描述：DirectDraw Helper是DirectX这个用于图形服务的一个组成部分。
是否为系统进程：是
dllhost.exe
进程文件：dllhost or dllhost.exe
进程名称：DCOM DLL Host进程
描述：DCOM DLL Host进程支持基于COM对象支持DLL以运行Windows程序。
是否为系统进程：是
inetinfo.exe
进程文件：inetinfo or inetinfo.exe
进程名称：IIS Admin Service Helper
描述：InetInfo是Microsoft Internet Infomation Services (IIS)的一部分，用于Debug调试除错。
是否为系统进程：是
internat.exe
进程文件：internat or internat.exe
进程名称：Input Locales
描述：这个输入控制图标用于更改类似国家设置、键盘类型和日期格式。
是否为系统进程：是
kernel32.dll
进程文件：kernel32 or kernel32.dll
进程名称：Windows壳进程
描述：Windows壳进程用于管理多线程、内存和资源。
是否为系统进程：是
lsass.exe
进程文件：lsass or lsass.exe
进程名称：本地安全权限服务
描述：这个本地安全权限服务控制Windows安全机制。
是否为系统进程：是
mdm.exe
进程文件：mdm or mdm.exe
进程名称：Machine Debug Manager
描述：Debug除错管理用于调试应用程序和Microsoft Office中的Microsoft Script Editor脚本编辑器。
是否为系统进程：是
mmtask.tsk
进程文件：mmtask or mmtask.tsk
进程名称：多媒体支持进程
描述：这个Windows多媒体后台程序控制多媒体服务，例如MIDI。
是否为系统进程：是
mprexe.exe
进程文件：mprexe or mprexe.exe
进程名称：Windows路由进程
描述：Windows路由进程包括向适当的网络部分发出网络请求。
是否为系统进程：是
msgsrv32.exe
进程文件：msgsrv32 or msgsrv32.exe
进程名称：Windows信使服务
描述：Windows信使服务调用Windows驱动和程序管理在启动。
是否为系统进程：是
mstask.exe
进程文件：mstask or mstask.exe
进程名称：Windows计划任务
描述：Windows计划任务用于设定继承在什么时间或者什么日期备份或者运行。
是否为系统进程：是
regsvc.exe
进程文件：regsvc or regsvc.exe
进程名称：远程注册表服务
描述：远程注册表服务用于访问在远程计算机的注册表。
是否为系统进程：是
rpcss.exe
进程文件：rpcss or rpcss.exe
进程名称：RPC Portmapper
描述：Windows 的RPC端口映射进程处理RPC调用(远程模块调用)然后把它们映射给指定的服务提供者。
是否为系统进程：是
services.exe
进程文件：services or services.exe
进程名称：Windows Service Controller
描述：管理Windows服务。
是否为系统进程：是
smss.exe
进程文件：smss or smss.exe
进程名称：Session Manager Subsystem
描述：该进程为会话管理子系统用以初始化系统变量，MS-DOS驱动名称类似LPT1以及COM，调用Win32壳子系统和运行在Windows登陆过程。
是否为系统进程：是
snmp.exe
进程文件：snmp or snmp.exe
进程名称：Microsoft SNMP Agent
描述：Windows简单的网络协议代理（SNMP）用于监听和发送请求到适当的网络部分。
是否为系统进程：是
spool32.exe
进程文件：spool32 or spool32.exe
进程名称：Printer Spooler
描述：Windows打印任务控制程序，用以打印机就绪。
是否为系统进程：是
spoolsv.exe
进程文件：spoolsv or spoolsv.exe
进程名称：Printer Spooler Service
描述：Windows打印任务控制程序，用以打印机就绪。
是否为系统进程：是
stisvc.exe
进程文件：stisvc or stisvc.exe
进程名称：Still Image Service
描述：Still Image Service用于控制扫描仪和数码相机连接在Windows。
是否为系统进程：是
svchost.exe
进程文件：svchost or svchost.exe
进程名称：Service Host Process
描述：Service Host Process是一个标准的动态连接库主机处理服务。
是否为系统进程：是
system
进程文件：system or system
进程名称：Windows System Process
描述：Microsoft Windows系统进程。
是否为系统进程：是
taskmon.exe
进程文件：taskmon or taskmon.exe
进程名称：Windows Task Optimizer
描述：windows任务优化器监视你使用某个程序的频率，并且通过加载那些经常使用的程序来整理优化硬盘。
是否为系统进程：是
tcpsvcs.exe
进程文件：tcpsvcs or tcpsvcs.exe
进程名称：TCP/IP Services
描述：TCP/IP Services Application支持透过TCP/IP连接局域网和Internet。
是否为系统进程：是
winlogon.exe
进程文件：winlogon or winlogon.exe
进程名称：Windows Logon Process
描述：Windows NT用户登陆程序。
是否为系统进程：是
winmgmt.exe
进程文件：winmgmt or winmgmt.exe
进程名称：Windows Management Service
描述：Windows Management Service透过Windows Management Instrumentation data (WMI)技术处理来自应用客户端的请求。
是否为系统进程：是
程序进程
absr.exe
进程文件：absr or absr.exe
进程名称：Backdoor.Autoupder Virus
描述：这个进程是Backdoor.Autoupder后门病毒程序创建的。
是否为系统进程：否
acrobat.exe
进程文件：acrobat or acrobat.exe
进程名称：Adobe Acrobat
描述：Acrobat Writer用于创建PDF文档。
是否为系统进程：否
acrord32.exe
进程文件：acrord32 or acrord32.exe
进程名称：Acrobat Reader
描述：Acrobat Reader是一个用于阅读PDF文档的软件。
是否为系统进程：否
agentsvr.exe
进程文件：agentsvr or agentsvr.exe
进程名称：OLE automation server
描述：OLE Automation Server是Microsoft Agent的一部分。
是否为系统进程：否
aim.exe
进程文件：aim or aim.exe
进程名称：AOL Instant Messenger
描述：AOL Instant Messenger是一个在线聊天和即时通讯IM软件客户端。
是否为系统进程：否
airsvcu.exe
进程文件：airsvcu or airsvcu.exe
进程名称：Microsoft Media Manager
描述：OLE 这是一个用于在硬盘上建立索引文件和文件夹，在Microsoft Media Manager媒体管理启动时运行的进程。它可以在控制面板被禁用。
是否为系统进程：否
alogserv.exe
进程文件：alogserv or alogserv.exe
进程名称：McAfee VirusScan
描述：McAfee VirusScan是一个反病毒软件用于扫描你的文档和E-mail中的病毒。
是否为系统进程：否
avconsol.exe
进程文件：avconsol or avconsol.exe
进程名称：McAfee VirusScan
描述：McAfee VirusScan是一个反病毒软件用于扫描你的文档和E-mail中的病毒。
是否为系统进程：否
avsynmgr.exe
进程文件：avsynmgr or avsynmgr.exe
进程名称：McAfee VirusScan
描述：McAfee VirusScan是一个反病毒软件用于扫描你的文档和E-mail中的病毒。
是否为系统进程：否
backWeb.exe
进程文件：backWeb or backWeb.exe
进程名称：Backweb Adware
描述：Backweb是一个Adware（广告插件，一般是由于安装某些免费软件而伴随安装上的程序）来自Backweb Technologies。
是否为系统进程：否
bcb.exe
进程文件：bcb or bcb.exe
进程名称：Borland C++ Builder
描述：Borland C++ Builder
是否为系统进程：否
calc.exe
进程文件：calc or calc.exe
进程名称：Calculator
描述：Microsoft Windows计算器程序
是否为系统进程：否
ccapp.exe
进程文件：ccapp or ccapp.exe
进程名称：Symantec Common Client
描述：Symantec公用应用客户端包含在Norton AntiVirus 2003和Norton Personal Firewall 2003。
是否为系统进程：否
cdplayer.exe
进程文件：cdplayer or cdplayer.exe
进程名称：CD Player
描述：Microsoft Windows包含的CD播放器
是否为系统进程：否
charmap.exe
进程文件：charmap or charmap.exe
进程名称：Windows Character Map
描述：Windows字符映射表用来帮助你寻找不常见的字符。
是否为系统进程：否
idaemon.exe
进程文件：cidaemon or cidaemon.exe
进程名称：Microsoft Indexing Service
描述：在后台运行的Windows索引服务，用于帮助你搜索文件在下次变得更快。
是否为系统进程：
cisvc.exe
进程文件：cisvc or cisvc.exe
进程名称：Microsoft Index Service Helper
描述：Microsoft Index Service Helper监视Microsoft Indexing Service (cidaemon.exe) 的内存占用情况，如果cidaemon.exe内存使用超过了40M，则自动重新启动该进程。
是否为系统进程：否
cmd.exe
进程文件：cmd or cmd.exe
进程名称：Windows Command Prompt
描述：Windows控制台程序。不像旧的command.com，cmd.exe是一个32位的命令行使用在WinNT/2000/XP。
是否为系统进程：否
cmesys.exe
进程文件：cmesys or cmesys.exe
进程名称：Gator GAIN Adware
描述：Gator GAIN是一个Adware插件（广告插件，一般是由于安装某些免费软件而伴随安装上的程序）。
是否为系统进程：否
ctfmon.exe
进程文件：ctfmon or ctfmon.exe
进程名称：Alternative User Input Services
描述：控制Alternative User Input Text Processor (TIP)和Microsoft Office语言条。Ctfmon.exe提供语音识别、手写识别、键盘、翻译和其它用户输入技术的支持。
是否为系统进程：否
ctsvccda.exe
进程文件：ctsvccda or ctsvccda.exe
进程名称：Create CD-ROM Services
描述：在Win9X创建CD-ROM访问服务。
是否为系统进程：否
cutftp.exe
进程文件：cutftp or cutftp.exe
进程名称：CuteFTP
描述：CuteFTP是一个流行的FTP客户端用于从FTP服务器上传/下载文件。
是否为系统进程：否
defwatch.exe
进程文件：defwatch or defwatch.exe
进程名称：Norton AntiVirus
描述：Norton Anti-Virus扫描你的文件和email以检查病毒。
是否为系统进程：否
devldr32.exe
进程文件：devldr32 or devldr32.exe
进程名称：Create Device Loader
描述：Creative Device Loader属于Create Soundblaster驱动。
是否为系统进程：否
directcd.exe
进程文件：directcd or directcd.exe
进程名称：Adaptec DirectCD
描述：Adaptec DirectCD是一个用文件管理器式的界面，烧录文件到光盘的软件。
是否为系统进程：否
dreamweaver.exe
进程文件：dreamweaver or dreamweaver.exe
进程名称：Macromedia DreamWeaver
描述：Macromedia DreamWeaver是一个HTML编辑器用于创建站点和其它类别的HTML文档。
是否为系统进程：否
em_exec.exe
进程文件：em_exec or em_exec.exe
进程名称：Logitech Mouse Settings
描述：这是Logitech MouseWare状态栏图标的进程，用于用户访问控制鼠标属性和察看MouseWare帮助。
是否为系统进程：否
excel.exe
进程文件：excel or excel.exe
进程名称：Microsoft Excel
描述：Microsoft Excel是一个电子表格程序包括在Microsoft Office中。
是否为系统进程：否
findfast.exe
进程文件：findfast or findfast.exe
进程名称：Microsoft Office Indexing
描述：Microsoft Office索引程序，用于提高Microsoft Office索引Office文档的速度。
是否为系统进程：否
frontpage.exe
进程文件：frontpage or frontpage.exe
进程名称：Microsoft FrontPage
描述：Microsoft FrontPage是一个HTML编辑器用于创建站点和其它类别的HTML文档。
是否为系统进程：否
gmt.exe
进程文件：gmt or gmt.exe
进程名称：Gator Spyware Component
描述：Gator Spyware是一个广告插件，随Gator安装和启动。
是否为系统进程：否
hh.exe
进程文件：hh or hh.exe
进程名称：Gator Windows Help
描述：Windows Help程序用以打开帮助文件和文档，包括在很多Windows程序中。
是否为系统进程：否
hidserv.exe
进程文件：hidserv or hidserv.exe
进程名称：Microsoft Human Interface Device Audio Service
描述：后台服务，用来支持USB音效部件和USB多媒体键盘。
是否为系统进程：否
QQ.exe
进程文件：QQ or QQ.exe
进程名称：QQ
描述：QQ是一个在线聊天和即时通讯客户端。
是否为系统进程：否
iexplore.exe
进程文件：iexplore or iexplore.exe
进程名称：Internet Explorer
描述：Microsoft Internet Explorer网络浏览器透过HTTP访问WWW万维网。
是否为系统进程：否
kodakimage.exe
进程文件：kodakimage or kodakimage.exe
进程名称：Imaging
描述：Kodak Imaging是一个图片察看软件。包括在Windows，用以打开图像文件。
是否为系统进程：否
loadqm.exe
进程文件：loadqm or loadqm.exe
进程名称：MSN Queue Manager Loader
描述：MSN Queue Manager Loader被随着MSN Explorer和MSN Messenger安装。他在一些时候会占用很多系统资源。
是否为系统进程：否
loadwc.exe
进程文件：loadwc or loadwc.exe
进程名称：Load WebCheck
描述：Load WebCheck用以定制一些Internet Explorer的设定，添加、删除或者更新用户profiles设定。
是否为系统进程：否
mad.exe
进程文件：mad or mad.exe
进程名称：System Attendant Service
描述：System Attendant Service是Microsoft Exchange Server的后台程序。它用以读取Microsoft Exchange的DLLs文件，写log信息和生成离线地址薄。
是否为系统进程：否
mcshield.exe
进程文件：mcshield or mcshield.exe
进程名称：McAfee VirusScan
描述：McAfee VirusScan是一个反病毒软件用以扫描你的文件和email中的病毒。
是否为系统进程：否
mgabg.exe
进程文件：mgabg or mgabg.exe
进程名称：Matrox BIOS Guard
描述：Matrox BIOS守护进程。
是否为系统进程：否
mmc.exe
进程文件：mmmc or mmc.exe
进程名称：Microsoft Management Console
描述：Microsoft Management Console管理控制程序集成了很多的系统控制选项。例如设备管理(系统、硬件)或者计算机权限控制(Administrative管理工具)。
是否为系统进程：否
mobsync.exe
进程文件：mobsync or mobsync.exe
进程名称：Microsoft Synchronization Manager
描述：Internet Explorer的一个组成部分，用以在后台同步离线察看页面。
是否为系统进程：否
mplayer.exe
进程文件：mplayer or mplayer.exe
进程名称：Windows Media Player
描述：Windows Media Player是一个用以打开音乐、声音和视频文件的软件。
是否为系统进程：否
mplayer2.exe
进程文件：mplayer2 or mplayer2.exe
进程名称：Windows Media Player
描述：Windows Media Player是一个用以打开音乐、声音和视频文件的软件。
是否为系统进程：否
msaccess.exe
进程文件：msaccess or msaccess.exe
进程名称：Microsoft Access
描述：Microsoft Access是一个数据库软件包括在Microsoft Office。
是否为系统进程：否
msbb.exe
进程文件：msbb or msbb.exe
进程名称：MSBB Web3000 Spyware Application
描述：MSBB Web3000 Spyware是包括在一些adware产品中，利用注册表随Windows启动。
是否为系统进程：否
msdtc.exe
进程文件：msdtc or msdtc.exe
进程名称：Distributed Transaction Coordinator
描述：Microsoft Distributed Transaction
Coordinator控制多个服务器的传输，被安装在Microsoft Personal Web Server和Microsoft SQL Server。
是否为系统进程：否
msiexec.exe
进程文件：msiexec or msiexec.exe
进程名称：Windows Installer Component
描述：Windows Installer的一部分。用来帮助Windows Installer package files (MSI)格式的安装文件。
是否为系统进程：否
msimn.exe
进程文件：msimn or msimn.exe
进程名称：Microsoft Outlook Express
描述：Microsoft Outlook Express是一个Email和新闻组客户端包括在Microsoft Windows。
是否为系统进程：否
msmsgs.exe
进程文件：msmsgs or msmsgs.exe
进程名称：MSN Messenger Traybar Process
描述：MSN Messenger是一个在线聊天和即时通讯客户端。
是否为系统进程：否
msoobe.exe
进程文件：msoobe or msoobe.exe
进程名称：Windows Proct Activation
描述：Windows XP License的Proct Activation产品激活程序。
是否为系统进程：否
mspaint.exe
进程文件：mspaint or mspaint.exe
进程名称：Microsoft Paint
描述：Microsoft Paint画图是一个图像编辑器包括在Microsoft Windows，它能够编辑bmp图像。
是否为系统进程：否
③ c语言编程，请求大佬们的帮忙
你在存储信息的时候，同时要把这个链表的一些信息放进去，这样的话，你下次都取出来，也可以再次把他还原成一个列表，便于你下次的一个查找，希望可以帮到你
④ C语言中怎么用fork()创建子进程运行程序并且计算时间
1、fork一般用于处理多线程任务。比如在网络中，需要同时发送多种请求报文，则可以fork出子进程来进行发包任务，而父进程则直接去做自己的逻辑任务。
2、所谓运行时间指的是已经运行了多长时间还是从进程创建到进程退出的时间？输入的程序是由程序启动还是已经在运行的
，如果是已经存在的，就试着去获取进程创建时间（WIN32
提供这样的API），然后获取当前时间，就可以得到进程已经运行了多久。如果是程序启动的，那就用类似time这种函数打桩就可以了。
⑤ 操作系统课程设计
最近没什么写日记，想写，但是对于感情方面的写多了没意思，变得庸俗。于是，我决定来一个科学的日志。下面就写写我在操作系统那门课中的一个实验：银行家算法。自从学了java，在我对游戏和网络情有独钟的基础上，我抛弃了c语言，因此，这个实验我是用java来编写的。线程我没学，所以就简单地写几个输入，然后得出结果。
银行家算法大家懂吗？我想，我们学院的都应该懂的。简单地来讲，就是假设系统有n种资源，每种资源有m个数量。又假设有k个进程。如果某进程要取得一些资源则系统首先测试是否满足资源请求要求，如果满足，则尝试分配，接着就判断分配后系统有没有发生死锁，有，就还原，没有就继续。如果某进程要求进入内存，则系统要判断所有进程的请求资源数有没有超过可用资源，有则不许建立，没有就可以建立该进程。
花了几个小时（其实大概一个小时就能搞定，不过可能困的原因，有两个错误没有看出来。我在此要提醒大家，编写程序的格式非常重要，不然检查错误是在很难。），终于写完程序和报告。下面就贴上我的代码吧。
/*
* 操作系统实验：
* 《银行家算法》本程序参考课本的例子，资源种数为3.如果要求更多可作相应更改。
*/
/**
*
* @author Kevin 华南农业大学
*/
//银行家算法，此为Banker类。
import java.util.ArrayList;
import java.util.Random;
public class Banker {
static int[] available = {10,5,7}; //各个资源可用的数量。
static ArrayList processM = new ArrayList(); //线性表，里面装的是进程。
public static void main(String[] args){ //主函数，调试用。
Process p1 = new Process(7,5,3);
Process p2 = new Process(3,2,2);
Process p3 = new Process(9,0,2);
Process p4 = new Process(2,2,2);
Process p5 = new Process(4,3,3);
processM.add(p1);
processM.add(p2);
processM.add(p3);
processM.add(p4);
processM.add(p5);
while(!p1.isOK() || !p2.isOK() || !p3.isOK() || !p4.isOK() || !p5.isOK()){ //进程都还有没满足的就继续申请。
p1 = (Process)processM.get(0);
p2 = (Process)processM.get(1);
p3 = (Process)processM.get(2);
p4 = (Process)processM.get(3);
p5 = (Process)processM.get(4);
if(!p1.isOK())
allocation(p1.request(),p1,0); //申请资源，以下同。
if(!p2.isOK())
allocation(p2.request(),p2,1);
if(!p3.isOK())
allocation(p3.request(),p3,2);
if(!p4.isOK())
allocation(p4.request(),p4,3);
if(!p5.isOK())
allocation(p5.request(),p5,4);
}
}
public static boolean allocation(int[] rq ,Process process,int n){ //进程请求分配函数，
if(process.have[0] + rq[0] > process.claim[0] || process.have[1] + rq[1] > process.claim[1] || process.have[2] + rq[2] > process.claim[2]){
System.out.println("申请失败。"+ (n+1)); //如果请求的资源比最大需求大，则申请失败。
return false;
}
else{
if(rq[0] > available[0] || rq[0] > available[0] || rq[0] > available[0]){
//如果要求的资源暂时不够，则先挂起。
}
else{
process.have[0] = process.have[0] + rq[0];
process.have[1] = process.have[1] + rq[1];
process.have[2] = process.have[2] + rq[2];
available[0] = available[0]-rq[0];
available[1] = available[1]-rq[1];
available[2] = available[2]-rq[2];
processM.add(n, process);
processM.remove(n+1);
}
if(safe()){ //如果安全，则分配成功。
System.out.println("申请成功。"+"进程"+ (n+1)+"已获得资源分别为："+ process.have[0]+" "+process.have[1]+" "+process.have[2]);
return true;
//如果安全，那资源被该进程利用。
}
else{
process.have[0] = process.have[0] - rq[0];
process.have[1] = process.have[1] - rq[1];
process.have[2] = process.have[2] - rq[2];
available[0] = available[0]+ rq[0];
available[1] = available[1]+ rq[1];
available[2] = available[2]+ rq[2];
processM.add(n, process);
processM.remove(n+1);
System.out.println("申请失败。" + (n+1)); //不安全，则申请失败.
return false;
//如果不安全，则还原，并且挂起该进程。
}
}
}
public static boolean safe(){ //判断分配后是否安全。
ArrayList rest = new ArrayList(processM);
Process test ;
int num = rest.size();
int found = num*num;
while(found > 0 && !rest.isEmpty()){
test = (Process)rest.remove(0);
if(test.claim[0] - test.have[0] <= available[0] && test.claim[1] - test.have[1] <= available[1] && test.claim[2] - test.have[2] <= available[2] ){
available[0] = available[0] + test.have[0];
available[1] = available[1] + test.have[1];
available[2] = available[2] + test.have[2];
}
else {
rest.add(test);
}
found--;
}
if(rest.isEmpty()){
return true;
}
else
return false;
}
}
class Process{ //此类为进程类，描述的是一个进程。
int[] claim =new int[3]; //这个进程需要的资源数。
int[] have = new int[3];
public Process(int n1,int n2,int n3){ //初始化进程
claim[0] = n1;
claim[1] = n2;
claim[2] = n3;
have[0] = 0;
have[1] = 0;
have[2] = 0;
}
public boolean isOK(){ //判断这个进程得到满足没有。
if(have[0] == claim[0] && have[1] == claim[1] && have[2] == claim[2]){
return true;
}
else return false;
}
public int[] request(){ //这个函数随机生成3个数，作为某个进程的请求。
Random random = new Random(); //实例化随机对象。
int[] num = new int[3];
num[0] = random.nextInt(10);
System.out.println(num[0]);
num[1] = random.nextInt(10);
System.out.println(num[1]);
num[2] = random.nextInt(10);
System.out.println(num[2]);
return num;
}
}
⑥ 怎样用C语言描述操作系统里的死锁算法谢谢。
利用银行家算法避免死锁 . 银行家算法 设Requesti是进程Pi的请求向量，如果Requesti〔j〕=K，表示进程Pi需要K个Rj类型的资源。当Pi发出资源请求后，系统按下述步骤进行检查：� (1) 如果Requesti〔j〕≤Need〔i,j〕，便转向步骤2；否则认为出错，因为它所需要的资源数已超过它所宣布的最大值。 (2) 如果Requesti〔j〕≤Available〔j〕，便转向步骤(3)；否则， 表示尚无足够资源，Pi须等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。 (3) 系统试探着把资源分配给进程Pi，并修改下面数据结构中的数值：� Available〔j〕∶=Available〔j〕-Requesti〔j〕;� Allocation〔i,j〕∶=Allocation〔i,j〕+Requesti〔j〕;� Need〔i,j〕∶=Need〔i,j〕-Requesti〔j〕;� (4) 系统执行安全性算法，检查此次资源分配后，系统是否处于安全状态。若安全，才正式将资源分配给进程Pi，以完成本次分配；否则， 将本次的试探分配作废，恢复原来的资源分配状态，让进程Pi等待。
⑦ C语言如何创建并发进程
WIN32API函数CreateProcess用来创建一个新的进程和它的主线程，这个新进程运行指定的可执行文件。
函数原型：
BOOL CreateProcess
(
LPCTSTR lpApplicationName,
LPTSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes。
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFO lpStartupInfo,
LPPROCESS_
);参数：
lpApplicationName
指向一个NULL结尾的、用来指定可执行模块的字符串。
这个字符串可以是可执行模块的绝对路径，也可以是相对路径，在后一种情况下，函数使用当前驱动器和目录建立可执行模块的路径。
这个参数可以被设为NULL，在这种情况下，可执行模块的名字必须处于 lpCommandLine 参数最前面并由空格符与后面的字符分开。
lpCommandLine
指向一个以NULL结尾的字符串，该字符串指定要执行的命令行。
这个参数可以为空，那么函数将使用lpApplicationName参数指定的字符串当做要运行的程序的命令行。
如果lpApplicationName和lpCommandLine参数都不为空，那么lpApplicationName参数指定将要被运行的模块，lpCommandLine参数指定将被运行的模块的命令行。新运行的进程可以使用GetCommandLine函数获得整个命令行。C语言程序可以使用argc和argv参数。
lpProcessAttributes
指向一个SECURITY_ATTRIBUTES结构体，这个结构体决定是否返回的句柄可以被子进程继承。如果lpProcessAttributes参数为空（NULL），那么句柄不能被继承。
在Windows NT中：SECURITY_ATTRIBUTES结构的lpSecurityDescriptor成员指定了新进程的安全描述符，如果参数为空，新进程使用默认的安全描述符。
lpThreadAttributes
同lpProcessAttribute,不过这个参数决定的是线程是否被继承.通常置为NULL.
bInheritHandles
指示新进程是否从调用进程处继承了句柄。
如果参数的值为真，调用进程中的每一个可继承的打开句柄都将被子进程继承。被继承的句柄与原进程拥有完全相同的值和访问权限。
dwCreationFlags
指定附加的、用来控制优先类和进程的创建的标志。以下的创建标志可以以除下面列出的方式外的任何方式组合后指定。
⑴值：CREATE_DEFAULT_ERROR_MODE
含义：新的进程不继承调用进程的错误模式。CreateProcess函数赋予新进程当前的默认错误模式作为替代。应用程序可以调用SetErrorMode函数设置当前的默认错误模式。
这个标志对于那些运行在没有硬件错误环境下的多线程外壳程序是十分有用的。
对于CreateProcess函数，默认的行为是为新进程继承调用者的错误模式。设置这个标志以改变默认的处理方式。
⑵值：CREATE_NEW_CONSOLE
含义：新的进程将使用一个新的控制台，而不是继承父进程的控制台。这个标志不能与DETACHED_PROCESS标志一起使用。
⑶值：CREATE_NEW_PROCESS_GROUP
含义：新进程将是一个进程树的根进程。进程树中的全部进程都是根进程的子进程。新进程树的用户标识符与这个进程的标识符是相同的，由lpProcessInformation参数返回。进程树经常使用GenerateConsoleCtrlEvent函数允许发送CTRL+C或CTRL+BREAK信号到一组控制台进程。
⑷值：CREATE_SEPARATE_WOW_VDM
如果被设置，新进程将会在一个私有的虚拟DOS机（VDM）中运行。另外，默认情况下所有的16位Windows应用程序都会在同一个共享的VDM中以线程的方式运行。单独运行一个16位程序的优点是一个应用程序的崩溃只会结束这一个VDM的运行；其他那些在不同VDM中运行的程序会继续正常的运行。同样的，在不同VDM中运行的16位Windows应用程序拥有不同的输入队列，这意味着如果一个程序暂时失去响应，在独立的VDM中的应用程序能够继续获得输入。
⑸值：CREATE_SHARED_WOW_VDM
如果WIN.INI中的Windows段的DefaultSeparateVDM选项被设置为真，这个标识使得CreateProcess函数越过这个选项并在共享的虚拟DOS机中运行新进程。
⑹值：CREATE_SUSPENDED
含义：新进程的主线程会以暂停的状态被创建，直到调用ResumeThread函数被调用时才运行。
⑺值：CREATE_UNICODE_ENVIRONMENT
含义：如果被设置，由lpEnvironment参数指定的环境块使用Unicode字符，如果为空，环境块使用ANSI字符。
⑻值：DEBUG_PROCESS
含义：如果这个标志被设置，调用进程将被当做一个调试程序，并且新进程会被当做被调试的进程。系统把被调试程序发生的所有调试事件通知给调试器。
如果你使用这个标志创建进程，只有调用进程（调用CreateProcess函数的进程）可以调用WaitForDebugEvent函数。
⑼值：DEBUG_ONLY_THIS_PROCESS
含义：如果此标志没有被设置且调用进程正在被调试，新进程将成为调试调用进程的调试器的另一个调试对象。如果调用进程没有被调试，有关调试的行为就不会产生。
⑽值：DETACHED_PROCESS
含义：对于控制台进程，新进程没有访问父进程控制台的权限。新进程可以通过AllocConsole函数自己创建一个新的控制台。这个标志不可以与CREATE_NEW_CONSOLE标志一起使用。
〔11〕值：CREATE_NO_WINDOW
含义：系统不为新进程创建CUI窗口，使用该标志可以创建不含窗口的CUI程序。
dwCreationFlags参数
还用来控制新进程的优先类，优先类用来决定此进程的线程调度的优先级。如果下面的优先级类标志都没有被指定，那么默认的优先类是NORMAL_PRIORITY_CLASS，除非被创建的进程是IDLE_PRIORITY_CLASS。在这种情况下子进程的默认优先类是IDLE_PRIORITY_CLASS。
可以选择下面的标志中的一个：
优先级：HIGH_PRIORITY_CLASS
含义：指示这个进程将执行时间临界的任务，所以它必须被立即运行以保证正确。这个优先级的程序优先于正常优先级或空闲优先级的程序。一个例子是Windows任务列表，为了保证当用户调用时可以立刻响应，放弃了对系统负荷的考虑。确保在使用高优先级时应该足够谨慎，因为一个高优先级的CPU关联应用程序可以占用几乎全部的CPU可用时间。
优先级：IDLE_PRIORITY_CLASS
含义：指示这个进程的线程只有在系统空闲时才会运行并且可以被任何高优先级的任务打断。例如屏幕保护程序。空闲优先级会被子进程继承。
优先级：NORMAL_PRIORITY_CLASS
含义：指示这个进程没有特殊的任务调度要求。
优先级：REALTIME_PRIORITY_CLASS
含义：指示这个进程拥有可用的最高优先级。一个拥有实时优先级的进程的线程可以打断所有其他进程线程的执行，包括正在执行重要任务的系统进程。例如，一个执行时间稍长一点的实时进程可能导致磁盘缓存不足或鼠标反映迟钝。
lpEnvironment
指向一个新进程的环境块。如果此参数为空，新进程使用调用进程的环境。
一个环境块存在于一个由以NULL结尾的字符串组成的块中，这个块也是以NULL结尾的。每个字符串都是name=value的形式。
因为相等标志被当做分隔符，所以它不能被环境变量当做变量名。
与其使用应用程序提供的环境块，不如直接把这个参数设为空，系统驱动器上的当前目录信息不会被自动传递给新创建的进程。对于这个情况的探讨和如何处理，请参见注释一节。
环境块可以包含Unicode或ANSI字符。如果lpEnvironment指向的环境块包含Unicode字符，那么dwCreationFlags字段的CREATE_UNICODE_ENⅥRONMENT标志将被设置。如果块包含ANSI字符，该标志将被清空。
请注意一个ANSI环境块是由两个零字节结束的：一个是字符串的结尾，另一个用来结束这个快。一个Unicode环境块是由四个零字节结束的：两个代表字符串结束，另两个用来结束块。
lpCurrentDirectory
指向一个以NULL结尾的字符串，这个字符串用来指定子进程的工作路径。这个字符串必须是一个包含驱动器名的绝对路径。如果这个参数为空，新进程将使用与调用进程相同的驱动器和目录。这个选项是一个需要启动应用程序并指定它们的驱动器和工作目录的外壳程序的主要条件。
lpStartupInfo
指向一个用于决定新进程的主窗体如何显示的STARTUPINFO结构体。
lpProcessInformation
指向一个用来接收新进程的识别信息的PROCESS_INFORMATION结构体。返回值：
如果函数执行成功，返回非零值。
如果函数执行失败，返回零，可以使用GetLastError函数获得错误的附加信息。进程的查看、创建和撤销（C语言）
例程:
#include<stdio.h>
#include<windows.h>
#include<tlhelp32.h>
intshowallproc()
{
PROCESSENTRY32pe32;//用来存储进程信息的结构体
pe32.dwSize=sizeof(pe32);
HANDLEhProcessSnap=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);//获取进程快照
if(hProcessSnap==INVALID_HANDLE_VALUE)
{
printf("调用失败 ");
return1;
}
BOOLbProc=Process32First(hProcessSnap,&pe32);
while(bProc)
{
printf("%5d%s ",pe32.th32ProcessID,pe32.szExeFile);//输出进程ID和进程名
bProc=Process32Next(hProcessSnap,&pe32);
}
CloseHandle(hProcessSnap);
return0;
}
intcreatproc()
{
charstr[256]={0};
printf("请输入可执行文件路径(*.exe): ");
scanf("%s",str);
STARTUPINFOsi={0};
si.cb=sizeof(STARTUPINFO);
si.dwFlags=STARTF_USESHOWWINDOW;
si.wShowWindow=SW_SHOW;
PROCESS_INFORMATIONpi;
if(!CreateProcess(NULL,str,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi))
{
printf("创建失败 ");
return-1;
}
else
{
printf("创建成功 ");
printf("进程号:%d ",pi.dwProcessId);
}
return0;
}
intstopproc()
{
DWORDProcessID;
printf("请输入想要终止的进程ID ");
scanf("%d",&ProcessID);
HANDLEhProcess=OpenProcess(PROCESS_TERMINATE,FALSE,ProcessID);//打开对应进程句柄
if(hProcess==NULL)
{
printf("失败 ");
return-1;
}
if(!TerminateProcess(hProcess,0))//关闭进程
{
printf("关闭失败 ");
}
else
{
printf("关闭成功 ");
}
CloseHandle(hProcess);
return0;
}
intmain()
{
intn=0;
while(n!=4)
{
printf("1查看进程 ");
printf("2创建进程 ");
printf("3终止进程 ");
printf("4结束 ");
printf("请选择:");
scanf("%d",&n);
switch(n)
{
case1:
showallproc();
break;
case2:
creatproc();
break;
case3:
stopproc();
break;
case4:
break;
default:
printf("输入有误! ");
break;
}
}
return0;
}
⑧ C语言程序。。请求帮忙注释下
access(user_id,inode,mode)的作用就是判断判user_id的用户对inode节点对应的文件是否拥有mode权限，如果拥有mode权限返回1,如果不拥有mode权限返回0.
以下代码中inode->di_mode是inode的文件权限属性值，通过位与(&)判断该属性值是否拥有包含相应的权限属性，如inode->di_mode&ODIREAD，如果值不为零，则inode的文件访问权限属性值包含ODIREAD权限，也就是其它用户对inode的文件拥有READ权限。
只要你明白了Linux下或Unix下的文件/目录访问权限关系，下面的代码就很简单了。
case READ: //mode == READ
/*如果inode的其它用户拥有READ权限(即inode->di_mode&ODIREAD 不等于0)，那么user_id当然也拥有inode对应的文件的READ权限了*/
if (inode->di_mode&ODIREAD) return 1;
/*如果inode权限包含GDIREAD（inode->di_mode&GDIREAD不等于0,也就是文件组用户拥有对该文件的READ权限），user_id又属于相应的用户组(user[k].u_gid==inode->di_gid)) )，当然也就拥有READ权限了*/
if ((inode->di_mode&GDIREAD)&&(user[k].u_gid==inode->di_gid)) return 1;
/*如果inode属主拥有READ权限（也就是文件组用户拥有对该文件的READ权限），而user_id就是inode的用户属主(即user[k].u_uid==inode->di_uid)，那user_id当然就有READ权限了*/
if ((inode->di_mode&UDIREAD)&&(user[k].u_uid==inode->di_uid)) return 1;
return 0;
...
其它类似
⑨ 操作系统题目,好的追加高分,感谢大虾
http://tieba..com/f?kz=588380474
http://blog.163.com/mqt_signature/blog/static/1049595722009429104343122/
或者看看这个，可是你需要的
《操作系统--银行家算法》
课程设计报告
1 课程设计目的 …………………………………………………… 1
2 课程设计的要求 ………………………………………………… 1
3 课程设计题目描述 ……………………………………………… 2
4 课程设计之银行家算法原理 …………………………………… 2
5 源程序结构分析及代码实现 …………………………………… 4
6 课程设计总结 …………………………………………………… 25
一、课程设计的目的
操作系统是计算机系统的核心系统软件，它负责控制和管理整个系统的资源并组织用户协调使用这些资源，使计算机高效的工作。《操作系统课程设计》是《操作系统》理论课的必要补充，是复习和检验所学课程的重要手段，本课程设计的目的是综合应用学生所学知识，通过实验环节，加深学生对操作系统基本原理和工作过程的理解，提高学生独立分析问题、解决问题的能力，增强学生的动手能力。
二、课程设计的要求
1．分析设计内容，给出解决方案（要说明设计实现的原理，采用的数据结构）。
2．画出程序的基本结构框图和流程图。
3．对程序的每一部分要有详细的设计分析说明。
4．源代码格式要规范。
5．设计合适的测试用例，对得到的运行结果要有分析。
6．设计中遇到的问题，设计的心得体会。
7．按期提交完整的程序代码、可执行程序和课程设计报告。
三、课程设计题目描述
银行家算法是一种最有代表性的避免死锁的算法。
要解释银行家算法，必须先解释操作系统安全状态和不安全状态。
安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。
不安全状态:不存在一个安全序列。不安全状态不一定导致死锁。
那么什么是安全序列呢？
安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。
银行家算法：
我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。
四、课程设计之银行家算法原理
1．银行家算法的思路
先对用户提出的请求进行合法性检查，即检查请求的是不大于需要的，是否不大于可利用的。若请求合法，则进行试分配。最后对试分配后的状态调用安全性检查算法进行安全性检查。若安全，则分配，否则，不分配，恢复原来状态，拒绝申请。
2．银行家算法中用到的主要数据结构
可利用资源向量 int Available[j] j为资源的种类。
最大需求矩阵 int Max[i][j] i为进程的数量。
分配矩阵 int Allocation[i][j]
需求矩阵 int need[i][j]= Max[i][j]- Allocation[i][j]
申请各类资源数量 int Request i[j] i进程申请j资源的数量
工作向量 int Work[x] int Finish[y]
3．银行家算法bank()
进程i发出请求申请k个j资源，Request i[j]=k
(1)检查申请量是否不大于需求量：Request i[j]<=need[i,j],若条件不符重新输入，不允许申请大于需求量。
(2)检查申请量是否小于系统中的可利用资源数量：Request i[j]<=available[i,j]，若条件不符就申请失败，阻塞该进程，用goto语句跳转到重新申请资源。
(3)若以上两个条件都满足，则系统试探着将资源分配给申请的进程，并修改下面数据结构中的数值：
Available[i,j]= Available[i,j]- Request i[j]；
Allocation[i][j]= Allocation[i][j]+ Request i[j]；
need[i][j]= need[i][j]- Request i[j]；
(4)试分配后，执行安全性检查，调用safe()函数检查此次资源分配后系统是否处于安全状态。若安全，才正式将资源分配给进程；否则本次试探分配作废，恢复原来的资源分配状态，让该进程等待。
(5)用do{…}while 循环语句实现输入字符y/n判断是否继续进行资源申请。
4．安全性检查算法（safe()函数）
(1)设置两个向量：
工作向量Work，它表示系统可提供给进程继续运行所需的各类资源数目，在执行安全性算法开始时，Work= Available。
Finish，它表示系统是否有足够的资源分配给进程，使之运行完成。开始时先做Finish[i]=0；当有足够的资源分配给进程时，再令Finish[i]=1。
(2)在进程中查找符合以下条件的进程：
条件1：Finish[i]=0；
条件2：need[i][j]<=Work[j]
若找到，则执行步骤(3)否则，执行步骤(4)
(3)当进程获得资源后，可顺利执行，直至完成，并释放出分配给它的资源，故应执行：
Work[j]= Work[j]+ Allocation[i][j]；
Finish[i]=1；
goto step 2；
(4)如果所有的Finish[i]=1都满足，则表示系统处于安全状态，否则，处于不安全状态。
五、源程序结构分析及代码实现
1．程序结构
程序共有以下五个部分：
(1).初始化chushihua()：用于程序开始进行初始化输入数据：进程数量、资源种类、各种资源可利用数量、各进程的各种资源已分配数量、各进程对各类资源最大需求数等。
(2).当前安全性检查safe()：用于判断当前状态安全性，根据不同地方的调用提示处理不同。
(3).银行家算法bank()：进行银行家算法模拟实现的模块，调用其他各个模块进行银行家算法模拟过程。
(4).显示当前状态show()：显示当前资源分配详细情况，包括：各种资源的总数量(all)、系统目前各种资源可用的数量、各进程已经得到的资源数量、各进程还需要的资源量。
(5).主程序main()
逐个调用初始化、显示状态、安全性检查、银行家算法函数，使程序有序的进行。
2．数据结构
程序使用的全局变量：
const int x=10，y=10； //定义常量
int Available[x]; //各种资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //还需求矩阵
int Request[x]; //申请各类资源的数量
int Work[x]; //工作向量，表系统可提供给进程运行所需各类资源数量
int Finish[y]; //表系统是否有足够的资源分配给进程，0为否，1为是
int p[y]; //存储安全序列
int i,j; //全局变量，主要用于循环语句中
int n,m; //n为进程的数量,m为资源种类数
int l=0,counter=0;
3．函数声明
void chushihua(); //系统初始化函数
void safe(); //安全性算法函数
void bank(); //银行家算法函数
void show (); //输出当前资源分配情况
4．主函数main()
int main()
{
cout<<…… //显示程序开始提示信息
chushihua(); //初始化函数调用
cout<<endl<<endl;
showdata(); //输出初始化后的状态
//===判断当前状态的安全性===
safe(); //安全性算法函数调用
if (l<n){
cout<<"\n当前状态不安全，无法申请,程序退出!!!!!"<<endl;
cout<<endl;
system("pause");
sign(); //调用签名函数
return 0; // break;
}
else{
int i; //局部变量
l=0;
cout<<"\n安全的状态!!!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
}
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl<<endl;
}
bank(); //银行家算法函数调用
return 0;
}
5. 操作系统银行家算法流程图：
2.源程序代码：
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//定义全局变量
const int x=10,y=10; //常量，便于修改
int Available[x]; //各资源可利用的数量
int Allocation[y][y]; //各进程当前已分配的资源数量
int Max[y][y]; //各进程对各类资源的最大需求数
int Need[y][y]; //尚需多少资源
int Request[x]; //申请多少资源
int Work[x]; //工作向量，表示系统可提供给进程继续运行所需的各类资源数量
int Finish[y]; //表示系统是否有足够的资源分配给进程，1为是
int p[y]; //存储安全序列
int i,j; //i表示进程，j表示资源
int n,m; //n为进程i的数量,m为资源j种类数
int l=0; //l用来记录有几个进程是Finish[i]=1的，当l=n是说明系统状态是安全的
int counter=0;
//函数声明
void chushihua(); //初始化函数
void safe(); //安全性算法
void show(); //函数show,输出当前状态
void bank(); //银行家算法
void jieshu(); //结束函数
void chushihua()
{
cout<<"输入进程的数量: ";//从此开始输入有关数据
cin>>n;
cout<<"输入资源种类数: ";
cin>>m;
cout<<endl<<"输入各种资源当前可用的数量( "<<m<<" 种): "<<endl;
for (j=0; j<m; j++)
{
cout<<"输入资源 "<<j<<" 可利用的数量Available["<<j<<"]: ";
cin>>Available[j]; //输入数字的过程...
Work[j]=Available[j]; //初始化Work[j]，它的初始值就是当前可用的资源数
}
cout<<endl<<"输入各进程当前已分配的资源数量Allocation["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 当前已分配的资源 "<<j<<" 数量: ";
cin>>Allocation[i][j];
}
cout<<endl;
Finish[i]=0;//初始化Finish[i]
}
cout<<endl<<"输入各进程对各类资源的最大需求Max["<<n<<"]["<<m<<"]: "<<endl;
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
cout<<" 输入进程 "<<i<<" 对资源 "<<j<<" 的最大需求数: ";
cin>>Max[i][j];
if(Max[i][j]>=Allocation[i][j]) //若最大需求大于已分配，则计算需求量
Need[i][j] = Max[i][j]-Allocation[i][j];
else
Need[i][j]=0;//Max小于已分配的时候，此类资源已足够不需再申请
}
cout<<endl;
}
cout<<endl<<"初始化完成"<<endl;
}
//安全性算法函数
void safe()
{
l=0;
for (i=0; i<n;i++)
{ //i++
if (Finish[i]==0)
{ //逐个查找Finish[i]==0的进程 条件一
counter=0; //记数器
for (j=0; j<m; j++)
{
if (Work[j]>=Need[i][j]) counter=counter+1;//可用大于需求，记数
}
if(counter==m) //i进程的每类资源都符合Work[j]>=Need[i][j] 条件二
{
p[l]=i; //存储安全序列
Finish[i]=1; //i进程标志为可分配
for (j=0; j<m;j++)
Work[j]=Work[j]+Allocation[i][j]; //释放资源
l=l+1; //记数,现在有L个进程是安全的，当L=N时说明满足安全序列
i= -1; //从第一个进程开始继续寻找满足条件一二的进程
}
}
}
}
//显示当前状态函数
void show() //函数show,输出当前资源分配情况
{
int i,j; //局部变量
int All[y]; //各种资源的总数量
int L1; //局部变量L1
cout<<"当前的状态为："<<endl;
cout<<"各种资源的总数量:"<<endl;
for (j=0;j<m;j++)
{
cout<<" 资源"<<j<<": ";
All[j]=Available[j]; //总数量=可用的+已分配的
for (i=0;i<n;i++) All[j]+=Allocation[i][j];
cout<<All[j]<<" ";
}
cout<<endl<<"当前各种资源可用的量为(available):"<<endl;
for (j=0;j<m;j++)
cout<<" 资源"<<j<<": "<<Available[j]<<" ";
cout<<endl<<"各进程已经得到的资源量(allocation): "<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Allocation[L1][j]<<" ";
cout<<endl;
}
}
cout<<endl<<"各进程还需要的资源量(need):"<<endl;
for(i=0;i<=m;i++)
{
for (j=i;j<m;j++) cout<<" 资源"<<j;
cout<<endl;
for(L1=0;L1<n;L1++)
{
cout<<"进程"<<L1<<":";
for (j=i;j<m;j++) cout<<Need[L1][j]<<" ";
cout<<endl;
}
}
}
//银行家算法函数
void bank()
{
cout<<endl<<"进程申请分配资源："<<endl;
int k=0; //用于输入进程编号
bool r=false; // 初值为假，输入Y继续申请则置为真
do{//输入请求
cout<<"输入申请资源的进程(0-"<<n-1<<"): ";
cin>>k;
cout<<endl;
while(k>n-1) //输入错误处理
{
cout<<endl<<"输入错误，重新输入："<<endl;
cout<<endl<<"输入申请资源的进程(0--"<<n-1<<"): ";
cin>>k;
cout<<endl;
}
cout<<endl<<"输入该进程申请各类资源的数量: "<<endl;
for (j=0; j<m; j++)
{
do{ //do……while 循环判断申请输入的情况
cout<<"进程 "<<k<<" 申请资源["<<j<<"]的数量:";
cin>>Request[j];
cout<<endl;
if(Request[j]>Need[k][j]){ //申请大于需求量时出错，提示重新输入（贷款数目不允许超过需求数目）
cout<<"申请大于需要量!"<<endl;
cout<<"申请的资源"<<j<<"的数量为"<<Request[j]<<",大于进程"<<k<<"对该资源需求量"<<Need[k][j]<<"。"<<endl;
cout<<"重新输入!"<<endl;
}
else //先判断是否申请大于需求量，再判断是否申请大于可利用量
if(Request[j]>Available[j]){ //申请大于可利用量， 应该阻塞等待？…… ？？？
cout<<"\n没有那么多资源，目前可利用资源"<<j<<"数量为"<<Available[j]<<",本次申请不成功，进程等待!"<<endl;
Finish[k]=0; //该进程等待
goto ppp; //goto语句 跳转，结束本次申请
}
}while(Request[j]>Need[k][j]); //Request[j]>Available[j]||
}
//改变Avilable、Allocation、Need的值
for (j=0; j<m; j++) {
Available[j] = Available[j]-Request[j];
Allocation[k][j] = Allocation[k][j]+Request[j];
Need[k][j] = Need[k][j]-Request[j];
Work[j] = Available[j];
}
//判断当前状态的安全性
safe(); //调用安全性算法函数
if (l<n)
{
l=0;
cout<<"\n试分配后，状态不安全,所以不予分配!恢复原状态"<<endl;
//恢复数据
for (j=0; j<m; j++)
{
Available[j] = Available[j]+Request[j];
Allocation[k][j] = Allocation[k][j]-Request[j];
Need[k][j] = Need[k][j]+Request[j];
Work[j] = Available[j];
}
for (i=0; i<n; i++)
Finish[i]=0; //进程置为未分配状态
}
else
{
l=0;
cout<<"\n申请资源成功!!!"<<endl;
for(j=0;j<m;j++)
{
if(Need[k][j]==0);
else { //有一种资源还没全部申请到，则该进程不可执行，不能释放拥有的资源
l=1; //置l为1，作为判断标志
break;
}
}
if(l!=1){ //进程可以执行，则释放该进程的所有资源
for (j=0;j<m;j++){
Available[j]=Available[j]+Allocation[k][j];
Allocation[k][j]=0;
}
cout<<"该进程已得到所有需求资源，执行后将释放其所有拥有资源！"<<endl;
}
l=0; //归零
cout<<"\n安全的状态!"<<endl;
cout<<"安全序列为: ";
cout<<endl<<"进程"<<"("<<p[0]<<")"; //输出安全序列，考虑显示格式，先输出第一个
Finish[0]=0;
for (i=1; i<n; i++){
cout<<"==>>"<<"进程"<<"("<<p[i]<<")";
Finish[i]=0; //所有进程置为未分配状态
}
cout<<endl<<endl;
}
show(); //显示当前状态
ppp: //申请大于可利用量， 应该阻塞等待,结束本次资源申请，GOTO 语句跳转至此
cout<<endl<<"是否继续申请资源(y/n) ?";
char* b=new char; //输入y/n，判断是否继续申请 <<endl
cin>>b;
cout<<endl;
cout<<"-------------------------------------------"<<endl<<endl;
cout<<endl;
if(*b=='y'||*b=='Y')
r=true;
else{
r=false; //输入非 Y 则令 R =false
jieshu(); //调用结束函数
}
} while (r==true);
}
//结束函数
void jieshu()
{
cout<<endl<<endl;
cout<<"\t\t 演示计算完毕"<<endl;
cout<<endl<<endl;
}
//主函数
int main()
{
cout<<endl<<endl<<"\t\t\t\t模拟银行家算法"<<endl<<endl;
chushihua(); //初始化函数调用
cout<<endl;
show(); //输出当前状态
safe(); //判断当前状态的安全性
if (l<n) //l在safe中是用来记录安全的进程的个数的
{
cout<<"\n当前状态不安全，拒绝申请！"<<endl;
cout<<endl;
return 0;
}
else
{
int i; //局部变量
l=0;
cout<<endl<<"\n当前的状态是安全的!安全序列为:"<<endl;
cout<<"进程"<<"("<<p[0]<<")"; //输出安全序列
for (i=1; i<n; i++) cout<<"->>"<<"进程"<<"("<<p[i]<<")";
for (i=0; i<n; i++) Finish[i]=0; //所有进程置为未分配状态
cout<<endl;
}
bank(); //调用银行家算法函数
cout<<"\t\t 演示计算完毕"<<endl;
return 0;
}
运行结果：
1.初始化结果
2.检测系统资源分配是否安全结果：
六、课程设计的总结
操作系统的基本特征是并发与共享。系统允许多个进程并发执行，并且共享系统的软、硬件资源。为了最大限度的利用计算机系统的资源，操作系统应采用动态分配的策略，但是这样就容易因资源不足，分配不当而引起“死锁”。而我本次课程设计就是得用银行家算法来避免“死锁”。银行家算法就是一个分配资源的过程，使分配的序列不会产生死锁。此算法的中心思想是：按该法分配资源时，每次分配后总存在着一个进程，如果让它单独运行下去，必然可以获得它所需要的全部资源，也就是说，它能结束，而它结束后可以归还这类资源以满足其他申请者的需要。
本次程序就是按照上面的思路展开的。但是因为时间上的仓促，本课程设计的存在着以下不足：一、不能实现并发操作，即当总资源同时满足几个进程所需要的资源数时，这些进程不能同时进行，只能一一按进程顺序执行。二、扫描进程顺序单一，只能按进程到来的顺序（即编号）来扫描，从而产生的安全顺序只能是在这个顺序的基础上产生的，而其实安全顺序是有多个的。三、对进程数和资源数进行的数量进行了限制，都只能最多有十个。四、运行程序后，界面较差，进程数，所需要资源数，已分配资源数，能用资源数，不能一目了然。
这次课程设计时间上虽说仓促点，但是我依然学到了很多的实用性知识。除了更深的了解这个算法，而且对C语言进行了复习，而且其过程中有很多的知识点都不记得了，所以在此感谢在此过程中帮助过我的老师和同学。
最后的感悟就是：只要你亲自动手，你就能学到知识。
再次感谢帮助过我的老师和同学！