LINUX进程

最新推荐文章于 2024-07-24 09:58:58 发布

Daryl Dixon

最新推荐文章于 2024-07-24 09:58:58 发布

阅读量1.9k

点赞数 57

文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/m0_74027838/article/details/137766425

版权

1 什么是进程

进程是程序的一次执行过程

进程和程序的区别

1.1 概念

程序：编译好的可执行文件

存放在磁盘上的指令和数据的有序集合（文件）

程序是静态

程序	进程
编译好的可执行文件	执行一个程序所分配的资源的总称
存放在磁盘上的指令和数据的有序集合	程序的一次执行过程
静态	动态的包括创建调度执行消亡

1.2 特点

（1）系统会为每个进程分配0-4g的虚

进程的内容

数据段：存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。

正文段：存放的是程序中的代码

堆栈段：存放的是函数的返回地址、函数的参数以及程序中的局部变量（类比内存的栈区）

进程的类型

交互进程：该类进程是由shell控制和运行的。交互进程既可以在前台运行，也可以在后台运行。该类进程经常与用户进行交互，需要等待用户的输入，当接收到用户的输入后，该类进程会立刻响应，典型的交互式进程有：shell命令进程、文本编辑器等

批处理进程：该类进程不属于某个终端，它被提交到一个队列中以便顺序执行。(目前接触不到)

守护进程： 和终端无关，该类进程在后台运行。它一般在Linux启动时开始执行，系统关闭时才结束。

1.5 进程状态

D uninterruptible sleep (usually IO) 不可中断的睡眠态

R running or runnable (on run queue) 运行态

S interruptible sleep (waiting for an event to complete) 可中断的睡眠态

T stopped by job control signal 暂停态

t stopped by debugger during the tracing 因为调试而暂停

X dead (should never be seen) 死亡态

Z defunct ("zombie") process, terminated but not reaped by its parent 僵尸态

< high-priority (not nice to other users) 高优先级

N low-priority (nice to other users) 低优先级

L has pages locked into memory (for real-time and custom IO) 锁在内存中

s is a session leader 会话组组长

l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)多线程

+ is in the foreground process group 前台进程

没有+时，默认是后台进程

I (大写i)空闲状态进程

进程状态切换图

进程创建后，进程进入就绪态，当CPU调度到此进程时进入运行态，当时间片用完时，此进程会进入就绪态，如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态，完成IO操作（阻塞结束）后又可进入就绪态，等待CPU的调度，当进程运行结束即进入结束态。

1.7 进程相关命令

ps 查看系统中运行的进程-aux -ef

top 动态显示系统中运行的进程

renice 改变正在运行的进程的优先级

nice 按用户指定的优先级运行进程

kill 给进程发信号

bg 将进程切换到后台

fg 将进程切换到前台

jobs 查看当前终端的进程

补充：优先级调度（面试可能遇见）

根据进程的优先级进行调度，优先级高的进程先执行。

两种类型：

非剥夺式（非抢占式）优先级调度算法。当一个进程正在处理上运行时，即使有某个更为重要或紧迫的进程进入就绪队列，仍然让正在进行的进程继续运行，直到由于其自身原因而主动让出处理机（任务完成或等待事件），才把处理机分配给更为重要或紧迫的进程。
剥夺式（抢占式）优先级调度算法。当一个进程正在处理机上运行时，若有某个更为重要或紧迫的进程进入就绪队列，则立即暂停正在运行的进程，将处理机分配给更重要或紧迫的进程。

面试题：

下列关于轮询任务调度和可抢占式调度区别描述错误的是?

A. 抢占式调度实现相对较复杂且可能出现低优先级的任务长期得不到调度

B. 轮询调度不利于后面的请求及时得到响应

C. 抢占式调度有利于后面的高优先级的任务也能及时得到响应

D. 抢占式调度优点是其简洁性，它无需记录当前所有连接的状态

解析：抢占式调度相对于轮询调度来说实现相对复杂，需要记录和管理任务的优先级、状态等信息。

会导致进程从执行态变为就绪态的事件是（）。(大明科技)

A. 执行P（wait）操作

B. 申请内存失败

C. 启动I/O设备

D. 被高优先级进程抢占

分配到必要的资源并获得处理机时的进程状态是（）。(大明科技)

A. 就绪状态

B. 执行状态

阻塞状态

进程函数接口

2.1 创建进程fork()

pid_t fork(void);
功能：创建子进程
返回值：
    成功：在父进程中：返回子进程的进程号 >0
         在子进程中：返回值为0
    失败：-1并设置errno

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork(); //创建一个子进程

    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid==0)  //子进程
    {
        printf("i am child\n");
        while(1);  //让子进程不要结束
    }
    else    //父进程
    {
        printf("i am parent\n");
        while(1);  //让父进程不要结束
    }

    return 0;
}

执行： ./a.out

特点：

1）子进程几乎拷贝了父进程的全部内容。包括代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等；但它们的PID、PPID是不同的。

2）父子进程有独立的地址空间，互不影响；当在相应的进程中改变全局变量、静态变量，都互不影响。

3）若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程。

4）若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程（要避免僵尸进程产生）

2.2 回收资源

pid_t wait(int *status);
功能：回收子进程资源(阻塞)
参数：status：子进程退出状态，不接受子进程状态设为NULL
返回值：成功：回收的子进程的进程号
              失败：-1

pid_t waitpid(pid_t pid, int *status, int options);
功能：回收子进程资源
参数：
    pid：>0     指定子进程进程号
         =-1   任意子进程
         =0    等待其组ID等于调用进程的组ID的任一子进程
         <-1   等待其组ID等于pid的绝对值的任一子进程
    status：子进程退出状态，不接受子进程状态设为NULL
    options：0：阻塞 WNOHANG：非阻塞
返回值：正常：结束的子进程的进程号
      当使用选项WNOHANG且没有子进程结束时：0
      出错：-1

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork(); //创建一个子进程

    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) //子进程
    {
        printf("i am child\n");
        sleep(3);
    }
    else //父进程
    {
        printf("i am parent\n");
        //wait(NULL);
        //waitpid(-1,NULL,0); //此时和wait(NULL)一样，0代表阻塞。
        //waitpid(-1,NULL,WNOHANG);  //WNOHANG代表非阻塞，此时有可能接收不到子进程资源从而产生僵尸

        while (1) //所以用WNOHANG的时候需要通过循环调用
        {
            if (waitpid(-1, NULL, WNOHANG) > 0) //直到接收到了子进程资源就结束
                break;
        }
    }
    return 0;
}

2.3 结束进程

void exit(int status);
功能：结束进程，刷新缓存

void _exit(int status);
功能：结束进程，不刷新缓存

参数数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。
通常0表示正常结束；
其他的数值表示出现了错误，进程非正常结束

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

int main(int argc, char const *argv[])
{
    printf("hello");
    //exit(0);   //结束进程，刷新缓存
    _exit(0);    //结束进程，不刷新缓存
    while (1);

    //思考：exit和return的区别？
    
    return 0;
}

eixt结束的是当前整个进程，return结束的是当前函数：

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

int fun()
{
    printf("in fun\n");
    exit(0);        //结束当前进程，所以后面in main不打印了 
    //return 0;     //结束当前函数，后面in main还会打印
}

int main(int argc, char const *argv[])
{
    fun();
    printf("in main\n");
    return 0;
}

2.4 获取进程号

pid_t getpid(void);
功能：获取当前进程的进程号
pid_t getppid(void);
功能：获取当前进程的父进程号

例如：父子进程中分别打印这两个进程的进程号

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        printf("child: %d %d\n", getpid(), getppid());
        while (1);
    }
    else
    {
        printf("parent: %d %d\n", pid, getpid());
        while (1);
    }
    return 0;
}

exec函数族(了解)

在一个进程中执行另一个进程：

system("clear");

system("ls -l");

system函数所启动进程不会替换原本进程，但是exec函数族所启动进程会替换原本进程

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

int main(int argc, char const *argv[])
{
    printf("hello\n");
    //system("ls -a");   //原进程不会被替换，执行完召唤进程后原进程还会继续执行，所以world会打印
    execl("/bin/ls","ls","-a",NULL); //原进程被完全替换，所以后面world不打印
    printf("world\n");
    return 0;
}

原型：

#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 execvpe(const char *file, char *const argv[],char *const envp[]);

守护进程 Daemon

Linux以会话(session)、进程组的方式管理进程，每个进程属于一个进程组，也就是多个进程组成一个进程组。会话是一个或多个进程组的集合，通常用户打开一个终端时，系统会创建一个会话。所有通过该终端运行的进程都属于这个会话。终端关闭时，所有相关进程会被结束。但是守护进程却能突破这种限制，不受终端关闭的影响。

4.1 守护进程特点

守护进程是后台进程;

生命周期比较长，从系统开启时开启，系统关闭时结束;

它是脱离控制终端且周期执行的进程。

4.2 创建步骤

1）创建子进程，父进程退出

让子进程变成孤儿进程，成为后台进程；fork()

2）在子进程中创建新会话

让子进程成为会话组组长并且脱离终端：为了让子进程完全脱离终端；setsid()

3）改变进程运行路径为根目录

原因: 进程运行的路径不能被删除或卸载；chdir("/")

函数说明：chdir() 将进程当前的工作目录改变成以参数路径所指的目录

4）重设文件权限掩码

目的：增大进程创建文件时权限，提高灵活性；umask(0)

子进程继承了父进程的文件权限掩码，给该子进程使用文件带来一定的影响，因此把文件权限掩码设置为0，可以增强该守护进程的灵活性。

5）关闭文件描述符

原因：子进程继承了父进程的一些已经打开了的文件，这些被打开的文件可能永远不会被守护进程访问，但它们一样占用系统资源，而且还可能导致所在的文件系统无法被卸载。

将不需要的文件关闭：close()

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        setsid();
        chdir("/");
        umask(0);
        for(int i=0;i<3;i++)  //关闭默认打开的文件描述符0 1 2 
            close(i);
        while(1);
    }
    else
    {
        exit(0);
    }
     
    return 0;
}

创建一个守护进程，循环间隔1s向文件中写入一串字符“hello”

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

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        setsid();
        chdir("/");
        umask(0);
        for (int i = 0; i < 3; i++) //关闭默认打开的文件描述符0 1 2
            close(i);
        
        //因为前面已经切换到了根目录，所以路径要从根目录开始
        int fd = open("/tmp/info.log", O_RDWR | O_CREAT | O_APPEND, 0777);
        //a+
        while (1)
        {
            sleep(1);
            write(fd, "hello", 5);
        }
    }
    else
    {
        exit(0);
    }

    return 0;
}

总结守护进程：

守护进程是一个生存周期较长的进程，通常独立于控制终端并且周期性的执行某种任务或者等待处理某些待发生的事件
大多数服务都是通过守护进程实现的
关闭终端，相应的进程都会被关闭，而守护进程却能够突破这种限制

线程 Thread

什么是线程

1.1 概念

线程是一个轻量级的进程，为了提高系统的性能引入线程。

线程和进程都参与统一的调度。

在同一个进程中可以创建的多个线程, 共享进程资源。

（Linux里同样用task_struct来描述一个线程）

1.2 进程和线程的区别

相同点：都为操作系统提供了并发执行能力

不同点：

调度和资源：线程是系统调度的最小单位，进程是资源分配的最小单位

地址空间方面：同一个进程创建的多个线程共享该进程的资源；进程的地址空间相互独立

通信方面：线程通信相对简单，只需要通过全局变量可以实现，但是需要考虑临界资源访问的问题；进程通信比较复杂，需要借助进程间的通信机制(借助3g-4g内核空间)

安全性方面：线程安全性差一些，当进程结束时会导致所有线程退出；进程相对安全

面试题：程序什么时候该使用线程？什么时候用进程？（深圳棱镜空间智能科技有限公司）（北京明朝万达）

对资源的管理和保护要求高，不限制开销和效率时，使用多进程。

要求效率高、速度快的高并发环境时，需要频繁创建、销毁或切换时，资源的保护管理要求不是很高时，使用多线程。

1.3 线程资源

共享的资源：可执行的指令、静态数据、进程中打开的文件描述符、信号处理函数、当前工作目录、用户ID、用户组ID

私有的资源：线程ID (TID)、PC(程序计数器)和相关寄存器、堆栈(局部变量, 返回地址)、错误号 (errno)、信号掩码和优先级、执行状态和属性

练习: 通过父子进程完成对文件的拷贝(cp)

通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO cp src dest

文件长度获取？lseek
子进程定位到文件一半的位置 lseek
父进程怎么能准确读到文件一半的位置
fork之前打开文件，父子进程中读写文件时，位置指针是同一个

open()
pid=fork()
else if(pid==0)
{
    //定位操作
    //循环读写
}
else
{
    wait(NULL);
    //定位操作
    //分情况讨论，每次让len减去读到的个数，直到最后len<32就读剩下的
}

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

#define BUF_SIZE 4096

int main(int argc, char *argv[]) 
{
    if (argc != 3)
    {
        fprintf(stderr, "Usage: %s source_file destination_file\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *source_file = argv[1];
    char *dest_file = argv[2];

    // 打开源文件
    int src_fd = open(source_file, O_RDONLY);
    if (src_fd == -1) 
    {
        perror("open source file");
        exit(EXIT_FAILURE);
    }

    // 创建目标文件
    int dest_fd = open(dest_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (dest_fd == -1) 
    {
        perror("create destination file");
        close(src_fd);
        exit(EXIT_FAILURE);
    }

    // 获取文件长度
    off_t file_len = lseek(src_fd, 0, SEEK_END);

    // 创建子进程
    pid_t pid = fork();
    if (pid == -1) 
    {
        perror("fork");
        close(src_fd);
        close(dest_fd);
        exit(EXIT_FAILURE);
    }

    if (pid == 0) 
    { // 子进程
        // 子进程定位到文件的一半处
        lseek(src_fd, file_len / 2, SEEK_SET);

        // 从文件的一半处开始读取数据并写入目标文件
        char buf[BUF_SIZE];
        ssize_t num_bytes;
        while ((num_bytes = read(src_fd, buf, BUF_SIZE)) > 0) 
        {
            write(dest_fd, buf, num_bytes);
        }

        close(src_fd);
        close(dest_fd);
        exit(EXIT_SUCCESS);
    } 
    else 
    { // 父进程
        // 父进程定位到文件开始处
        lseek(src_fd, 0, SEEK_SET);

        // 从文件开始处到文件的一半处读取数据并写入目标文件
        char buf[BUF_SIZE];
        ssize_t num_bytes;
        off_t bytes_copied = 0;
        while ((num_bytes = read(src_fd, buf, BUF_SIZE)) > 0 && bytes_copied < file_len / 2) {
            ssize_t bytes_to_write = num_bytes;
            if (bytes_copied + num_bytes > file_len / 2) 
            {
                bytes_to_write = file_len / 2 - bytes_copied;
            }
            write(dest_fd, buf, bytes_to_write);
            bytes_copied += bytes_to_write;
        }

        // 等待子进程结束
        wait(NULL);

        close(src_fd);
        close(dest_fd);
        exit(EXIT_SUCCESS);
    }

    return 0;
}