进程笔记

学习笔记（二）之进程：

进程:本质是程序一次动态执行的过程 动态的 有生命周期 不能保存(临时存放于RAM上)

程序:本质是由源码编译生成的二进制可执行文件(指令和数据的集合) 静态的 无生命周期
可以报存(ROM)

注:即使是同一个程序多次执行产生进程也是不同的进程!!!

进程动态执行的一次过程:
1.创建 fork exec
2.调度
分时:将CPU的工作时间进行等均切割,进行合理分配,实现宏观上并行,微观上串行

进程基本三态: 就绪态 运行态 阻塞态

进程管理命令:
1.ps 进程信息截屏
ps -ef
ps aux

UID:用户编号
PID:进程编号 init 1 始祖进程
PPID:父进程编号
STAT:进程状态
R:运行态
T:暂停态
S:阻塞态
Z:僵尸态

<:进程优先级较高
N:进程优先级较低
s:进程的领导者
l:多线程
+:在前台运行
2.kill命令:给指定进程发送信号
kill -信号编号 PID
kill -l:列出信号 SIGINT 2 ctrl+c
SIGSTOP 19 ctrl+z
SIGKILL 9

　　top 类似windows 任务管理器 q退出界面
　　pstree 以树状图形式显示所有进程

3.执行 CPU执行
4.消亡 exit _exit

进程三要素:
1.程序 指令代码
2.内存分段
3.进程控制块 PCB task_struct 结构体 用于记录进程信息(PID,STAT,指向父进程的指针,记录所有子进程的列表)

getpid:获取调用进程的PID
pid_t getpid(void);

getppid:获取调用进程父进程的PID
pid_t getppid(void);

#include<stdio.h>
#include <sys/types.h>
#include <unistd.h>



int main(int argc, const char *argv[])
{
    pid_t pid,ppid;
    pid = getpid();
    ppid = getppid();

    printf("%d %d\n",pid,ppid);
    while(1)
    {
        ;
    }

    return 0;
}

进程创建:fork
pid_t fork(void);
功能:将当前调用进程进行精确的拷贝产生一个新的进程,新的进程称为子进程,调用进程称为父进程
返回值:失败在父进程中返回-1,并设置errno号,子进程不会被创建
成功时,在父进程中看到的返回值是子进程的pid,在子进程中看到的返回值是0

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



int main(int argc, const char *argv[])
{
    pid_t pid;
    pid_t pid_ret;


    pid = fork();  //该语句后子进程出现
    if(pid < 0)   //创建子进程失败
    {
        perror("fail to fork");
        exit(1);
    }
    else if(pid == 0) //子进程看到的代码块
    {
        printf("pid:%d child_pid:%d ppid:%d\n",pid,getpid(),getppid());
        sleep(5);
        exit(0);
    }
    else  // pid>0  父进程看到的代码块,得到的返回值是子进程的pid
    {
        printf("child_pid:%d pid:%d\n",pid,getpid());
    //    pid_ret = wait(NULL);//阻塞等待子进程退出
        
    //    pid_ret = waitpid(-1,NULL,0);waitpid阻塞

    //    pid_ret = waitpid(-1,NULL,WNOHANG);waitpid非阻塞
        printf("pid_ret:%d\n",pid_ret);
        exit(0);
    }

    return 0;
}

进程退出:exit man 3 _exit man 2
exit
void exit(int status);
功能:退出当前进程,刷新和关闭所有打开的文件流,并返回退出状态给当前进程的父进程 status & 0377
参数:退出状态可以自定义 官方提供的宏可以直接使用 EXIT_SUCCESS 0 EXIT_FAILURE 1

_exit
void _exit(int status);
功能:立刻退出当前进程,关闭所有属于该进程的文件描述符,将所有的子进程交给init关系,给当前进程的父进程发送SIGCHLD
的信号,并返回退出状态给父进程
参数:退出状态可以自定义 官方提供的宏可以直接使用 EXIT_SUCCESS 0 EXIT_FAILURE 1

wait
pid_t wait(int *status);
功能:1.用与父进程中阻塞等待任意子进程状态改变(1.子进程退出(使用exit) 2.被信号停止 3.被信号恢复)，2.当子进程退出时父进程会使用wait"收尸"(回收子进程相关资源),回收不及时会造成僵尸进程!
返回值:成功返回被回收的子进程的PID,失败返回-1
参数:如果不关子进程的状态改变,则直接填NULL
如果关心子进程状态改变,准备一个int型变量,取地址放入wait中,结合一下宏函数操作:
宏函数:
WIFEXITED(status) 判断子进程是否正常退出(使用exit _exit) 如果是返回true
WIFSIGNALED(status) 判断子进程是否被信号中断 如果是则返回true
WEXITSTATUS(status) 使用时必须保证该子进程退出时使用的时exit或者_exit退出
解析子进程使用exit函数返回status中的信息

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



int main(int argc, const char *argv[])
{
    pid_t pid;


    pid = fork();  //该语句后子进程出现
    if(pid < 0)   //创建子进程失败
    {
        perror("fail to fork");
        exit(1);
    }
    else if(pid == 0) //子进程看到的代码块
    {
        printf("pid:%d child_pid:%d ppid:%d\n",pid,getpid(),getppid());
        sleep(10);
        exit(2);
    }
    else  // pid>0  父进程看到的代码块,得到的返回值是子进程的pid
    {
        printf("child_pid:%d pid:%d\n",pid,getpid());
        int s;
        wait(&s);//阻塞等待子进程退出
        if(WIFEXITED(s))
        {
            printf("child is exit!\n");
            printf("exit_status:%d\n",WEXITSTATUS(s));
        }
        else if(WIFSIGNALED(s))
        {
            printf("child is killed by signal!\n");
        }

        exit(0);
    }

    return 0;
}

waitpid:
pid_t waitpid(pid_t pid, int *status, int options);
参数:
1.pid:
-1:代表等待任意子进程状态发生改变
>0:(子进程pid编号)等待指定的子进程状态发生改变
0:代表等待与当前进程同一组内的所有子进程的状态发生改变
2.同wait一致
3.选项 0 默认阻塞(与wait一致) WNOHANG 默认非阻塞
返回值:成功返回回收子进程的pid号,失败返回-1,如果选项使用的是WNOHANG,则没有子进程退出时返回0
waitpid(-1,&status,0) == wait(&status)

僵尸进程:僵尸进程是问题,要解决 详见:man 2 wait NOTES
孤儿进程:不是问题,当父进程退出,子进程还没有结束,所有的子进程就变成孤儿进程,交给init管理
init能一瞬间回收所有退出的子进程
1.wait waitpid 无法同时回收多个退出的子进程,有效率问题

2.信号注册 SIGCHLD
signal
sighandler_t signal(int signum, sighandler_t handler);
功能:向内核注册指定信号,当当前进程收到该对应信号时,执行指定操作
参数:1.需要被注册的信号 2.指定操作
signal(SIGCHLD,SIG_IGN); 信号忽略操作

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



int main(int argc, const char *argv[])
{
    signal(SIGCHLD,SIG_IGN); 
    //向内核注册SIGCHLD,当该进程收到这个信号时,选择忽略 

    pid_t pid;
    pid_t pid_ret;


    pid = fork();  //该语句后子进程出现
    if(pid < 0)   //创建子进程失败
    {
        perror("fail to fork");
        exit(1);
    }
    else if(pid == 0) //子进程看到的代码块
    {
        printf("pid:%d child_pid:%d ppid:%d\n",pid,getpid(),getppid());
        exit(0);
    }
    else  // pid>0  父进程看到的代码块,得到的返回值是子进程的pid
    {
        sleep(3);
        pid_ret = waitpid(-1,NULL,WNOHANG);//waitpid非阻塞
        printf("pid_ret:%d\n",pid_ret);
        exit(0);
    }

    return 0;
}

3.父子孙
父创建子 子立马创建孙 子自杀 父进程回收子,父做自己的事 孙交给init,孙进程做自己的事

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


int main(int argc, const char *argv[])
{
    pid_t pid1,pid2;


    pid1 = fork();  //父创建子进程
    if(pid1 < 0)
    {
        perror("fail to fork1");
        exit(1);
    }
    else if(pid1 == 0) //子进程
    {
        pid2 = fork(); //子创建孙
        if(pid2 < 0)
        {
            perror("fail to fork2");
            exit(1);
        }
        else if(pid2 == 0)//孙进程
        {
            sleep(5);
            printf("父亲被残忍杀害,爷爷不管,交给孤儿院!\n");
            printf("getppid:%d\n",getppid());
            exit(0);
        }
        else  //子进程
        {
            printf("惨无人道被杀害的子进程,心态爆炸!\n");
            exit(0);
        }
    }
    else  //父进程
    {
        wait(NULL); 
        //回收自杀的子进程,由于子进程创建孙进程很快,不做任何事就退出,父进程等待回收时基本不会受到影响
        printf("嘿嘿嘿!\n");
        exit(0);
    }

    return 0;
}

exec函数族: 将指定的新的可执行文件替换当前进程的0~3G空间
l:list(以列表形式排布) p:path(通过shell查找) e:env 环境 v: vector
execl:
int execl(const char *path, const char *arg, ...);
参数:1.新的可执行文件的路径 2.命令行传参,以列表形式排布,以NULL结尾 3. ...代表可变长度传参

#include <stdio.h>
#include <unistd.h>



int main(int argc, const char *argv[])
{
    printf("before execl!\n");

    execl("/home/xyx/teach/18072/Pro_2/hello","./hello",NULL);

    printf("after execl!\n");

    return 0;
}

execlp:
int execlp(const char *file, const char *arg, ...);
参数:1.新的可执行文件名(自动查找路径) 2.命令行传参,以列表形式排布,以NULL结尾 3. ...代表可变长度传参

#include <stdio.h>
#include <unistd.h>



int main(int argc, const char *argv[])
{
    printf("before execlp!\n");
    
    execlp("ls","ls","-l",NULL);

    printf("after execlp!\n");
    
    return 0;
}

execv:
int execv(const char *path, char *const argv[]);
参数:1.新的可执行文件路径 2.命令行传承,以数组方式填写(自己准备数组,最后一个元素依旧是NULL)

#include <stdio.h>
#include <unistd.h>



int main(int argc, const char *argv[])
{
    printf("before execv!\n");
    char * a[] = {"./hello",NULL};
    execv("/home/xyx/teach/18072/Pro_2/hello",a);
    printf("after execv!\n");
    return 0;
}

execle:
int execle(const char *path, const char *arg, ..., char * const envp[]);
参数:1.新的可执行文件的路径 2.命令行传参,以列表形式排布,以NULL结尾 3. ...代表可变长度传参 4.自己提供的环境变量

#include <stdio.h>
#include <unistd.h>



int main(int argc, const char *argv[])
{
    printf("before execle!\n");
    char * env[] = {"PATH=hehe","LOGANNAME=heihei",NULL};
    execle("/usr/bin/env","env",NULL,env);
    printf("after execle!\n");
    return 0;
}

终端上执行a.out:
bash --> fork --> exec(a.out)

system:跳出进程执行shell命令,执行完成后返回当前调用进程
int system(const char *command);
参数:shell命令

#include <stdio.h>
#include <stdlib.h>



int main(int argc, const char *argv[])
{
    printf("before system!\n");
    system("ls -l");
    printf("after system!\n");
    return 0;
}

交互进程:与终端产生交互
前台进程(输入输出都存在): 后台运行过程中输入fg切换为前台运行
后台进程(只有输出): 后台运行a.out: (1) ./a.out & (2)ctrl+z暂停进程 用bg回复进程到后台运行

守护进程:与终端无关 ,从开始运行,一直到主动杀死或者操作系统结束才会终止
1.创建子进程,父进程退出,子进程交给init接管
2.设置当前进程为会话组组长
setsid:
pid_t setsid(void);
3.改变了工作路径
chdir
int chdir(const char *path);
4.更改文件权限掩码
umask(0)
mode_t umask(mode_t mask);
5.关闭文件描述符
getdtablesize: 返回当前进程能打开的最大的文件个数 1024
int getdtablesize(void);
利用for结合close循环关闭文件描述符

注：有输出时需要依靠fflush函数实现

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


int main(int argc, const char *argv[])
{
    pid_t  pid;


    pid = fork();
    if(pid < 0)
    {

    }
    else if(pid == 0)
    {
        //设置会话组组长
        setsid();

        //更改工作路径
        chdir("/home/xyx");

        //更改文件权限掩码
        umask(0);


        //关闭所有打开的文件描述符
        int size_fd;
        size_fd = getdtablesize();
        int i;
        for(i = 0;i < size_fd;i++)
        {
            close(i);
        }
        printf("11111\n");        
        sleep(50);
    }
    else
    {
        exit(0);
    }



    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>


int main(int argc, const char *argv[])
{
    pid_t  pid;


    pid = fork();
    if(pid < 0)
    {

    }
    else if(pid == 0)
    {
        //设置会话组组长
        setsid();

        //更改工作路径
        chdir("/home/xyx");

        //更改文件权限掩码
        umask(0);


        //关闭所有打开的文件描述符
        int size_fd;
        size_fd = getdtablesize();
        int i;
        for(i = 0;i < size_fd;i++)
        {
            close(i);
        }

        FILE *fp;
        fp = fopen("/home/xyx/log.txt","a");
        if(fp == NULL)
        {
            perror("fail to fopen");
            exit(1);
        }
    
        time_t t;

        while(1)
        {
            t = time(NULL);
            fprintf(fp,"%s\n",ctime(&t));
            fflush(fp);
            sleep(1);
        }
    }
    else
    {
        exit(0);
    }



    return 0;
}