进程描述符：task_struct包含了描述一个进程所需的所有信息。
进程状态：包括运行、就绪、阻塞等状态。
进程标识符：如进程ID（PID）。
进程调度信息：如优先级、调度策略等。
内存管理信息：如虚拟地址空间、页表等。
文件系统信息：如打开的文件、文件系统根目录等。
信号处理：包括待处理信号和信号处理函数。
进程间通信：如消息队列、共享内存等IPC机制相关信息。
时间和定时器：如进程创建时间、CPU使用时间等。
线程信息：在Linux中，线程被视为轻量级进程，也用task_struct表示。

5）单核cpu处理多任务是，一般使用的是时间片轮询机制

6）进程宇程序的区别：

程序时静态的，是存储在磁盘上的二进制代码

进程是动态的，有生命周期的

7）进程的组成:进程控制块(PCB)、数据段、程序段

1.3、进程的种类

进程分为三大类：交互进程、批处理进程、守护进程

1）交互进程：他是由shell控制，用于直接跟用户进行交互的进程。例如:vim编辑器、文本编辑器

2）批处理进程：本质上维护了一个队列，被放入队列中的进程会统一被调度。例如gcc编译器的一步到位的编译

3）守护进程：脱了了终端而存在的进程，随着系统的启动而开始，随着系统的结束而终止。例如:服务进程

1.4、进程号的概念

每个进程在系统中都有一个唯一的标识位，用一个整数表示这就是该进程的进程号(PID)

1、PID(processID):当前进程的进程号

2、PPID(parent processID):当前进程的父进程的进程号

3、每个进程都是由其父进程进行拷贝赋值出来的

4、/proc目录中的每个数字都是现在正在执行的一个进程

1.5、特殊进程 0号 1号 2号孤儿僵尸

1、0号进程：也称其为 idel进程，他是操作系统启动后执行的第一个进程，这个进程也叫空闲进程，当没有其他进程执行时会默认执行该进程。1号进程和2号进程都是由0号进程创建出来的

2、1号进程：也称init进程，该进程由0号进程产生，主要完成系统创建时一些软件硬件的初始化工作。当其他进程的父进程死亡后，会托管其子进程

3、2号进程：也称kthreadd，该进程由0号进程产生，也称为调度进程，当某个就绪进程时间片轮到时，该进程负责进程的调度工

4、孤儿进程：当前进程的父进程死亡后，但是当前进程还没有结束，那么当前进程称为孤儿进程，孤儿进程会由1号进程收养

5、僵尸进程:当前进程已经死亡，但是其父进程没有为其收尸（回收其进程的资源），那么该进程为僵尸进程

1.6、进程的相关命令

1）查看进程信息的命令：ps 跟不同的选项，执行不同的状态

ps -ef ：显示进程之间的关系

UID PID PPID C STIME TTY TIME CMD
root 1 0 0 七月25 ? 00:00:20 /sbin/init splash
root 2 0 0 七月25 ? 00:00:00 [kthreadd]
root 3 2 0 七月25 ? 00:00:00 [rcu_gp]
root 4 2 0 七月25 ? 00:00:00 [rcu_par_gp]
root 6 2 0 七月25 ? 00:00:00 [kworker/0:0H-kb]
root 9 2 0 七月25 ? 00:00:00 [mm_percpu_wq]
root 10 2 0 七月25 ? 00:00:06 [ksoftirqd/0]
root 11 2 0 七月25 ? 00:01:11 [rcu_sched]
UID：用户ID
PID：当前进程的id号
PPID:当前进程的父进程PID号
C：不用管
STIME、TIME：创建时间
TTY：如果该值为问号，说明不依赖于终端而存在的进程
CMD：进程名称

ps -ajx：可显示进程的状态

PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND
0 1 1 1 ? -1 Ss 0 0:20 /sbin/init splash
0 2 0 0 ? -1 S 0 0:00 [kthreadd]
2 3 0 0 ? -1 I< 0 0:00 [rcu_gp]
2 4 0 0 ? -1 I< 0 0:00 [rcu_par_gp]
2 6 0 0 ? -1 I< 0 0:00 [kworker/0:0H-kb]

PPID:当前进程的父进程PID号

PID：当前进程的id号

PGID：组id号
SID：会话组id
STAT：当前进程的状态

ps -aux：可以查看资源使用情况

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.2 160076 4676 ? Ss 七月25 0:20 /sbin/init splash
root 2 0.0 0.0 0 0 ? S 七月25 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I< 七月25 0:00 [rcu_gp]
root 4 0.0 0.0 0 0 ? I< 七月25 0:00 [rcu_par_gp]
root 6 0.0 0.0 0 0 ? I< 七月25 0:00 [kworker/0:0H-kb]
%CPU：cpu的占用率
%MEM ：内存的占用率

2）top/htop

top：动态显示资源使用情况

top - 11:51:17 up 5 days, 13:55, 1 user, load average: 0.01, 0.02, 0.00
任务: 327 total, 3 running, 260 sleeping, 0 stopped, 0 zombie
%Cpu(s): 3.5 us, 1.8 sy, 0.0 ni, 94.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 2005964 total, 67820 free, 1168168 used, 769976 buff/cache
KiB Swap: 969960 total, 88160 free, 881800 used. 654624 avail Mem

进程 USER PR NI VIRT RES SHR � %CPU %MEM TIME+ COMMAND
1872 ubuntu 20 0 640144 59872 5056 S 4.0 3.0 12:54.43 Xorg
2057 ubuntu 20 0 3057424 149072 31884 S 3.0 7.4 27:58.69 gnome-shell
89961 ubuntu 20 0 949248 69268 23020 S 2.7 3.5 3:17.13 terminator
2193 ubuntu 20 0 809364 5568 2120 S 0.3 0.3 2:22.89 gsd-color
111256 ubuntu 20 0 51380 4456 3616 R 0.3 0.2 0:00.21 top
1 root 20 0 160076 4676 2652 S 0.0 0.2 0:20.90 systemd
2 root 20 0 0 0 0 S 0.0 0.0 0:00.02 kthreadd

htop：动态显示资源使用情况（彩色）

3）ptree：展示进程树，可以显示进程的父子关系

4）查看给定进程的进程号：pidof 进程名

5）kill：向进程发送信号

格式： kill -信号名（号）进程号

能够发送的信号号有：可以通过指令 kil -查看

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX

共计62个

前32个属于稳定信号

SIGHUP：
        当进程所在的终端关闭时，该终端会向运行在该终端上的所有进程发送该信号，让其结束进程

SIGINT：

        当终端键入 ctrl+c时，终端向指定进程发送的就是该信号，表示中断进程

SIGOUIT：

        当终端键入 ctrl + \时，表示终端要终止进程的结束

SIGILL：

        当进程自己发生非法操作时，内核空间会发送该信号

SIGKILL：

杀死进程

SIGUSR1、SIGUSR2：

        没有特殊的含义，留给程序员使用

SIGSEGV：

        表示指针访问越界时的段错误

SIGPIPE：

        当操作管道文件时，如果管道的读端被关闭，写端继续写的话，就会出现管道破裂

SIGALRM：

        当启动一个定时器，并且定时器超时时，会发送该信号

SIGHCHLD：

        当一个进程的子进程退出时，会向该进程的父进程发送该信号，表示让其为子进程收尸

SIGCONT：

该信号表示让暂停的进程继续执行

SIGSTOP、SIGSTP：

        表示让一个进程暂停，当用户从键盘上键入 ctrl +z时，就会发送该信号

1.7、进程的状态

1）主要状态有五个：创建态、就绪态、运行态、阻塞态、死亡态

2）程序中的进程状态显示：可以通过man ps查看

主状态：
D 不可中断的休眠态 (usually IO)
R 运行态 (on run queue)
S 可中断的休眠态 (waiting for an event to complete)
T 暂停态，会给出作业号进行控制
t 程序调试时的暂停态
W 已经弃用
X 死亡态 (should never be seen)
Z 僵尸态
附加态：
< 高优先级的进程 (not nice to other users)
N 低优先级的进程 (nice to other users)
L 锁到内存中的进程 (for real-time and custom IO)
s 会话组组长，默认为当前终端
l 包含多线程的进程 (using CLONE_THREAD, like NPTL pthreads do)
+ 表示是前台运行的进程

二、多进程编程

2.1fork进程的创建函数

1）在进程的创建过程，其实就是通过拷贝父进程的lask stucl结构体而来的，子进程中保存了大部分的父进程的遗传基因（内容一致），只需要修改少部分的内容，如子进程的进程号，子进程的父进程号

2）子进程和父进程的资源用户空间是完全独立的，创建出子进程后，父子进程的资源相互独立，互不影响

3）进程的创建，通过fork函数完成

4）当子进程创建后，会跟父进程一起执行fork后面的语句

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

pid_t fork(void);
功能：拷贝父进程得到子进程
参数：无
返回值：成功时，父进程中返回子进程的pid号，子进程中返回0，失败返回-1并置位错误码

例1 不使用返回值

创建出的子进程跟父进程没有先后执行的顺序，遵循时间片轮询机制

例2 使用返回值


#include <myhead.h>
int main(int argc, char const *argv[])
{
    pid_t pid = -1;  //定义变量存储 pid 号
 
    pid = fork();   //获取pid
 
    if (pid > 0)
    {
        while (1)
        {
            printf("父进程\n");
            sleep(1);
        }
    }
    else if (pid == 0)
    {
        while (1)
        {
            printf("子进程\n");
            sleep(1);
        }
    }
 
    sleep(1);
 
    return 0;
}

2.2 进程号的获取 getpid getppid

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

pid_t getpid(void);
功能：获取当前进程的进程号
参数：无
返回值：当前进程的pid
pid_t getppid(void);
功能：获取当前进程的父进程的pid号
参数：无
返回值：当前进程父进程的pid

2.3进程的退出 exit _exit

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

pid_t getpid(void);
功能：获取当前进程的进程号
参数：无
返回值：当前进程的pid
pid_t getppid(void);
功能：获取当前进程的父进程的pid号
参数：无
返回值：当前进程父进程的pid

2.4 进程资源的回收 wait waitpid

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *wstatus);
功能：阻塞回收子进程的资源，如果没有进程退出，那么就阻塞等待
参数：子进程退出时的状态，一般不接收，直接填NULL即可
返回值：成功返回回收的子进程的pid，失败返回-1并置位错误码

pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：既可以阻塞也可以非阻塞形式回收僵尸进程
参数1：要回收的进程号
>0:表示回收具体的某个进程
=0：能够回收当前进程所在的进程组中的任意一个子进程
=-1：回收任意一个子进程
<-1: 回收别的进程组（进程组id为给定的pid的绝对值）中的任意一个子进程
参数2：子进程退出时的状态，一般不接收，直接填NULL即可
参数3：表示是否阻塞回收僵尸进程
0：表示阻塞
WNOHANG：表示非阻塞
返回值：

                >0:如果成功回收了子进程资源，那么会返回该子进程的pid

                =0:表示以非阻塞的形式回收资源，但是没有回收到子进程

                =-1:失败返回-1并置位错误码


#include<myhead.h>
 
int main(int argc, const char *argv[])
{
    //定义进程号
    pid_t pid = fork();     //创建一个子进程
 
    //判断父子进程
    if(pid > 0)
    {
        printf("我是父进程：pid = %d, 当前进程的id为：%d,当前进程的父进程的id为：%d\n",\
                pid, getpid(), getppid());
 
 
    }else if(pid == 0)
    {
        printf("我是子进程：pid = %d,当前进程的pid为：%d, 当前进程的父进程pid为：%d\n",\
                pid, getpid(), getppid());
 
        sleep(3);          //休眠3秒
 
        //退出子进程
        //exit(EXIT_SUCCESS);         //exit(0);
        _exit(EXIT_SUCCESS);         //exit(0);
    }else
    {
        perror("fork error");
        return -1;
    }
 
 
    //回收子进程资源
    //wait(NULL);
    //waitpid(-1, NULL, 0);       //阻塞回收
    sleep(5);
    waitpid(-1, NULL, WNOHANG);       //非阻塞回收
    
    printf("回收子进程资源结束\n");
    while(1);
 
    return 0;
}

作业


#include <myhead.h>
 
#define N 128
char buf[N] = {0};
 
int main(int argc, char const *argv[])
{
    pid_t pid;
    int len,size, o_file, n_file;
    if (argc != 3)
    {
        printf("终端输入数不正确\n");
        return -1;
    }
 
    umask(0000);  //置位掩码
 
    if ((o_file = open(argv[1], O_RDONLY)) == -1)
    {
        perror("open");
        exit(-1);
    }
 
    n_file = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0664);
    if (n_file == -1)
    {
        perror("open");
        exit(-1);
    }
 
    size = lseek(o_file, 0, SEEK_END);  //得到源文件大小
    if (size < 0)
    {
        perror("lseek");
        exit(-1);
    }
 
    size /= 2;   //取一半的大小
 
    close(o_file);
    close(n_file);
 
    pid = fork();  //子程序创建
    if (pid < 0)
    {
        perror("fork");
        exit(-1);
    }
    else if (0 == pid)  //子程序执行
    {
        o_file = open(argv[1], O_RDONLY);
        if (o_file < 0)
        {
            perror("c open1");
            exit(-1);
        }
 
        n_file = open(argv[2], O_WRONLY);
        if (n_file < 0)
        {
            perror("c open2");
            exit(-1);
        }
 
        lseek(o_file, size, SEEK_SET);  //光标定位到一半的位置
        lseek(n_file, size, SEEK_SET);
 
        //拷贝后一半
        while ((len = read(o_file, buf, N)) > 0)
        {
            write(n_file, buf, len);
        }
 
        close(o_file);
        close(n_file);
    }
    else  //父程序执行
    {
        o_file = open(argv[1], O_RDONLY);
        if (o_file < 0)
        {
            perror("f open1");
            exit(-1);
        }
 
        n_file = open(argv[2], O_WRONLY);
        if (n_file < 0)
        {
            perror("f open2");
            exit(-1);
        }
 
        //拷贝前一半
        while (size > 0)
        {
            if (size > N)
            {
                write(n_file, buf, read(o_file, buf, N));
                size -= N;
            }
            else
            {
                write(n_file, buf, read(o_file, buf, size));
                break;
            }
        }
 
        close(o_file);
        close(n_file);
    }
 
    return 0;
}

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】

学习记录——day23 多进程编程

一、多进程引入

1.1、引入目的

1.2、进程的概念