Linux——进程控制

myproc.cc

#include <iostream>
#include <vector>

typedef void (*handler_t)(); //函数指针类型

std::vector<handler_t> handlers; //函数指针数组

void fun_one()
{
    printf(;这是一个临时任务1
;);
}
void fun_two()
{
    printf(;这是一个临时任务2
;);
}



// 设置对应的方法回调
// 以后想让父进程闲了执行任何方法的时候;只要向Load里面注册;就可以让父进程执行对应的方法喽!
void Load()
{
    handlers.push_back(fun_one);
    handlers.push_back(fun_two);
}

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        // 子进程
        int cnt =  5;
        while(cnt)
        {
            printf(;我是子进程: %d
;, cnt--);
            sleep(1);
        }

        exit(11); // 11 仅仅用来测试
    }
    else
    {
        int quit = 0;
        while(!quit)
        {
            int status = 0;
            pid_t res = waitpid(-1, &status, WNOHANG); //以非阻塞方式等待
            if(res > 0)
            {
                //等待成功 && 子进程退出
                printf(;等待子进程退出成功, 退出码: %d
;, WEXITSTATUS(status));
                quit = 1;
            }
            else if( res == 0 )
            {
                //等待成功 && 但子进程并未退出
                printf(;子进程还在运行中;暂时还没有退出;父进程可以在等一等, 处理一下其他事情??
;);
                if(handlers.empty()) Load();
                for(auto iter : handlers)
                {
                    //执行处理其他任务
                    iter();
                }
            }
            else
            {
                //等待失败
                printf(;wait失败!
;);
                quit = 1;
            }
            sleep(1);
        }





         父进程
        //int status = 0;
         只有子进程退出的时候;父进程才会waitpid函数;进行返回;;[父进程依旧还活着呢;;]
         waitpid/wait 可以在目前的情况下;让进程退出具有一定的顺序性;
         将来可以让父进程进行更多的收尾工作.
         id > 0 : 等待指定进程
         id == -1: 等待任意一个子进程退出, 等价于wait();
         options: 默认为0;代表阻塞等待, WNOHANG: 叫做非阻塞等待
        //pid_t result = waitpid(id, &status, 0); // 默认是在阻塞状态去等待子进程状态变化(就是退出!)
        //if(result > 0)
        //{
        //    // 可以不这么检测
        //    //printf(;父进程等待成功, 退出码: %d, 退出信号; %d
;, (status>>8)&0xFF, status & 0x7F);
        //    if(WIFEXITED(status))
        //    {
        //        //子进程是正常退出的
        //        printf(;子进程执行完毕,子进程的退出码: %d
;, WEXITSTATUS(status));
        //    }
        //    else{
        //        printf(;子进程异常退出: %d
;, WIFEXITED(status));
        //    }
        //}
    }
}

int execl(const char*path, const char *arg,...);

#include <unistd.h>

int main()
{
    printf(;当前进程的开始代码!
;);

    //execl(;/usr/bin/ls;, ;ls;, NULL);
    execl(;/usr/bin/ls;, ;ls;, ;--color=auto;,;-l;, NULL);
    exit(1);
    //execl(;/usr/bin/ls;, ;ls;, ;-l;, ;-a;, ;-i;, NULL);
    //execl(;/usr/bin/ls;, ;ls;, ;-l;, ;-a;, ;-i;, NULL);
    //execl(;/usr/bin/top;, ;top;, NULL);

    printf(;当前进程的结束代码!
;);
    return 0;
}

  1#include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <sys/wait.h>
  5 
  6 int main()
  7 {
  8   pid_t id = fork();
  9   if(id == 0)
 10   {
 11     //子进程
 12     //ls -a -l
 13     printf(;子进程开始运行;pid%d
;,getpid());
 14     execl(;/usr/bin/ls;,;ls;,;-a;,;-l;,NULL);                                    
 15     exit(1);
 16   }
 17   else{
 18     //父进程
  printf(;父进程开始运行;pid%d
;,getpid());
 21     int status = 0;
 22     pid_t id = waitpid(-1,&status,0);//阻塞等待;一定是子进程先运行完毕然后父进程    获取之后才退出;
 23     if(id > 0)
 24     {
 25       printf(;wait success,exit code:%d
;,WEXITSTATUS(status));
 26     }
 27   }
 28 
 29   return 0;
 30 }

int execv (const char *path, char *const argv[]);

 12 if(id == 0)
 13   {
 14     //子进程
 15     //ls -a -l
 16     printf(;子进程开始运行;pid%d
;,getpid());
 17     //execl(;/usr/bin/ls;,;ls;,;-a;,;-l;,NULL);
 18     sleep(3);
 19     char *const _argv[NUM] = {
 20       (char*) ;ls;,
 21       (char*);-a;,
 22       (char*);-l;,
 23       NULL
 24     };
 25     execv(;/usr/bin/ls;,_argv);                                                  
 26     exit(1);
 27   }

int execlp(const char *file, const char *arg,...);

execlp(;ls;,;ls;,;-a;,;-l;,NULL);

int execlp(const char *file, char  *const argv[]);

char *const _argv[NUM] = {
       (char*) ;ls;,
        (char*);-a;,
        (char*);-l;,
        NULL
      };
  execvp(;ls;, _argv);

  1.PHONY:all
  2 all:exec mycmd
  3                                                                                  
  4 exec:exec.c   
  5   gcc -o $; $^
  6 mycmd:mycmd.c 
  7   gcc -o $; $^
  8 .PHONY:clean
  9 clean:            
 10   rm -f exec mycmd 

  1#include <stdio.h>
  2 #include <string.h>
  3 #include <stdlib.h>                                                              
  4 
  5 // ./mycmd -a/-b/-c...
  6 int main(int argc, char *argv[])
  7 {
  8     if(argc != 2)
  9     {
 10         printf(;can not execute;
;);
 11         exit(1);
 12     }
 13 
 14     //MY_105_VAL: 目前并不存在;
 15     printf(;获取环境变量: MY_105_VAL: %s
;, getenv(;MY_105_VAL;));
 16 
 17     if(strcmp(argv[1], ;-a;) == 0)
 18     {
 19         printf(;hello a!
;);
   }
 21     else if(strcmp(argv[1], ;-b;) == 0)
 22     {
 23         printf(;hello b!
;);
 24     }
 25     else{
 26         printf(;default!
;);
 27     }                                                                            
 28 
 29     return 0;
 30 }

int execle(const char *path, const char *arg, ..., char * const envp[]);
char *const _env[NUM] = {
    (char *) ;MY_105_VAL=55667788;,
       NULL 
      }; 

execle(myfile, ;mycmd;,;-a;,NULL,_env);

int main(int argc, char*argv[], char *env[])
   {
       .....
       //execle(myfile, ;mycmd;,;-a;,NULL,_env);
       execle(myfile, ;mycmd;,;-a;,NULL,env);
       .....
       }

#include <unistd.h>;
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

int execve(const char *path, char *const argv[], char *const envp[]);

myproc:myproc.cc
	gcc;; -o $; $^
.PHONY:clean
clean:
	rm -rf myproc

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

#define NUM 1024
#define SIZE 32
#define SEP ; ;

//保存完整的命令行字符串
char cmd_line[NUM];
//保存打散之后的命令行字符串
char *g_argv[SIZE];

// shell 运行原理 ; 通过让子进程执行命令;父进程等待&&解析命令
int main()
{
    //0. 命令行解释器;一定是一个常驻内存的进程;不退出
    while(1)
    {
        //1. 打印出提示信息 [whb;localhost myshell]# 
        printf(;[root;localhost myshell]# ;);
        fflush(stdout);
        memset(cmd_line, ;;, sizeof cmd_line);
        //2. 获取用户的键盘输入[输入的是各种指令和选项: ;ls -a -l -i;]
        if(fgets(cmd_line, sizeof cmd_line, stdin) == NULL)
        {
            continue;
        }
        cmd_line[strlen(cmd_line)-1] = ;;;
        //;ls -a -l -i
;
        //printf(;echo: %s
;, cmd_line);
        //3. 命令行字符串解析;;ls -a -l -i; -> ;ls; ;-a; ;-i;
      //把一个字符串打散成为多个子串
          g_argv[0] = strtok(cmd_line, SEP); //第一次调用;要传入原始字符串
        int index = 1;
        if(strcmp(g_argv[0], ;ls;) == 0)
        {
            g_argv[index;;] = ;--color=auto;;
        }
        if(strcmp(g_argv[0], ;ll;) == 0)
        {
            g_argv[0] = ;ls;;
            g_argv[index;;] = ;-l;;
            g_argv[index;;] = ;--color=auto;;
        }
        //?
        while(g_argv[index;;] = strtok(NULL, SEP)); //第二次;如果还要解析原始字符串,传入NULL

        //for debug
        //for(index = 0; g_argv[index]; index;;)
        //    printf(;g_argv[%d]: %s
;, index, g_argv[index]);
        //4. TODO,内置命令, 让父进程;shell;自己执行的命令;我们叫做内置命令;内建命令
        //内建命令本质其实就是shell中的一个函数调用
        if(strcmp(g_argv[0], ;cd;) == 0) //not child execute, father execute
        {
            if(g_argv[1] != NULL) chdir(g_argv[1]); //cd path, cd ..

            continue;
        }
        //5. fork()
        pid_t id = fork();
        if(id == 0) //child
        {
            printf(;下面功能让子进程进行的
;);
            //cd cmd , current child path
            execvp(g_argv[0], g_argv); // ls -a -l -i
            exit(1);
        }
        //father
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if(ret > 0) printf(;exit code: %d
;, WEXITSTATUS(status));
    }
}