精华内容
下载资源
问答
  • Linux下C语言进程实现TCP程序
  • C语言实现进程的管理,结构简单明了。
  • C语言守护进程实现

    2020-12-09 09:30:44
    为避免终端挂起,将父进程退出,造成程序已经退出的假象,所有后面的工作都在子进程完成,这样控制终端也可以继续执行其他命令,从而在形式上脱离控制终端的控制。 由于父进程先于子进程退出,子进程就变为孤儿进程...

    创建子进程,父进程退出

    编写守护进程第一步,就是要使得进程独立于终端后台运行。为避免终端挂起,将父进程退出,造成程序已经退出的假象,所有后面的工作都在子进程完成,这样控制终端也可以继续执行其他命令,从而在形式上脱离控制终端的控制。

    由于父进程先于子进程退出,子进程就变为孤儿进程,并由 init 进程作为其父进程收养。

    子进程创建新会话

    经过上一步,子进程已经后台运行,然而系统调用 fork 创建子进程,子进程便复制了原父进程的进程控制块(PCB),相应地继承了一些信息,包括会话、进程组、控制终端等信息。尽管父进程已经退出,但子进程的会话、进程组、控制终端的信息没有改变。为使子进程完全摆脱父进程的环境,需要调用 setsid 函数。

    /* Daemonize a process */
    void goDaemon()
    {
        int fd;
        pid_t pid;                
    
        pid = fork();             
        if (pid < 0) {            
            merror(FORK_ERROR, errno, strerror(errno));
            return;               
        } else if (pid) {         
            exit(0);
        }  
    
        /* Become session leader */    
        if (setsid() < 0) {       
            merror(SETSID_ERROR, errno, strerror(errno));
            return;
        }  
    
        /* Fork again */          
        pid = fork();             
        if (pid < 0) {            
            merror(FORK_ERROR, errno, strerror(errno));
            return;               
        } else if (pid) {         
            exit(0);
        }  
    
        /* Dup stdin, stdout and stderr to /dev/null */
        if ((fd = open("/dev/null", O_RDWR)) >= 0) {
            dup2(fd, 0);          
            dup2(fd, 1);          
            dup2(fd, 2);          
    
            close(fd);            
        }  
    
        /* Go to / */             
        if (chdir("/") == -1) {   
            merror(CHDIR_ERROR, "/", errno, strerror(errno));
        }  
    
        nowDaemon();
    }
    

    参考链接

    展开全文
  • C语言进程调度

    2018-10-19 09:36:27
    用C实现进程轮转调度和优先级调度,具体要求: 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。 调度算法: 时间片循环法 1、 设计进程控制块PBC表结构,适用循环时间片轮转算法。 2、 PBC结构通常包括...
  • 概念:按一定的算法,从一组待运行的进程中选出一个来占有CPU运行 调度算法: 1.先来先服务调度算法:(FCFS first come first serve)也称为FIFO算法 ...目的是改善短程序的响应时间,周期性地进行进程切换

    概念:按一定的算法,从一组待运行的进程中选出一个来占有CPU运行

    调度算法:

    1.先来先服务调度算法:(FCFS first come first serve)也称为FIFO算法

    先来先处理,算法优点:简单,实现容易,并且似乎很公平。缺点:短的任务也可能变得非常慢,因为其前面的任务占用很长时间,容易造成平均响应时间非常慢

    2.时间片轮转法

    目的是改善短程序的响应时间,周期性地进行进程切换。时间片轮转调度是一种最古老,最简单,最公平且使用最广的算法。每个进程被分配一个时间段,称作它的时间片,即该进程允许运行的时间。如果在时间片结束时进程还在运行,则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束,则CPU当即进行切换。此算法的关键点在于时间片的选择,时间片大小的确定是由系统对响应时间的要求、就绪队列中进程的数目和系统的处理能力决定。

    3.短进程优先调度算法(STCF short time to complete first)

    STCF分为抢占式和非抢占式,非抢占式是让已经在CPU上运行的程序执行到结束或阻塞,然后在所有就绪进程中选择执行时间最短的,抢占式则是每进来一个新的进程,就对所有进程(包括CPU上执行的过程)进行检查,谁的执行时间短,就运行谁。

    4.高优先级优先调度算法

    动态调整优先级,使得长任务的程序优先级高,解决STCF遇到的长任务的程序饥饿问题。



    展开全文
  • 请编写一个程序,模拟若干进程调度执行的情况。假设进程的状态分为执行和就绪两种。每个进程以其PCB为代表即可,无需创建真正的进程。 ```c #include <stdio.h> #include <stdlib.h> #include <time...

    请编写一个程序,模拟若干进程调度执行的情况。假设进程的状态分为执行和就绪两种。每个进程以其PCB为代表即可,无需创建真正的进程。

    
    ```c
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <windows.h>
    #define free 0
    #define ready 1
    #define running 2
    #define ts 2 /* time slice */
    //函数定义
    
    void init(int );
    struct PCB* readyQueueToRunningQueue(struct PCB *);
    void runningQueneToReadyQuene(struct PCB *);
    void runningQueneToFreeQuene(struct PCB *);
    void paraInit(struct PCB *,int ,int );
    void prpcb(struct PCB* );
    void scheduling();
    int input();
    
    struct PCB {
        int pid;    /* 进程ID  */
        int pstate;  /* 进程状态 */
        char pname[3]; /* 映象名称 */
        int ptime;   /* 剩余运行时间 */
        struct PCB *pnext;  /* 下一个PCB */
    } ;
    struct PCBQUENE{
        struct PCB head;
        int qNum;
    }freeQueue,readyQueue,runningQueue;         //创建三个队列
    
    int main()                                   //主函数入口
    {
        srand(time(0));
        int num = input();
        init(num);
        scheduling();
        printf("---------------------------------------------------------------------------\n");
        printf("freeQuene:\n");
        printQuene(&freeQueue);
        printf("Hello world!\n");
        getchar();
        getchar();
        return 0;
    }
    void init(int n){             //初始化函数
        struct PCB *pcb,*p;
        pcb = (struct PCB*)calloc(n,sizeof(struct PCB));
        for(int i=0;i<n;i++){           //创建PCB
            paraInit(&pcb[i],i,i);
            prpcb(&pcb[i]);
        }
        runningQueue.head.pnext = &pcb[0];      //设置运行队列头结点
        runningQueue.head.pnext->pstate = running;
        pcb[0].pstate = running;
        printf("当前%s运行态,%d\n",pcb[0].pname,pcb[0].pstate);
        runningQueue.qNum = 1;
        readyQueue.head.pnext = &pcb[1];     //设置准备队列头结点
        readyQueue.qNum = 1;
        p = &pcb[1];
        for(int i=2;i<n;i++){
            p->pnext = &pcb[i];
            p = p->pnext;
            readyQueue.qNum++;
        }
    }
    void printQuene(struct PCBQUENE* pcbquene){         //打印队列信息
        struct PCB *p;
        p = pcbquene->head.pnext;
        while(p!=NULL){
            prpcb(p);
            p = p->pnext;
        }
    }
    struct PCB* readyQueueToRunningQueue(struct PCB *pcb){      //准备进程加入运行队列
        struct PCB *pold;
        pcb->pstate = 2;
        pold = runningQueue.head.pnext;
        runningQueue.head.pnext = pcb;
        readyQueue.head.pnext = pcb->pnext;
        pcb->pnext = NULL;
        printf("---------------------------------------------------------------------------\n");
        printf("\t\t\t\t\tSched: %s(Ready -> Running)\n",pcb->pname);
        return pold;                     //原先运行进程返回准备插入其他队列
    }
    void runningQueneToReadyQuene(struct PCB *pcb){     //运行进程插入就绪队列
        struct PCB *p,*pold;
        pcb->pstate = 1;
        int n = 0;
        p = readyQueue.head.pnext;
        while(p){               //遍历readyquene节点个数
            n++;
            p = p->pnext;
        }
        if(n>0){
            n = rand()%n;                   //随机插入readyquene的位置
            p = readyQueue.head.pnext;
            while(n>=1){
                n--;
                p = p->pnext;
            }
            pold = p;
            p = p->pnext;
            pold->pnext = pcb;          //插入readyqueen
            pcb->pnext = p;
        }
        else{
            readyQueue.head.pnext = pcb;
        }
        printf("\t\t\t\t\tSched: %s(Running -> Ready)\n",pcb->pname);
    }
    void runningQueneToFreeQuene(struct PCB *pcb){      //运行进程插free队列
        struct PCB *p,*pold;
        pcb->pstate = 0;
        p = freeQueue.head.pnext;
        if(p==NULL){
        freeQueue.head.pnext = pcb;
        pcb->pnext = NULL;
        }
        else{
            while(p){
                pold = p;
                p = p->pnext;
            }
        pold->pnext = pcb;
        pcb->pnext = NULL;
        }
        printf("\t\t\t\t\tSched: %s(Running -> Free)\n",pcb->pname);
    }
    void prpcb(struct PCB* p)       //打印pcb节点信息
    {
        printf("pname:%s,",p->pname);
        printf("pid:%d,", p->pid);
        printf("pstate:%d,", p->pstate);
        printf("ptime:%d\n", p->ptime);
    }
    void paraInit(struct PCB *pcb,int i,int ptime){  //参数初始化
        pcb->pid = i;
        sprintf(pcb->pname,"P%d",i);//int转字符串函数
        pcb->pstate = ready;
        pcb->ptime = rand()%10 +2 ; //随机时间片>0
        printf("%s初始化完成\n",pcb->pname);
    }
    
    void scheduling(){                  //调度器
        struct PCB *p = readyQueue.head.pnext ,*q = runningQueue.head.pnext,*r;
        int time = runningQueue.head.pnext->ptime;
        while(p || q){
            if(p){                              //判断是否有等待进程
                if (time>=ts)time = ts;
                Sleep(time*300);            //睡眠时间 ms
                q->ptime-=time;
                r=readyQueueToRunningQueue(p);
    
                if (q->ptime<=0){
                   runningQueneToFreeQuene(r);
                }
                else runningQueneToReadyQuene(r);
                p = readyQueue.head.pnext;
                q = runningQueue.head.pnext;
                time = q->ptime;
                printf("readyQuene:\n");
                printQuene(&readyQueue);
                printf("runningQuene:\n");
                printQuene(&runningQueue);
            }
            else {                                //无就绪队列
    
            Sleep(time*300);
            q->ptime = 0;
            runningQueneToFreeQuene(q);
    
            q = NULL;
            }
        }
    }
    int input(){
        int num ;
        printf("input process number please:");
        while(!scanf("%d",&num)){
            fflush(stdin);      //清空缓存
            printf("it's not a number! try again\n");
        }
        return num;
    }
    
    
    
    
    展开全文
  • 项目需要,要监控二进制程序是否在运行状态,如果没有在运行状态,则检查是否存在升级文件、升级文件是否可用、是否存在备份文件、备份文件是否需要删除等等功能…… ...先放C语言实现方式,代码简单就没写备注

    项目需要,要监控二进制程序是否在运行状态,如果没有在运行状态,则检查是否存在升级文件、升级文件是否可用、是否存在备份文件、备份文件是否需要删除等等功能……
    注意这里会使用file命令检查文件是否是execute,如果程序是可执行脚本,是无法监测的。

    先放C语言实现方式,代码简单就没写备注

    #include "stdint.h"
    #include "stdio.h"
    #include "stdlib.h"
    #include "string.h"
    #include "unistd.h"
    
    #define fileName        "/opt/hello"
    #define fileNameOld     fileName"old"
    #define fileNameNew     fileName"new"
    
    int main(int argc, char *argv[])
    {
        FILE   *    stream;
        char        buf[1024];
        uint32_t    i;
        int         ret;
        uint8_t     bValidOld = 0;
        uint8_t     bValid    = 0;
        uint8_t     bValidNew = 0;
    
        if(argc > 1)
        {
            if(argv[1][0] == 'v')
            {
                printf("20160122\n");
                return 0;
            }
        }
        printf("app deamon running\n");
    
        while(1)
        {
            memset(buf,0,sizeof(buf));
            stream = popen( "ps -ef | grep "fileName" | grep -v grep | wc -l", "r" );
            fread( buf, sizeof(char), sizeof(buf), stream);
            pclose(stream);
    
            for(i=0;i<sizeof(buf);i++)
            {
                if((buf[i] <= '0') || ('9' >= buf[i]))
                {
                    buf[i] = 0;
                    break;
                }
            }
    
            ret = atoi(buf);
            printf("ret = %d\n",ret);
    
            if(ret)
            {
                sleep(2);
                continue;
            }
    
            printf("dest app isn't running , now check it\n");
    
            bValidOld = 0;
            bValid    = 0;
            bValidNew = 0;
    
            if(0 == access(fileNameNew,F_OK))
            {
                printf("found "fileNameNew);
    
                system("chmod +x "fileNameNew);
    
                memset(buf,0,sizeof(buf));
                stream = popen( "file "fileNameNew, "r");
                fread( buf, sizeof(char), sizeof(buf), stream);
                pclose(stream);
    
                if(strstr(buf,"executable"))
                {
                    printf(" and it is executable \n");
                    bValidNew = 1;
                }
                else
                {
                    printf(" but it isn't executable , remove it\n");
                    remove(fileNameNew);
                }
            }
            if(0 == access(fileName,F_OK))
            {
                printf("found "fileName);
                system("chmod +x "fileName);
    
                memset(buf,0,sizeof(buf));
                stream = popen( "file "fileName, "r");
                fread( buf, sizeof(char), sizeof(buf), stream);
                pclose(stream);
    
                if(strstr(buf,"executable"))
                {
                    printf(" and it is executable \n");
                    bValid = 1;
                }
                else
                {
                    printf(" but it isn't executable , remove it\n");
                    remove(fileName);
                }
            }
            if(0 == access(fileNameOld,F_OK))
            {
                printf("found "fileNameOld);
                system("chmod +x "fileNameOld);
    
                memset(buf,0,sizeof(buf));
                stream = popen( "file "fileNameOld, "r");
                fread( buf, sizeof(char), sizeof(buf), stream);
                pclose(stream);
    
                if(strstr(buf,"executable"))
                {
                    printf(" and it is executable \n");
                    bValidOld = 1;
                }
                else
                {
                    printf(" but it isn't executable , remove it\n");
                    remove(fileNameOld);
                }
            }
    
            if(bValidNew)
            {
                if(bValid)
                {
                    if(bValidOld)
                    {
                        printf("remove old\n");
                        remove(fileNameOld);
                    }
                    printf("rename current to old\n");
                    rename(fileName,fileNameOld);
                }
                printf("rename new to current\n");
                rename(fileNameNew,fileName);
            }
            else
            {
                if(bValid)
                {
                    if(bValidOld)
                    {
                        printf("current is valid , remove old\n");
                        remove(fileNameOld);
                    }
                }
                else
                {
                    if(bValidOld)
                    {
                        printf("rename old to current\n");
                        rename(fileNameOld,fileName);
                    }
                }
            }
            system("sync");
            system(fileName);
            sleep(2);
        }
        return 0;
    }
    

    下面是sh脚本实现,基本上就是把C语言版本做了个“翻译”

    #!/bin/sh
    
    workd=/opt/
    fileName=hello
    fileNameOld=$fileName"old"
    fileNameNew=$fileName"new"
    
    bFileValid=0
    bFileOldValid=0
    bFileNewValid=0
    
    #检查文件是否可执行
    checkFileExecutable()
    {
        #echo "check file $1 executable"
        local ret=`file $1 | grep executable | grep -v grep | wc -l`
        return $ret;
    }
    
    #检查文件是否有效,先检查是否存在,再检查是否可执行
    chechFileValid()
    {
        local valid
        if [ -f $1 ]; then
            #echo "file $1 exist"
    
            checkFileExecutable $1
            valid=$?
            if [ $valid -eq 1 ] ;  then
                #echo "file $1 is executable"
                valid=1
            else
                #echo "file $1 is note executable, remove it"
                rm $1
            fi
    
        else
            #echo "file $1 not exist"
            valid=0;
        fi
    
        return $valid;
    }
    
    chechFileValid $fileName
    bFileValid=$?
    chechFileValid $fileNameNew
    bFileNewValid=$?
    chechFileValid $fileNameOld
    bFileOldValid=$?
    
    #echo $bFileValid $bFileNewValid $bFileOldValid
    
    while [ true ] ; do
        processExist=`ps -ef | grep $fileName | grep -v grep | wc -l`
        if [ $processExist -gt 0 ] ; then
            sleep 2;
        else
            chechFileValid $fileName
            bFileValid=$?
            chechFileValid $fileNameNew
            bFileNewValid=$?
            chechFileValid $fileNameOld
            bFileOldValid=$?
    
            if [ $bFileNewValid -eq 1 ] ; then
                #echo "new file valid"
                if [ $bFileValid -eq 1 ] ; then
                    if [ $bFileOldValid -eq 1 ] ; then
                        #echo "file old found, remove it"
                        rm $fileNameOld
                    fi
                    #echo "current file valid ,rename it to old"
                    mv $fileName $fileNameOld
                fi
                #echo "new file valid ,rename it to current"
                mv $fileNameNew $fileName
            else
                if [ $bFileValid -eq 1 ] ; then
                    if [ $bFileOldValid -eq 1 ] ; then
                        #echo "file old found, remove it"
                        rm $fileNameOld
                    fi
                else
                    #echo "rename old to current"
                    mv $fileNameOld $fileName
                fi
            fi
            sync
            $workd$fileName
            sleep 1;
        fi
    done;
    展开全文
  • 进程调度实现--C语言

    2019-12-28 15:24:45
    程序主要来自https://blog.csdn.net/weixin_39373989/article/details/84778402,但是链接里的短进程优先调度算法有些错误实现不了,这是我修改后的程序,里面也有C++语言。 具体代码 去博客设置页面,选择一款...
  • C语言实现防杀进程

    2020-03-19 09:37:27
    程序原理很简单:弄俩进程,互相检测对方有没有被杀,被杀就再调一个,实现防杀效果。 原来我用了两个程序,但比较麻烦,就合并了,但是没有实现就自己运行的效果,只能自我复制一份。 可以把文件名改一下,但是要...
  • 当制作多个项目的时候,我们可以把多个应用程序集成在一起,就像网页的href一样,在几个进程中跳转,这里就在C语言实现获取进程号,然后kill掉它,启动另外一个应用程序,就这样我们就轻松实现了应用程序的模块化...
  • C语言编写程序,模拟实现创建新的进程:查看运行进程;换出某个进程:杀死运行进程等功能。 实验步骤 进程 1.进程的含义 进程程序在一个数据集合上的运行过程,是系统资源分配和调度的一个独立单位。一个程序在...
  • 2、进程调度算法模拟 ...要求使用链表,进程个数由用户提供,按照进程的实际个数生成PCB,程序能够让用户选择使用哪种调度算法,能够在Linux环境运行并验证结果。程序要考虑用户界面的友好性和使用方便性
  • 编写一个Linux C程序,在主进程中创建一个子进程,子进程中死循环输出“Hello CSU”字符串,主进程休眠10s后,向子进程发送信号结束子进程,随后主进程退出。(用信号实现进程间的通信,kill函数) 代码 #include&...
  • 进程优先算法C语言实现

    万次阅读 多人点赞 2016-10-19 23:24:49
    1、实验说明: 2、程序定义: 3、源代码示例: 4、运行结果: 5、算法流程图: 6、C语言知识点:
  • 实现简单的Deamon守护进程,包含2个功能,拉起系统所需进程、监控到有子进程意外退出时重新拉起。 目录 程序效果 功能流程 关键实现 参考资料 程序效果 截图1.Daemon父进程视角 Daemon父进程分别拉起1个...
  • 操作系统进程调度算法 c语言实现

    热门讨论 2011-04-07 08:59:30
    实现进程调度算法,具有后备序列的调度 题目:设计一个有 N个进程共行的进程调度程序进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。 每个进程有一个进程...
  • 在时间片轮转调度算法中,系统根据先来先服务的原则,将所有的就绪进程排成一个就绪队列,并且每隔一段时间产生一次中断,激活系统中的进程调度程序,完成一次处理机调度,把处理机分配给就绪队列队首进程,让其执行...
  • 一个健壮的状态机可以让你的程序,不论发生何种突发事件都不会突然进入一个不可预知的程序分支,本篇通过实现一个简单的进程5状态模型的状态机,让大家熟悉一下状态机的魅力。 定义 有限状态机(finite-state ...
  • 基于 51 单片机 多进程 多任务 纯 C语言 实现 死循环 调度 多任务 调度程序
  • 代码如下所示: 代码如下:#include <stdio>#include <string>#include <stdlib>#include <signal>#include <unistd>#include ...// argv[0] 尽量使用绝对路径, 因为程序执行过程中可能会使用 chdir() .int main(int ar
  • 1、程序中有创建、撤消、阻塞、唤醒、挂起、激活、改变优先数(K0)、改变状态(STATE)、查看PCB功能模块,为每个模块建立一个程序。 2、PCB(进程控制块)可采用数组数据结构,每个数组元素即PCB块可包含N0(外部...
  • C语言实现进程调度—时间片轮转调度算法

    万次阅读 多人点赞 2018-07-08 12:02:43
    二、设计内容 设计程序模拟单处理机系统中时间片轮转进程调度算法,每个进程由一个进程控制块(PCB)表示。进程控制块包含如下信息:进程名、到达时间、需要运行时间、完成标志与否、进程状态、还需运行的时间等。...
  • 1.相关博文链接:...2.内容描述:参考本代码可熟悉LinuxC作为服务端的socket网络通信、消息队列进程间通信、使用嵌入式sql调用PostgreSQL数据库、使用libxml2构造XML报文等功能。
  • C语言实现进程调度—短作业优先调度算法

    万次阅读 多人点赞 2018-07-08 11:59:52
    二、设计内容 设计程序模拟单处理机系统中短作业优先进程调度算法,每个进程由一个进程控制块(PCB)表示。进程控制块包含如下信息:进程名、到达时间、需要运行时间、完成标志与否、进程状态、还需运行的时间等。...
  • C语言编写程序,模拟实现创建新的进程:查看运行进程;换出某个进程:杀死运行进程等功能。 【实验步骤】 程序代码 #include "stdio.h" #include "conio.h" #include "stdlib.h" struct PCB_type { int pid...
  • Linux程序设计之线程池(C语言实现) 首先介绍Linux下线程的基础编程知识。 创建线程 #include<pthread.h> int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), ...
  • 专业 专业word可编辑 时间片轮转算法和优先级调度算法 C语言模拟实现 收藏 21気一目的和要求 进程调度是处理机管理的核心内容本实验要求用高级语言编写模拟进程调度 程序以便加深理解有关进程控制快进程队列等概念并...
  • 进程调度模拟(C语言实现)

    千次阅读 2011-05-17 16:10:36
    /** * 这是一个进程调度模拟的程序,输入阻塞进程的个数和信息,输入就绪进程的个数和信息, * 然后采用时间片轮转法进程调度,在整个调度过程中会有阻塞队列里的进程被唤醒 * 输出进程切换信息和cpu的利用率...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 843
精华内容 337
关键字:

c语言进程实现程序

c语言 订阅