linux进程

1.什么是程序，什么是进程，有什么区别
2.如何查看系统中有那些进程
3.什么是进程标识符
4.什么叫父进程，什么叫子进程
5.c程序的存储空间是如何分配

---

程序是静态的概念， gcc xxx.c -o pro
磁盘中生成pro文件，叫做程序
进程是程序的一次运动活动
通俗点意思是程序跑起来了，系统中就多了一个进程

如何查看系统中有哪些进程

a.使用ps指令查看
实际工作中，配合grep来查找程序中是否存在某一进程
ps -aux 显示所有进程
ps -aux|grep init
查找进程中是否有init
b 使用top指令查看，类似windows任务管理器一样

什么是进程描述符

每个进程都有一个非负整数表示的唯一ID，叫做pid，类似身份证
Pid=0：称为交换进程(swapper)
作用-进程调度
Pid=1: init进程
作用 --系统初始化

编程调用getpid函数获取自身的进程标识符getppid获取父进程的进程标识符

如何查看自己的pid

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

int main()
{
   
        pid_t pid;
        pid = getpid();
        printf("my pid is %d\n", pid);

        return 0;
}

运行的结果如下所示

什么叫父进程， 什么叫子进程
进程A叫做父进程，B叫做子进程，父子进程是相对的概念，理解为人类中的父子关系

c程序的存储空间如何分配

1.栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些
存储单元自动被释放，栈内存分配运算内置于处理器的指令集中，效率很高但是分配的内存容量有
限，栈区主要存放运行函数而分配的局部变量函数参数，返回数据，返回地址等
2.堆区：一般由程序员分配释放，若程序员不释放，程序结束时可能有OS回收，分配方式类似于链表
3.数据段（静态区）（static）存放全局变量，静态数据，程序结束后由系统释放
4.代码段：存放函数体（类成员函数和全局函数）的二进制d代码

实际上普通的局部变量是在栈区分配k空间的，栈区的特点是在上面创建的变量出了作用域就销毁
但是被static修饰的变量存放在数据段(静态区)，数据段的特点是在上面创建的变量，直到程序结束才销毁
所以生命周期变长

fork函数创建进程

创建一个子进程

pid_t fork(void);

失败返回-1；
成功返回(1)父进程返回子进程的ID(非负)(2)子进程返回0
pid_t类型表示进程ID，但为了表示-1，它是有符号的整型，(0不是有效进程ID, init最小，为1)
注意返回值，不是fork函数能返回两个值，而是fork后，父子各自返回一个

getpid()返回当前进程的进程号

getppid()返回当前进程父进程的进程号

getpid() getppid()就这样用

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
   

        printf("before fork -- 1 -- \n");
        printf("before fork -- 2 -- \n");
        printf("before fork -- 3 -- \n");
        printf("before fork -- 4 -- \n");
        printf("before fork -- 5 -- \n");

        pid_t pid = fork();
        if(pid == -1)
        {
   
                printf( "create failed \n");
                exit(-1);
        }
        else if(pid == 0)
        {
   
                printf("child is created  is %d, parent pid is %d\n", getpid(), getppid() );
        }
        else if(pid > 0)
        {
   
                printf("parent process  my child pid is %d, my pid is %d, parend de parend is %d\n", pid, getpid(), getppid());
                sleep(1);
        }

        printf(" end of file\n");
        return 0;
}

上面可以看到父进程返回子进程的ID号 子进程返回0

下面是老陈的过程

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


int main()
{
   
        pid_t pid;
        pid = getpid();

        fork();
        printf("my pid is %d, dangqian pid is %d\n", pid, getpid());
        return 0;
}

由结果可以看出子进程和父进程各执行了一遍

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


int main()
{
   
        pid_t pid;
        pid_t pid2;
        pid = getpid();
        printf("before fork : pid = %d\n", pid);
        fork();
        pid2 = getpid();

        printf("atfer fork is %d\n", pid2);
        if(pid == pid2)
        {
   
                printf("this is father child pid is\n");
        }
        else
        {
   
                printf("this is child pid is %d\n", getpid());
        }

        return 0;
}

由下面结果可知父进程和子进程各自进行执行

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


int main()
{
   
        pid_t pid;
        pid = fork();

        if(pid > 0)
        {
   
                printf("this is father  pid is %d child pid is %d\n", getpid(),pid);
                sleep(1);
        }
        else if(pid == 0)
        {
   
                printf("this is child pid is %d,  parent pid is %d\n", getpid(), getppid());
        }

        return 0;
}
~          

由下图可知 父进程返回的是子进程的id子进程返回的是0

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


int main()
{
   
        pid_t pid;
        pid_t pid2;
        pid_t retpid;

        pid = getpid();
        printf("before frok pid =%d\n", pid);

        retpid = fork();
        pid2 = getpid();
        printf("after fork is %d\n", pid2);

        if(pid == pid2)
        {
   
                printf("this is father child pid is%d\n", retpid);
        }
        else
        {
   
                printf("this is child retpid is %d pid is %d\n",retpid, getpid());
        }

        return 0;
}

这是由返回值来判断父进程和子进程的

#include <stdio.h>