c语言进程编程

⑴ 用c语言编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct PCB {
char NAME[10]; /*进程名*/
int ROUND; /*进程轮转时间片*/
int REACHTIME; /*进程到达时间*/
int CPUTIME; /*进程占用CPU时间*/
int COUNT; /*计数器*/
int NEEDTIME; /*进程完成还要的CPU时间*/
char STATE; /*进程的状态*/
struct PCB *NEXT; /*链指针*/
};

struct LINK { /*PCB的链结构*/
struct PCB *RUN; /*当前运行进程指针*/
struct PCB *READY; /*就绪队列头指针*/
struct PCB *TAIL; /*就绪队列尾指针*/
struct PCB *FINISH; /*完成队列头指针*/
};

void INIT(LINK *); /*对PCB的链结构初始化*/
void INSERT(LINK *); /*将执行了一个单位时间片数且还未完成的进程的PCB插到就绪队列的队尾*/
void FIRSTIN(LINK *); /*将就绪队列中的第一个进程投入运行*/
void PRINT(LINK *); /*打印每执行一个时间片后的所有进程的状态*/
void PR(PCB *); /*打印一个进程的状态*/
int CREATE(LINK *,int); /*创建新的进程*/
void ROUNDSCH(LINK *); /*按时间片轮转法调度进程*/

void main() {
LINK pcbs;
int i;
INIT(&pcbs);
i=0;
printf("创建5个进程\n\n");
while(i<5) {
if(CREATE(&pcbs,i+1)==1) {
printf("进程已创建\n\n");
i++;
}
else
printf("进程创建失败\n\n");
}
FIRSTIN(&pcbs);
ROUNDSCH(&pcbs);
}

void ROUNDSCH(LINK *p) {
PCB *pcb;
while(p->RUN!=NULL) {
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
pcb->CPUTIME++;
pcb->NEEDTIME--;
pcb->COUNT++;
if(pcb->NEEDTIME==0) {
pcb->NEXT=p->FINISH->NEXT;
p->FINISH->NEXT=pcb;
pcb->STATE='F';
p->RUN=NULL;
if(p->READY!=p->TAIL)
FIRSTIN(p);
}
else {
p->RUN=pcb;
if(pcb->COUNT==pcb->ROUND) {
pcb->COUNT=0;
if(p->READY!=p->TAIL) {
pcb->STATE='W';
INSERT(p);
FIRSTIN(p);
}
}
}
PRINT(p);
}
}

void INIT(LINK *p) {
p->RUN=NULL;
p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB));
p->READY->NEXT=NULL;
p->FINISH=(PCB *)malloc(sizeof(PCB));
p->FINISH->NEXT=NULL;
}

int CREATE(LINK *p,int n) {
PCB *pcb,*q;
pcb=(PCB *)malloc(sizeof(PCB));
flushall();
printf("请输入第%d个进程的名称：\n",n);
gets(pcb->NAME);
printf("请输入第%d个进程的轮转时间片数：\n",n);
scanf("%d",&(pcb->ROUND));
printf("请输入第%d个进程的到达时间：\n",n);
scanf("%d",&(pcb->REACHTIME));
pcb->CPUTIME=0;
pcb->COUNT=0;
printf("请输入第%d个进程需运行的时间片数：\n",n);
scanf("%d",&(pcb->NEEDTIME));
pcb->STATE='W';
pcb->NEXT=NULL;
if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*输入错误*/
return 0;
q=p->READY;
while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)
q=q->NEXT;
pcb->NEXT=q->NEXT;
q->NEXT=pcb;
if(pcb->NEXT==NULL)
p->TAIL=pcb;
return 1;
}

void FIRSTIN(LINK *p) {
PCB *q;
q=p->READY->NEXT;
p->READY->NEXT=q->NEXT;
q->NEXT=NULL;
if(p->READY->NEXT==NULL)
p->TAIL=p->READY;
q->STATE='R';
p->RUN=q;
}

void INSERT(LINK *p) {
PCB *pcb;
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
p->TAIL->NEXT=pcb;
p->TAIL=pcb;
p->RUN=NULL;
pcb->STATE='W';
}

void PRINT(LINK *p) {
PCB *pcb;
printf("执行一个时间片后的所有进程的状态：\n\n");
if(p->RUN!=NULL)
PR(p->RUN);
if(p->READY!=p->TAIL) {
pcb=p->READY->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}
pcb=p->FINISH->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}

void PR(PCB *p) {
printf("进程名：%s\n",p->NAME);
printf("进程轮转时间片：%d\n",p->ROUND);
printf("进程到达时间：%d\n",p->REACHTIME);
printf("进程占用CPU时间：%d\n",p->CPUTIME);
printf("计数器：%d\n",p->COUNT);
printf("进程完成还要的CPU时间：%d\n",p->NEEDTIME);
printf("进程的状态：%c\n\n",p->STATE);
}

⑵ 在Linux下用C语言编程

4。守护进程的创建
如果你在DOS时代编写过程序,那么你也许知道在DOS下为了编写一个常驻内存的程序我们要编写多少代码了.相反如果在Linux下编写一个"常驻内存"的程序却是很容易的.我们只要几行代码就可以做到. 实际上由于Linux是多任务操作系统,我们就是不编写代码也可以把一个程序放到后台去执行的.我们只要在命令后面加上&符号SHELL就会把我们的程序放到后台去运行的. 这里我们"开发"一个后台检查邮件的程序.这个程序每个一个指定的时间回去检查我们的邮箱,如果发现我们有邮件了,会不断的报警(通过机箱上的小喇叭来发出声音). 后面有这个函数的加强版本加强版本
后台进程的创建思想: 首先父进程创建一个子进程.然后子进程杀死父进程(是不是很无情?). 信号处理所有的工作由子进程来处理.

#include
#include
#include
#include
#include
#include
#include

/* Linux 的默任个人的邮箱地址是 /var/spool/mail/用户的登录名 */

#define MAIL "/var/spool/mail/hoyt"

/* 睡眠10秒钟 */

#define SLEEP_TIME 10

main(void)
{
pid_t child;

if((child=fork())==-1)
{
printf("Fork Error:%s\n",strerror(errno));
exit(1);
}
else if(child>0)
while(1);
if(kill(getppid(),SIGTERM)==-1)
{
printf("Kill Parent Error:%s\n",strerror(errno));
exit(1);
}
{
int mailfd;

while(1)
{
if((mailfd=open(MAIL,O_RDONLY))!=-1)
{
fprintf(stderr,"%s","\007");
close(mailfd);
}
sleep(SLEEP_TIME);
}
}
}

你可以在默认的路径下创建你的邮箱文件,然后测试一下这个程序.当然这个程序还有很多地方要改善的.我们后面会对这个小程序改善的,再看我的改善之前你可以尝试自己改善一下.比如让用户指定邮相的路径和睡眠时间等等.相信自己可以做到的.动手吧,勇敢的探险者.
好了进程一节的内容我们就先学到这里了.进程是一个非常重要的概念,许多的程序都会用子进程.创建一个子进程是每一个程序员的基本要求!

⑶ ）用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（本）;

}

}
}

⑷ c语言编写进程的创建与撤销

struct pb
{int n;
int k;
int cha;};
typedef struct pb PCB;
PCB a[10];void creat()
{static int pi=1;
int k,l=0,m;
printf("plase input n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=1;
if (l==1)
{printf("error!\n");
creat(); }
else
{a[pi].n=m;
printf("\n");
printf("plase input k0:");
scanf("%d",&a[pi].k);
printf("\n");
a[pi++].cha=4;}}void destory()
{int i,num,k=0;
printf(" plase input destory number:");
scanf("%d",&num);
for(i=1;i<=10;i++)
if(a[i].n==num) k=i;
if(k!=0)
{a[k].n=0;a[k].k=0;a[k].cha=0;}
else
printf("No have this destory number!\n");}void wakeup()
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
a[l].cha=1; /*唤醒->静止就绪*/}void active()
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
a[l].cha=3; /*激活->活动就绪*/}void dse()
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
a[l].cha=4; /*阻塞->活动阻塞*/}void swpend()
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
a[l].cha=2; /* 挂起->静止阻塞 */}void look()
{int i;
printf("\t\t�pcb n0 k0 cha\n");
for (i=1;i<=10;i++)
printf("\t\t%d\t%d\t%d\t%d\n",i,a[i].n,a[i].k,a[i].cha);
printf("\t1--静止就绪 2--静止阻塞 3--活动就绪 4--活动阻塞 5--运行\n");}void zt() /* 改变状态*/
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
printf("请输入当前状态:");
scanf("%d",&a[l].cha);
look();}void yxs() /*改变优先数*/
{int i,k,m,l;
printf("请输入n0:");
scanf("%d",&m);
for(k=1;k<=10;k++)
if (a[k].n==m)
l=k;
printf("请输入优先数:");
scanf("%d",&a[l].k);
look();}main()
{int d;
clrscr();
do
{
printf("\t\t*************** CHOICE *****************\n");
printf("\t\t* 1--------------进程创建 *\n");
printf("\t\t* 2--------------进程撤消 *\n");
printf("\t\t* 3--------------阻塞 *\n");
printf("\t\t* 4--------------唤醒 *\n");
printf("\t\t* 5--------------挂起 *\n");
printf("\t\t* 6--------------激活 *\n");
printf("\t\t* 7--------------查看状态 *\n");
printf("\t\t* 8--------------改变状态 *\n");
printf("\t\t* 9--------------改变优先数 *\n");
printf("\t\t* 0--------------退出 *\n");
printf("\t\t****************************************\n");
printf("\t\t�请选择(0-9):");
scanf("%d",&d);
printf("\n");
switch(d)
{
case 1: creat();break;
case 2: destory();break;
case 3: dse();break;
case 4: wakeup();break;
case 5: swpend();break;
case 6: active();break;
case 7:look();break;
case 8:zt();break;
case 9:yxs();break;
case 0: exit(0);
}
}
while(d!=0);
}

⑸ 求进程调度先来先服务算法，短进程优先算法完整c语言代码

/*（一）进程调度

进程调度算法有FIFO，优先数调度算法，时间片轮转调度算法，分级调度算法，

输入：进程流文件，其中存储的是一系列要执行的进程，
每个作业包括三个数据项：
进程名 所需时间 优先数(0级最高)
输出:
进程执行流 等待时间 平均等待时间

本程序包括:FIFO，优先数调度算法，时间片轮转调度算法

进程流文件process_stream.txt
测试数据：
p0 16 2
p1 5 1
p2 4 3
p3 8 0
p4 9 4
p5 7 6

VC++调试通过
*/
#include <stdio.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>

const int Quatum=2;//定义时间片的长度为2秒
const int MAXPCB=100;//定义最大进程数

//定义进程结构体
typedef struct node
{
char name[20];//进程名
int time; //进程运行时间
int privilege;//进程优先级（静态）
int finished;//进程完成标志，0-未完成，1-已完成
int wait_time;//进程等待时间
}pcb;

pcb pcbs[MAXPCB];
int quantiry;//进程流文件中的进程总数

void initial()
{
int i;
for (i=0;i<MAXPCB;i++)
{
strcpy(pcbs[i].name,"");
pcbs[i].time=0;
pcbs[i].privilege=0;
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
quantiry=0;
}

int readData()
{
FILE *fp;
char fname[20];
int i;
cout<<"请输入进程流文件名:"<<endl;
cin>>fname;
if ((fp=fopen(fname,"r"))==NULL)
{
cout<<"错误,文件打不开，请检查文件名"<<endl;
}
else
{
while (!feof(fp))
{
fscanf(fp,"%s %d %d %d",pcbs[quantiry].name,
&pcbs[quantiry].time,&pcbs[quantiry].privilege);
quantiry++;
}
//输出所读入得数据
cout<<"输出所读入的数据"<<endl;
cout<<"进程流文件中的进程总数="<<quantiry<<endl;
cout<<"进程名 所需时间 优先数"<<endl;

for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].time<<" "<<pcbs[i].privilege<<endl;
}

return 1;
}

return 0;
}

//重置数据，以供另一个算法使用
void init()
{
int i;
for (i=0;i<MAXPCB;i++)
{
pcbs[i].finished=0;
pcbs[i].wait_time=0;
}
}

void FIFO()
{
int i,j;

int total;
//输出FIFO算法执行流
cout<<endl<<"---------------------------------------------------------------"<<endl;
cout<<"FIFO算法执行流:"<<endl;
cout<<"进程名 等待时间"<<endl;

for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;
for (j=i+1;j<quantiry;j++)
{
pcbs[j].wait_time+=pcbs[i].time;
}
}

total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}
cout<<"总等待时间:"<<total<<" "<<"平均等待时间:"<<total/quantiry<<endl;
}

//优先度调度算法
void privilege()
{
int i,j,p;
int passed_time=0;
int total;

int queue[MAXPCB];
int current_privielege=1000;

for (i=0;i<quantiry;i++)
{
current_privielege=1000;
for (j=0;j<quantiry;j++)
{
if ((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privielege))
{
p=j;
current_privielege=pcbs[j].privilege;
}
}
queue[i]=p;
pcbs[p].finished=1;
pcbs[p].wait_time+=passed_time;
passed_time+=pcbs[p].time;

}
//输出优先数调度执行流
cout<<endl<<"-----------------------------------------"<<endl;
cout<<"优先数调度执行流:"<<endl;
cout<<"进程名 等待时间"<<endl;

for (i=0;i<quantiry;i++)
{
cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<"--"<<queue[i]<<endl;
}

total=0;
for (i=0;i<quantiry;i++)
{
total+=pcbs[i].wait_time;
}

cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantiry<<endl;
}

//时间片轮转调度算法
void timer()
{
int i,j,sum,flag=1;
int passed_time=0;
int max_time=0;
int round=0;

int queue[1000];
int total=0;

while(flag==1)
{
flag=0;
for (i=0;i<quantiry;i++)
{
if (pcbs[i].finished==0)
{
flag=1;
queue[total]=i;
total++;
if (pcbs[i].time<=Quatum*(round+1))
pcbs[i].finished=1;
}
}
round++;
}

cout<<endl<<"---------------------------------------------------------------"<<endl;
cout<<"时间片轮转调度执行流:";
for(i=0;i<total;i++)
{
cout<<pcbs[queue[i]].name<<" ";
}
cout<<endl;
cout<<"进程名 结束时间 运行时间 等待时间"<<endl;

sum=0;

for (i=0;i<quantiry;i++)
{
for(j=total-1;j>=0;j--)//从轮转调度执行流序列由后往前比较，找到同名进程即可计算其完成时间
{
if (strcmp(pcbs[queue[j]].name,pcbs[i].name)==0)
{
cout<<" "<<pcbs[i].name<<" "<<(j+1)*Quatum<<" ";
cout<<pcbs[i].time<<" "<<(j+1)*Quatum-pcbs[i].time<<endl;
sum+=(j+1)*Quatum-pcbs[i].time;
break;
}
}
}

cout<<"总等待时间:"<<sum<<" "<<"平均等待时间:"<<sum/quantiry<<endl;
}

//显示版权信息函数
void version()
{
cout<<endl<<endl;

cout<<" ┏━━━━━━━━━━━━━━━━━━━━━━━┓"<<endl;
cout<<" ┃ 进程调度模拟系统 ┃"<<endl;
cout<<" ┠───────────────────────┨"<<endl;
cout<<" ┃ version 2011 ┃"<<endl;
cout<<" ┗━━━━━━━━━━━━━━━━━━━━━━━┛"<<endl;
cout<<endl<<endl;
}
//主函数

int main()
{
int flag;
version();
initial();
flag=readData();
if(flag==1){
FIFO();
init();
privilege();
init();
timer();
}
cout<<endl;
system("pause");
return 0;
}

⑹ 使用C语言编程实现：父进程创建二个子进程，三个进程各自打印出其进程

#include <stdio.h>

#include <sys/types.h>

#include <unistd.h>

int main()

{

int i=2;

int pid=0;

printf("father id=%ld ",getpid());

while(i-->0){

pid = fork();

if(pid==0){

printf("son id=%ld ",getpid());

return 0;

}

}

return 0;

}

⑺ 怎么用C语言写一个关闭后台某进程的程序

//kill进程from名字
BOOL KillProcessFromName(LPCSTR lpProcessName)
{
//创建进程快照(TH32CS_SNAPPROCESS表示创建所有进程的快照)
HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
//PROCESSENTRY32进程快照的结构体
PROCESSENTRY32 pe;
//实例化后使用Process32First获取第一个快照的进程前必做的初始化操作
pe.dwSize = sizeof(PROCESSENTRY32);

//下面的IF效果同:
//if(hProcessSnap == INVALID_HANDLE_VALUE) 无效的句柄
if(!Process32First(hSnapShot,&pe))
{
return FALSE;
}
CString strProcessName = lpProcessName;
//将字符串转换为小写
strProcessName.MakeLower();

//如果句柄有效 则一直获取下一个句柄循环下去
while (Process32Next(hSnapShot,&pe))
{
//pe.szExeFile获取当前进程的可执行文件名称
CString scTmp = pe.szExeFile;

//将可执行文件名称所有英文字母修改为小写
scTmp.MakeLower();
//比较当前进程的可执行文件名称和传递进来的文件名称是否相同
//相同的话Compare返回0
if(!scTmp.Compare(strProcessName))
{
//从快照进程中获取该进程的PID(即任务管理器中的PID)
DWORD dwProcessID = pe.th32ProcessID;
HANDLE hProcess = ::OpenProcess(PROCESS_TERMINATE,FALSE,dwProcessID);
::TerminateProcess(hProcess,0);
CloseHandle(hProcess);
return TRUE;
}
scTmp.ReleaseBuffer();
}
strProcessName.ReleaseBuffer();
return FALSE;
}
以杀死qq程序为例，我们可以通过下列方式：
KillProcessFromName("qq.exe");