精华内容
下载资源
问答
  • 进程的创建与撤销
    千次阅读
    2020-10-22 15:09:12

    实验目的

    模拟进程的创建、就绪、撤销,并按优先级对进程排序。

    实现

    总体设计

    1. 数据结构定义
      结构体PCB: 进程名、ID、运行时间、优先级等,队列的排序按优先级排序。
      PCB空间: 结构体PCB数组
      队列: 就绪队列,消息缓冲队列
    2. 函数
      Create()—进程创建: 从PCB空间申请一个空PCB,填入进程参数,插入就绪队列;
      kill()—进程终止: 将指定的就绪进程移出就绪队列,清楚PCB信息;
      display()-就绪队列输出: 输出就绪队列中的进程信息,以便观察创建或撤消活动的结果;
      Sort()—进程优先级排序: 根据你定义的优先级,把进程进行排序。
      menu()—功能选择 :调用创建函数;显示就绪队列;调用终止函数;退出程序等
    3. 功能测试
      从显示出的就绪队列状态,查看操作的正确与否。

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    
    ///pcb控制块信息
    typedef struct P_node{
        char t_name[20];///进程名
        long t_id;///进程id
        float t_time;///进程运行时间
        int priority;///进程优先级
    }PCB;
    
    ///就绪队列
    typedef struct Tnode *T;
    struct Tnode{
        int data;
        T next;///指向就绪队列的下一个位置
    };
    
    ///消息缓冲队列
    typedef struct Linkqueue{
        T front,rear;///头指针和尾指针分别指向就绪队列的头和尾
    }LQ;
    
    LQ L;
    PCB pcb[100];///结构体PCB数组,模拟当前内存大小
    int N=0;///当前已经创建的进程数目
    
    ///就绪队列初始化
    void InitQueue(){
        L.rear=L.front=malloc(sizeof(T));
        if(!L.front)
            exit(-2);
        L.front->next=NULL;
        return 0;
    }
    
    ///创建进程:申请PCB,填入进程参数
    void Create(){
        int n;///要创建的进程的数目
        printf("请输入要创建的进程的数目:");
        scanf("%d",&n);
        ///要申请的进程数大于当前系统的内存
        if(n>100){
            printf("当前内存已满");
            return 0;
        }
        int i,j;
        long id;
        T t;
            for(i=1;i<=n;i++){
                ///当就绪队列为空时,第一个进程id可以直接写入
                if(L.front->next==NULL){
                    printf("请输入进程id:");
                    scanf("%ld",&pcb[i+N].t_id);
                    getchar();
                    printf("请输入进程名:");
                    gets(pcb[i+N].t_name);
                    printf("请输入进程运行时间:");
                    scanf("%f",&pcb[i+N].t_time);
                    getchar();
                    printf("请输入进程优先级:");
                    scanf("%d",&pcb[i+N].priority);
                    N++;///当前进程数加1
                }else{
                    printf("请输入进程id:");
                    scanf("%ld",&id);
                    ///当就绪队列不为空时,需要检查所创建的进程id是否重复
                    for(j=1;j<i+N;){
                        if(id==pcb[j].t_id){
                            printf("进程ID已经存在!\n请重新输入:");
                            scanf("%ld",&id);
                            j=0;
                        }else{
                            j++;
                        }
                    }
                    pcb[i+N].t_id=id;
                    getchar();
                    printf("请输入进程名:");
                    gets(pcb[i+N].t_name);
                    printf("请输入进程运行时间:");
                    scanf("%f",&pcb[i+N].t_time);
                    getchar();
                    printf("请输入进程优先级:");
                    scanf("%d",&pcb[i+N].priority);
                    N++;///当前进程数加1
                }
                ///将当前进程加入就绪队列
                t=malloc(sizeof(T));
                t->data=N;
                t->next=NULL;
                ///将就绪队列中的进程加入消息缓冲队列
                L.rear->next=t;
                L.rear=t;
    
            }
        Sort();
        return 0;
    
    }
    void Sort(){
        int i,j;
         ///将进程按优先级排序
        for(i=1;i<=N;i++){
            for(j=i+1;j<=N;j++){
                if(pcb[i].priority<pcb[j].priority){
                    PCB temp=pcb[i];
                    pcb[i]=pcb[j];
                    pcb[j]=temp;
                }
            }
    
        }
    }
    
    ///显示已经就绪的进程
    void display(){
        T p;
        p=L.front;
        if(p->next==NULL){
            printf("当前无进程!");
        }
        while(p->next!=NULL){
            p=p->next;
            printf(" 进程ID:%ld\n 进程名:%s \n运行时间:%f \n优先级:%d\n",pcb[p->data].t_id,pcb[p->data].t_name,pcb[p->data].t_time,pcb[p->data].priority);
        }
    }
    ///进程终止
    void kill(){
        int id;
        T p;
        p=L.front;
        if(p->next==NULL){
            printf("当前无进程!\n\n");
        }else{
            printf("输入要终止的进程的id:");
            scanf("%ld",&id);
            while(pcb[p->next->data].t_id!=id){
                if(p->next==NULL){
                    printf("该进程不存在!\n");
                    return 0;
                }
                p=p->next;
            }
            if(pcb[p->next->data].t_id==id){
                p->next=p->next->next;
                
                /*当L.front->next==NULL时,
                说明当前杀死的进程是系统中最后一个进程,
                此时首位指针指向同一个位置*/
                
                if(L.front->next==NULL){
                    L.front=L.rear;
                }
                /*当p->next==NULL时,
                说明当前杀死的进程是队尾进程,
                此时尾指针指向p*/
                if(p->next==NULL){
                    L.rear=p;
                }
                ///删除已终止进程的PCB进程控制块信息
                while(p->next!=NULL){
                    p->next->data--;
                    pcb[p->next->data]=pcb[p->next->data+1];
                    p=p->next;
                }
            }
        printf("成功杀死进程!\n");
        return 0;
        }
    
    }
    void menu(){
        int n;
        while(1){
            printf("进程演示系统\n");
            printf("**************************************************\n");
            printf("1.创建进程\n");
            printf("2.查看进程\n");
            printf("3.杀死进程\n");
            printf("4.退出程序\n");
            printf("请输入你的选择(1-4):");
            scanf("%d",&n);
            switch(n){
                case 1:Create();
                break;
                case 2:display();
                break;
                case 3:kill();
                break;
                case 4:return 0;
                default:printf("没有这个选项!");
                break;
            }
        }
        return 0;
    }
    int main()
    {
        InitQueue();
        menu();
        return 0;
    }
    
    更多相关内容
  • 进程创建与撤消

    2013-06-13 23:20:56
    以普通程序员身份认识高级语言VC++/Java/C#的进程创建与撤销工具。
  • 进程创建与撤销

    2014-04-17 21:34:23
    熟悉有关进程管理函数的使用,加深对进程概念的理解,了解进程如何被创建和终止。
  • 进程创建与撤销的模拟实现

    千次阅读 2021-03-28 22:18:36
    Create()—进程创建:从PCB空间申请一个空PCB,填入进程参数,插入就绪队列; kill()—进程终止:将指定的就绪进程移出就绪队列,清除PCB中的信息; display()—就绪队列输出函数:输出就绪队列中的进程信息,以便...

    总体设计

    • 数据结构定义:
      结构体PCB:进程名、ID、运行时间、优先级等,队列的排序按优先级排序。
      PCB空间:结构体PCB数组
      就绪队列指针
      首尾指针
    • 函数
      InitQueue():初始化就绪队列
      Create()—进程创建:从PCB空间申请一个空PCB,填入进程参数,插入就绪队列;
      kill()—进程终止:将指定的就绪进程移出就绪队列,清除PCB中的信息;
      display()—就绪队列输出函数:输出就绪队列中的进程信息,以便观察创建或撤消活动的结果;
      Sort()—进程优先级排序,根据你定义的优先级,把进程进行排序。
      menu()—功能选择:调用创建函数;调用终止函数;显示就绪进程;退出系统等。
    • 功能测试:
      在菜单中选择执行各功能,从显示出的就绪队列状态,查看操作的正确与否。

    详细设计

    在本次模拟实验中,我主要写了六个函数。

    ——在InitQueue()中,我主要将指向就绪队列的头指针和尾指针初始化,方便后面进程的创建。
    ——在Create()函数中,我主要将要创建的进程的参数填入PCB,并插入到就绪队列中。在Create()函数中我进行了三次判断,第一次是n是否大于100,如果n>100,说明PCB数组已满(即模拟内存已满)就不能再继续创建进程了,反之可以;第二次是判断L.front->next是否为NULL,如果为NULL,说明这时创建的进程是系统中第一个进程,不用考虑进程id是否会与其他进程id重复,可直接将参数填入数组,反之我们就要判断id是否会与其他进程id重复,即第三次判断,如果id重复,我们就要重新输入,直至成功为止,然后将填入参数的PCB节点插入到就绪队列中,即进程创建成功。
    —— Sort()函数主要是对进程的优先级进行排序,这里我采用了冒泡排序将优先级高的进程放在了就绪队列的前面。
    ——display()函数主要是输出当前就绪队列中的所有就绪队列的信息,我们可以借助这个函数来查看我们的每一次操作是否成功。
    ——kill()函数主要是用来终止进程,我们进行进程的终止操作是将进程移出就绪队列,重新找到首位指针应该指向的位置,并且删除已终止的进程在PCB中的相关信息。
    ——menu()是菜单函数,让我们进行功能选择,我们可以从菜单中选择调用上述的任一函数,从而进一步对进程的创建与撤销进行操作。

    代码实现

    #include <stdio.h>
    #include <stdlib.h>
    ///pcb控制块信息
    typedef struct P_node{
        char t_name[20];///进程名
        long t_id;///进程id
        float t_time;///进程运行时间
        int priority;///进程优先级
    }PCB;
    ///就绪队列
    typedef struct Tnode *T;
    struct Tnode{
        int data;
        T next;///指向就绪队列的下一个位置
    };
    ///消息缓冲队列
    typedef struct Linkqueue{
        T front,rear;///头指针和尾指针分别指向就绪队列的头和尾
    }LQ;
    LQ L;
    PCB pcb[100];///结构体PCB数组,模拟当前内存大小
    int N=0;///当前已经创建的进程数目
    ///就绪队列初始化
    void InitQueue(){
        L.rear=L.front=malloc(sizeof(T));
        if(!L.front)
            exit(-2);
        L.front->next=NULL;
        return 0;
    }
    ///创建进程:申请PCB,填入进程参数
    void Create(){
        int n;///要创建的进程的数目
        printf("请输入要创建的进程的数目:");
        scanf("%d",&n);
        ///要申请的进程数大于当前系统的内存
        if(n>100){
            printf("当前内存已满");
            return 0;
        }
        int i,j;
        long id;
        T t;
            for(i=1;i<=n;i++){
                ///当就绪队列为空时,第一个进程id可以直接写入
                if(L.front->next==NULL){
                    printf("请输入进程id:");
                    scanf("%ld",&pcb[i+N].t_id);
                    getchar();
                    printf("请输入进程名:");
                    gets(pcb[i+N].t_name);
                    printf("请输入进程运行时间:");
                    scanf("%f",&pcb[i+N].t_time);
                    getchar();
                    printf("请输入进程优先级:");
                    scanf("%d",&pcb[i+N].priority);
                    N++;///当前进程数加1
                }else{
                    printf("请输入进程id:");
                    scanf("%ld",&id);
                    ///当就绪队列不为空时,需要检查所创建的进程id是否重复
                    for(j=1;j<i+N;){
                        if(id==pcb[j].t_id){
                            printf("进程ID已经存在!\n请重新输入:");
                            scanf("%ld",&id);
                            j=0;
                        }else{
                            j++;
                        }
                    }
                    pcb[i+N].t_id=id;
                    getchar();
                    printf("请输入进程名:");
                    gets(pcb[i+N].t_name);
                    printf("请输入进程运行时间:");
                    scanf("%f",&pcb[i+N].t_time);
                    getchar();
                    printf("请输入进程优先级:");
                    scanf("%d",&pcb[i+N].priority);
                    N++;///当前进程数加1
                }
                ///将当前进程加入就绪队列
                t=malloc(sizeof(T));
                t->data=N;
                t->next=NULL;
                ///将就绪队列中的进程加入消息缓冲队列
                L.rear->next=t;
                L.rear=t;
            }
        Sort();
        return 0;
    }
    void Sort(){
        int i,j;
         ///将进程按优先级排序
        for(i=1;i<=N;i++){
            for(j=i+1;j<=N;j++){
                if(pcb[i].priority<pcb[j].priority){
                    PCB temp=pcb[i];
                    pcb[i]=pcb[j];
                    pcb[j]=temp;
                }
            }
    
        }
    }
    ///显示已经就绪的进程
    void display(){
        T p;
        p=L.front;
        if(p->next==NULL){
            printf("当前无进程!");
        }
        while(p->next!=NULL){
            p=p->next;
            printf(" 进程ID:%ld\n 进程名:%s \n运行时间:%f \n优先级:%d\n",pcb[p->data].t_id,pcb[p->data].t_name,pcb[p->data].t_time,pcb[p->data].priority);
        }
    }
    ///进程终止
    void kill(){
        int id;
        T p;
        p=L.front;
        if(p->next==NULL){
            printf("当前无进程!\n\n");
        }else{
            printf("输入要终止的进程的id:");
            scanf("%ld",&id);
            while(pcb[p->next->data].t_id!=id){
                if(p->next==NULL){
                    printf("该进程不存在!\n");
                    return 0;
                }
                p=p->next;
            }
            if(pcb[p->next->data].t_id==id){
                p->next=p->next->next;
                /*当L.front->next==NULL时,
                说明当前杀死的进程是系统中最后一个进程,
                此时首位指针指向同一个位置*/
                if(L.front->next==NULL){
                    L.front=L.rear;
                }
                /*当p->next==NULL时,
                说明当前杀死的进程是队尾进程,
                此时尾指针指向p*/
                if(p->next==NULL){
                    L.rear=p;
                }
                ///删除已终止进程的PCB进程控制块信息
                while(p->next!=NULL){
                    p->next->data--;
                    pcb[p->next->data]=pcb[p->next->data+1];
                    p=p->next;
                }
            }
        printf("成功杀死进程!\n");
        return 0;
        }
    }
    void menu(){
        int n;
        while(1){
            printf("\n*************进程演示系统*************\n");
            printf("             1.创建进程\n");
            printf("             2.查看进程\n");
            printf("             3.杀死进程\n");
            printf("             4.退出程序\n");
            printf("***************************************\n\n");
            printf("请输入你的选择(1-4):");
            scanf("%d",&n);
            switch(n){
                case 1:Create();
                break;
                case 2:display();
                break;
                case 3:kill();
                break;
                case 4:return 0;
                default:printf("没有这个选项!");
                break;
            }
        }
        return 0;
    }
    int main()
    {
        InitQueue();
        menu();
        return 0;
    }
    

    运行截图:
    在这里插入图片描述

    展开全文
  • (1) 加深对进程概念的理解和进程创建与撤销算法; (2) 进一步认识并发执行的性质 2. 实验内容: (1) 系统级——以普通用户身份认识Windows的进程管理。通过Windows的“任务管理器”观察进程的创建、切换和撤销。 (2)...

    操作系统——进程创建与撤销算法


    1. 实验目的:

    (1) 加深对进程概念的理解和进程创建与撤销算法;
    (2) 进一步认识并发执行的性质

    2. 实验内容:

    (1) 系统级——以普通用户身份认识Windows的进程管理。通过Windows的“任务管理器”观察进程的创建、切换和撤销。
    (2) 语言级——以普通程序猿身份认识高级语言VC++/JAVA/VB的进程创建与撤销工具。
    (3) 模拟级——以OS设计师身份编程模拟实现进程创建与撤销功能,并在屏幕上观察进程活动的结果

    3. 源程序:

    (2)语言级:(C语言)

    1. 什么是原语(Primitive)
      原语:机器指令构成的一种实现特定功能的小程序,它的运行具有不可分割性。
    2. 原语特点:
      a. 贴近底层
      b. 最重要的
      c. 运行过程具有原子性(不可中断)
      d. 系统小程序
    3. 操作系统中的原语类别
      a. 进程控制用的原语: 实现进程管理和状态切换
      如:进程创建原语、进程撤销原语、阻塞原语、唤醒原语、
      进程挂起原语、进程激活原语、进程调度原语等。
      b. 进程通信用的原语:用于实现进程之间通信的,如:消息发送原语、消息接收原语等。
      c. 资源互斥与同步用的原语:解决资源互斥访问的,主要有P操作原语和V操作原语。
      d. 资源管理用的原语: 主要有请求资源的原语和释放资源的原语。

    下列是具体的代码实现:

    #include <string>`在这里插入代码片`
    #include <Windows.h>
    #include<iostream>
    #include<stdlib.h>
    
    using namespace std;
    
    /*
    new和delete取代malloc和free
    用std::string来取代char*(定义在<string>头文件中)
    
    */
    
    int Creat_Process(STARTUPINFO si, PROCESS_INFORMATION pi, std::string strCmdLine)
    {
        if (!CreateProcess(NULL,
                           (LPSTR)strCmdLine.c_str(),
            //在c语言中没有string类型,故必须通过string类对象的成员函数c_str()
            //把string 对象转换成c中的字符串样式,c_str()返回的是一个临时指针,不能对其进行操作
            //strcpy(c,s.c_str());
    
                           NULL,
                           NULL,
                           FALSE,
                           0,
                           NULL,
                           NULL,
                           &si,
                           &pi
                          )
            )
        {
            system("pause");//等待用户按一个键,然后返回。
            return 0;
        }
        return 1;
    }
    
    int main()
    {
        STARTUPINFO si;
    	ZeroMemory(&si, sizeof(si));
    	si.cb = sizeof(si);
    	PROCESS_INFORMATION pi;
    	ZeroMemory(&pi, sizeof(pi));
    	std::string strCmdLine = "ping ";
    	std::string input;
    
        cout<<"请输入要ping的命令:";
        cin>>input;
        strCmdLine += input;
    
    	if(!Creat_Process(si, pi, strCmdLine))
        {
            cout<<endl;
            cout<<"进程创建失败 @_@ !"<<endl;
            exit(0);
        }
        else
        {
            cout<<endl;
            cout<<"进程创建成功 ^_^ !"<<endl;
        }
        WaitForSingleObject(pi.hProcess, INFINITE);
        if(!CloseHandle(pi.hProcess) and !CloseHandle(pi.hThread))
        {
            cout<<endl;
            cout<<"进程已关闭 ^_^ !"<<endl;
        }
    
        return 0;
    }
    

    (3)模拟级的代码实现:

    	#include<iostream>
    	#include<stdlib.h>
    	
    	using namespace std;
    	
    	/*
    	new和delete取代malloc和free
    	用std::string来取代char*(定义在<string>头文件中)
    	
    	*/
    	
    	typedef struct {
    	    long ID;
    	    float TIME;//运行时间
    	    int PRIORITY;//优先级
    	}PCB;
    	
    	typedef struct Lnode
    	{
    	    PCB data;
    	    struct Lnode *next;
    	}Qlist,*List;
    	
    	typedef struct
    	{
    	    List front;
    	    List rear;
    	}LQ;
    	
    	
    	void Display(LQ Q)
    	{
    	    List p;
    	    p=Q.front->next;
    	    while(p)
    	    {
    	        cout<<"(进程ID:"<<p->data.ID<<" -> 进程运行时间:"<<p->data.TIME<<" -> 进程优先级:"<<p->data.PRIORITY<<")"<<endl;
    	        p=p->next;
    	    }
    	    cout<<endl;
    	}
    	
    	void InitQueue(LQ &Q)
    	{
    	    Q.front=Q.rear=new Qlist;
    	    Q.front->next=NULL;
    	}
    	
    	void Enqueue(LQ &Q, List new_p, PCB e)
    	{
    	    List p=new Qlist;
    	    p->data.ID=e.ID;
    	    p->data.PRIORITY=e.PRIORITY;
    	    p->data.TIME=e.TIME;
    	    p->next=NULL;
    	
    	    if(Q.front == Q.rear)
    	    {
    	        Q.rear->next=p;
    	        Q.rear=p;
    	    }
    	    else
    	    {
    	        p->next=new_p->next;
    	        new_p->next=p;
    	        new_p=p;
    	        //cout<<"new_p:进程ID:"<<new_p->data.ID<<"进程运行时间:"<<new_p->data.TIME<<"进程优先级:"<<new_p->data.PRIORITY<<endl;
    	        //cout<<"p:进程ID:"<<new_p->data.ID<<"进程运行时间:"<<new_p->data.TIME<<"进程优先级:"<<new_p->data.PRIORITY<<endl;
    	    }
    	    //cout<<"Enqueue";
    	    //Display(Q);
    	}
    	
    	int KILL(LQ &Q, PCB &e)
    	{
    	    if(Q.front==Q.rear)
    	    {
    	        cout<<"队空!"<<endl;
    	        return 0;
    	    }
    	    List p;
    	    p=Q.front->next;
    	    e.ID=p->data.ID;
    	    e.PRIORITY=p->data.PRIORITY;
    	    e.TIME=p->data.TIME;
    	
    	    Q.front->next=p->next;
    	    if(Q.rear==p)
    	        Q.rear=Q.front;
    	    delete p;
    	
    	    return 1;
    	
    	}
    	
    	void Creat_Process(LQ &Q)
    	{
    	    int n;
    	    PCB pcb;
    	    List p1, p1_next;
    	
    	    cout<<"输入要创建进程的个数:";
    	    cin>>n;
    	
    	    for(int i=0; i<n; i++)
    	    {
    	        cout<<"进程ID:";
    	        cin>>pcb.ID;
    	
    	        cout<<"进程运行时间:";
    	        cin>>pcb.TIME;
    	
    	        cout<<"进程优先级:";
    	        cin>>pcb.PRIORITY;
    	
    	        p1=Q.front;
    	        if(Q.front == Q.rear)
    	            Enqueue(Q, p1, pcb);
    	        else
    	        {
    	            //cout<<"123"<<endl;
    	            p1_next=p1->next;
    	            while(p1)
    	            {
    	                while( p1_next && p1_next->data.PRIORITY == pcb.PRIORITY )//同一等级,先来后到,高等级优先
    	                {
    	                    p1=p1->next;
    	                    p1_next=p1->next;
    	                }
    	                //cout<<"1728  "<<p1_next->data.PRIORITY<<endl;
    	                if( p1_next && p1_next->data.PRIORITY > pcb.PRIORITY)
    	                {
    	                    //cout<<"kksadh"<<endl;
    	                    Enqueue(Q, p1, pcb);
    	                    break;
    	                }
    	                else
    	                {
    	                    //cout<<"11982"<<endl;
    	                    Enqueue(Q, Q.rear, pcb);
    	                    break;
    	
    	                }
    	                //cout<<"1714sadh"<<endl;
    	                p1=p1->next;
    	                p1_next=p1->next;
    	            }
    	
    	        }
    	
    	    }
    	    //cout<<"Creat_Process"<<endl;
    	    //Display(Q);
    	
    	}
    	
    	
    	int main()
    	{
    	    LQ Qpcb;
    	    InitQueue(Qpcb);
    	    PCB data;
    	    int n;
    	    while(1)
    	    {
    	        cout<<"*************菜单栏**************"<<endl;
    	        cout<<"  创建进程:1       撤销进程:2"<<endl;
    	        cout<<"  输出就绪队列:3   退出操作:4"<<endl;
    	        cout<<"*********************************"<<endl;
    	        cout<<"输入操作序号:";
    	        cin>>n;
    	        switch(n)
    	        {
    	        case 1:
    	            Creat_Process(Qpcb);break;
    	        case 2:
    	            KILL(Qpcb, data);
    	            cout<<"撤销的进程的相关信息("<<"进程ID:"<<data.ID<<"进程运行时间:"<<data.TIME<<"进程优先级:"<<data.PRIORITY<<"("<<endl;
    	            break;
    	        case 3:
    	            Display(Qpcb);break;
    	        case 4:
    	            break;
    	        default:
    	            cout<<"输入错误!!!"<<endl;
    	        }
    	        if(n == 4) break;
    	
    	    }
    	    //Display(Qpcb);
    	
    	    return 0;
    	}
    

    3)模拟级运行结果:

    在这里插入图片描述

    展开全文
  • 程序分为四部分:进程创建、进程撤消、显示就绪队列、退出。 进程创建:向PCB申请空间,用户输入进程名、运行时间、优先级,程序自动给进程分配ID。 按照优先级的高低顺序进就绪队列。 进程撤消:用户输入要撤销进程...
  • 计算机操作系统实验一,模拟进程创建与撤销,c++实现
  • (1)理解磁盘调度相关理论 (2)加深对操作系统进程管理功能的理解 (3)培养编写复杂程序的能力
  • 操作系统实验
  • 在Linux系统下用fork()函数创建进程,lockf()函数对进程加锁,实现进程创建撤销与控制。 四、源代码 1.进程的创建 #include<stdio.h> main() { int p1,p2; while((p1=fork())==-1); if(p1==0) putchar('b');...

    进程的创建撤销和控制

    一、实验名称
    进程的创建撤销和控制
    二、实验内容
    学生独立设计用于描述进程的数据结构,完成进程的创建、同步和互斥。
    三、实验原理和设计思路
    在Linux系统下用fork()函数创建进程,lockf()函数对进程加锁,实现进程的创建撤销与控制。
    四、源代码
    1.进程的创建

    #include<stdio.h>
    main()
    {
    int p1,p2;
    while((p1=fork())==-1);
    if(p1==0)
    putchar('b');
    else
    {
    while((p2=fork())==-1);
    if(p2==0)
    putchar('c');
    else
    putchar('a');
    }
    }
    

    2.进程的控制

    #include<stdio.h>
    main()
    {
    int p1,p2,i;
    while((p1=fork())==-1);
    if(p1==0)
    for(i=0;i<50;i++)
    printf("child %d\n",i);
    else
    {
    while((p2=fork())==-1);
    if(p2==0)
    for(i=0;i<50;i++)
    printf("son %d\n",i);
    else
    for(i=0;i<50;i++)
    printf("daughter %d\n",i);
    }
    }
    

    3.进程的控制2

    #include<stdio.h>
    #include<unistd.h>
    main()
    {
    int p1,p2,i;
    while((p1=fork())==-1);
    if(p1==0)
    {
    lockf(1,1,0);
    for(i=0;i<50;i++)
    printf("child %d\n",i);
    lockf(1,0,0);
    }
    else
    {
    while((p2=fork())==-1);
    if(p2==0)
    {
    lockf(1,1,0);
    for(i=0;i<50;i++)
    printf("son %d\n",i);
    lockf(1,0,0);
    }
    else
    {
    lockf(1,1,0);
    for(i=0;i<50;i++)
    printf("daughter %d\n",i);
    lockf(1,0,0);
    }
    }
    }
    

    4.软中断通信

    #include<unistd.h>
    #include<stdio.h>
    #include<signal.h>
    void waiting(),stop();
    int wait_mark;
    main()
    {
    int p1,p2;
    while((p1=fork())==-1);
    if(p1>0)
    {
    while((p2=fork())==-1);
    if(p2>0)
    {
    printf("parent \n");
    wait_mark=1;
    signal(SIGINT,stop);
    waiting(0);
    kill(p1,16);
    kill(p2,17);
    wait(0);
    wait(0);
    printf("parent process is killed! \n" );
    exit(0);
    }
    else
    {
    printf("p2 \n");
    wait_mark=1;
    signal(17,stop);
    waiting();
    lockf(stdout,1,0);
    printf("child process 2 is killed by parent! \n");
    lockf(stdout,0,0);
    exit(0);
    }
    }
    else
    {
    printf("p1\n");
    wait_mark=1;
    signal(16,stop);
    waiting();
    lockf(stdout,1,0);
    printf("chile process 1 is killed by parent! \n");
    lockf(stdout,0,0);
    exit(0);
    }
    }
    void waiting()
    {
    while(wait_mark!=0);
    }
    void stop()
    {
    wait_mark=0;
    }
    

    5.软中断通信2

    #include<unistd.h>
    #include<stdio.h>
    #include<signal.h>
    
    int pid1,pid2;
    int EndFlag=0,pf1,pf2=0;
    
    void IntDelete()
    {
    kill(pid1,16);
    kill(pid2,17);
    EndFlag=1;
    }
    void Int1()
    {
    printf("child process 1 is killed by parent!");
    exit(0);
    }
    void Int2()
    {
    printf("child process 2 is killed by parent!");
    exit(0);
    }
    main()
    {
    int exitpid;
    signal(SIGINT,SIG_IGN);
    signal(SIGQUIT,SIG_IGN);
    while((pid1=fork())==-1);
    if(pid1==0)
    {
    printf("p1\n");
    signal(SIGUSR1,Int1);
    signal(16,SIG_IGN);
    pause();
    exit(0);
    }
    else
    {
    while((pid2=fork())==-1);
    if(pid2==0)
    {
    printf("p2\n");
    signal(SIGUSR2,Int2);
    signal(17,SIG_IGN);
    pause();
    exit(0);
    }
    else
    {
    printf("parent\n");
    signal(SIGINT,IntDelete);
    waitpid(-1,&exitpid,0);
    printf("parent process is killed!\n");
    exit(0);
    }
    }
    }
    

    五、结果截图

    图 1 进程的创建
    在这里插入图片描述

    图 2 进程的控制
    在这里插入图片描述

    图 3 进程的控制
    在这里插入图片描述

    图 4 进程的控制
    在这里插入图片描述

    图 5 进程的控制(2)
    在这里插入图片描述

    图 6 进程的控制(2)

    在这里插入图片描述

    图 7 进程的控制(2)
    在这里插入图片描述

    六、编程体会
             在这次的操作系统实验中,系统环境从Windows换为了Linux,开始的时候有很多地方都不是很适应。比如在Linux中的vim编辑器编写代码非常困难,因为很多的快捷键也忘的差不多了,而且编写习惯又与Windows下编译器有点不一样。之后就好多了,通过一个一个查阅资料,多敲了几遍代码,慢慢的也可以掌握一些Linux环境下的基础操作。在程序编写过程中,涉及了用fork()函数创建进程,lockf()函数对进程加锁,实现进程的创建撤销与控制。这些在以往的代码编写中是没有遇到的,遇到了很大的难题。比如fork()函数的具体作用是什么?如果使用?只好通过询问同学、老师,查询资料,慢慢的才理解fork()函数的真正意思。通过这次实验,使得自己对于进程的创建、撤销、控制等基本操作有了初步的了解,希望对今后的学习生活有所帮助。

    展开全文
  • 进程创建、控制与撤消 一、目的: 通过进程的创建和控制的设计来达到如下目的: 1、加深对进程概念的理解,明确进程和程序的区别; 2、进一步认识并发执行的概念,区别顺序执行和并发执行; 3、分析进程争用临界资源...
  • 2、能够使用系统调用完成进程创建,形成多进程并发执行的环境. 实验基础 一、LINUX进程 引入进程概念,是为了描述多道程序的并发执行。为了执行一个程序,首先要创建进程。资源足够时,os为进程分配内存资源。操作...
  • OS作业
  • 创建撤销pcbjin进程

    2013-06-13 23:19:41
    以OS设计师身份编程模拟实现进程创建与撤销功能,并在屏幕上观察进程活动的结果。
  • 创建一个windows窗口程序,含有4个菜单项,分别用来创建撤消记事本进程和计算器进程。若相应进程已经创建了,再选择创建进程菜单,则弹出对话框提示进程已经创建;若进程已经撤消了,再选择撤消进程菜单,则弹出对话框...
  • 内核中进程的信息 进程的信息主要保存在task_struct中 ...fork: 通过拷贝当前进程创建一个子进程 exec: 读取可执行文件,将其载入到内存中运行 创建的流程 调用dup_task_struct()为新进程分配内核栈,task_struc
  • 进程创建、控制与撤消.pdf
  • 模拟进程创建、终止、阻塞、唤醒原语--附带注释.pdf
  • 进程创建与管理.docx

    2019-06-09 16:38:42
    设计一个有 N个进程并发执行的进程调度模拟程序。 进程调度算法:采用最高优先级优先的调度算法(即把处理机分配给优先级最高的进程)和先来先服务(若优先级相同)算法。
  • 操作系统---(14)进程创建与撤销

    千次阅读 2020-03-23 15:08:45
    进程从产生到消亡的整个过程中都是由操作系统来控制的。操作系统中实现进程控制的功能程序一“ 原语” 原语 什么是原语(Primitive) 原语:机器指令构成的一种实现特定功能的小程序,它的运行具有不可分割性。 ...
  • 进程创建而产生处于就绪状态。 进程因调用而运行,运行中的进程可能发生等待事件,比如访问的设备资源未满足,所以进程处于等待状态。 等待状态的进程因等待结束,进程就会处于就绪态。 另外,运行中的进程可能被...
  • C语言模拟实现操作系统中进程撤销,操作简单,注释清晰,以进程树的形式,实时显示模拟进程的情况;C语言模拟实现操作系统中进程撤销,操作简单,注释清晰,以进程树的形式,实时显示模拟进程的情况
  • 它因创建而产生,因调度而运行,因等待资源或事件而被处于等待状态,因完成任务而被撤消,反映了一个程序在一定的数据集上运行的全部动态过程。  线程(Thread)是进程的一个实体,是CPU调度和分派的基本单位。...
  • Windows线程的创建与撤销 操作系统实验
  • Linux——进程创建和进程终止

    千次阅读 2021-03-15 21:05:48
    进程创建&进程终止1.进程创建1.1fork函数初识1.2 fork函数返回值1.3 写时拷贝2.进程终止 1.进程创建 1.1fork函数初识 fork函数,从已存在进程中创建一个新进程,新进程为子进程,而原进程为父进程 进程调用...
  • c# 进程创建与撤销

    千次阅读 2020-04-30 14:34:55
    1、创建进程 using System; using System.Diagnostics; using System.ComponentModel; namespace MyProcessSample { class MyProcess { public static void Main() { try ...
  • 进程 创建 撤销 控制

    2010-06-24 19:58:28
    通过进程创建和控制的设计来达到如下目的: 加深对进程概念的理解,明确进程和程序的区别; 进一步认识并发执行的概念,区别顺序执行和并发执行; 分析进程争用临界资源的现象,学习解决进程互斥的方法;
  • 关键字: Linux进程创建的实例 进程控制原语 进程的阻塞和唤醒 进程的撤销 进程的挂起和激活

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 67,092
精华内容 26,836
关键字:

进程的创建与撤销

友情链接: VCserialCom.rar