Linux进程管理

最新推荐文章于 2024-08-14 08:54:41 发布
最新推荐文章于 2024-08-14 08:54:41 发布
阅读量156 收藏
点赞数
分类专栏： # Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lee_01/article/details/88049589
版权

一、进程

1.概念

  • 进程是正在内存中运行的程序
  • ps au可以列出操作系统中正在运行的进程

2.fork函数

#include<unistd.h>
// 功能：创建进程
// 返回值：成功时返回进程ID，失败时返回-1
pid_t fork();
  • 两个进程都将执行fork函数返回后的语句。因为通过同一个进程、复制相同的内存空间，所以之后的程序流要通过fork函数的返回值加以区分。对于父进程，fork函数返回子进程ID；对于子进程，fork函数返回0
#include<stdio.h>
#include<unistd.h>

int gval = 10;
int main() {
    pid_t pid;
    int lval = 20;
    gval++; lval += 5;

    pid = fork();
    if (pid == 0) {
        gval += 2, lval += 2;
        printf("Child process: gval=%d, lval=%d \n", gval, lval);
    }
    else {
        gval -= 2, lval -= 2;
        printf("Parent process: gval=%d, lval=%d \n", gval, lval);
    }

    return 0;
}
  • 运行结果：

Parent process: gval=9, lval=23 
Child process: gval=13, lval=27 

3.僵尸进程

  • 进程完成工作后（执行完main函数中的程序后）应被销毁，但又是这些进程会变成僵尸进程，占用系统的重要资源
  • 产生僵尸进程的原因：1）传递参数并调用exit函数；2）main函数中执行return语句并返回值。向exit函数传递的参数值和return返回值都会传递给操作系统，而操作系统不会销毁子进程，直到把这些值传递给产生该子进程的父进程。处于这种状态下的进程就是僵尸进程。将子进程变成僵尸进程的正是操作系统。
  • 操作系统不会主动把这些值传递给父进程那个，除非父进程主动发起请求
#include<stdio.h>
#include<unistd.h>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        printf("Child process id: %d \n", getpid());
    }
    else {
        printf("Parent process id: %d \n", getpid());
        sleep(10);
    }
    return 0;
}

运行结果：可以看到子进程(PID=3475）的状态为Z+，说明已经变成僵尸进程

4.利用wait函数销毁僵尸进程

#include<sys/wait.h>
// 功能：主动请求获取子进程的返回值
// 返回值：成功时返回终止的子进程ID，失败时返回-1
pid_t wait(int* statloc);
  • 调用用此函数时，如果有子进程终止，那么子进程终止时传递的返回值将保存到该函数的参数所指内存空间，但函数参数所指向的单元还包含其他信息，所以需要通过以下宏进行分离：WIFEXITED子进程正常终止时返回true；WEXITSTATUS返回子进程的返回值。
  • 调用此函数时，如果没有子进程终止，程序将阻塞直到有子进程终止。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/wait.h>

int main() {
    int status;
    pid_t pid = fork();
    if (pid == 0) {
        printf("First child process id: %d \n", getpid());
        return 3;
    }
    else {
        pid = fork();
        if (pid == 0) {
            printf("Second child process id: %d \n", getpid());
            exit(7);
        }
        else {
            printf("Parent process id: %d \n", getpid());
            wait(&status);
            if (WIFEXITED(status))
                printf("first return value form child: %d \n", WEXITSTATUS(status));

            wait(&status);
            if (WIFEXITED(status))
                printf("second return value form child: %d \n", WEXITSTATUS(status));

            sleep(10);
        }
    }
    return 0;
}

运行结果：两个子进程的状态均不为Z+

5.利用waitpid函数销毁僵尸进程

#include<sys/wait.h>
// 功能：请求获取指定子进程的返回值
// 参数：
//    pid--等待终止的子进程的ID，若传递-1，则与wait函数相同，可以等待任意子进程终止
//    statloc--保存子进程返回值的变量地址
//    options--传递头文件sys/wait.h中声明的常量WNOHANG，即使没有终止的子进程也不会进入阻塞状态
// 返回值：成功时返回终止的子进程ID（或0），失败时返回-1
pid_t waitpid(pid_t pid,int* statloc,int options);
#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>

int main(int argc, char* argv[]) {
    int status;
    pid_t pid = fork();
    if (pid == 0) {
        sleep(15);
        return 24;
    }
    else {
        while (!waitpid(-1, &status, WNOHANG)) {
            sleep(3);
            puts("sleep 3s");
        }
        if (WIFEXITED(status))
            printf("child process return value: %d \n", WEXITSTATUS(status));

    }
    return 0;
}

运行结果：输出了5次"sleep 3s"，说明waitpid函数并未阻塞

二、信号处理机制

1.signal函数

#include<signal.h>
// 功能：信号注册
// 参数：
//    signo--信号id
//    void(*func)(int)--处理函数
// 返回值：返回注册的函数指针
void (*signal(int signo, void(*func)(int)))(int);
  • SIGALRM--已到通过调用alarm函数注册的时间
  • SIGINT--输入CTRL+C
  • SIGCHLD--子进程终止
#include<unistd.h>
// 功能：指定一段时间后产生SIGALRM信号，若传递0，则之前对SIGALRM信号的预约取消
// 参数：
//    seconds--定时
// 返回：返回0或以秒为单位的距SIGALRM信号发生所剩时间
unsigned int alarm(unsigned int seconds);
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void timeout(int sig) {
    if (sig == SIGALRM)
        puts("Time out!");
    alarm(2);
}

void keycontrol(int sig) {
    if (sig == SIGINT)
        puts("CTRL+C pressed");
}

int main(int argc, char* argv[]) {
    signal(SIGALRM, timeout);
    signal(SIGINT, keycontrol);
    alarm(2);

    for (int i = 0; i < 3; i++) {
        puts("wait...");
        sleep(10);
    }

    return 0;
}

运行结果：

2.sigaction函数

  • signal函数在UNIX系列的不同操作系统中可能存在区别，但sigaction函数完全相同
#include<signal.h>
// 功能：信号注册函数
// 参数：
//    signo--信号信息
//    act--对应于第一个参数的信号处理函数（信号处理器）信息
//    oldact--通过此参数获取之前注册的信号处理函数指针，若不需要则传递0
// 返回值：成功时返回0，失败时返回-1
int sigaciton(int signo,const struct sigaciton* act,struct sigacion* oldact);
  • sigaction结构体
struct sigaciton{
    void (*sa_handler)(int);
    sigset_t sa_mask;
    int sa_flags;
}
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void timeout(int sig) {
    if (sig == SIGALRM)
        puts("Time out!");
    alarm(2);
}

int main(int argc, char* argv[]) {
    struct sigaction act;
    act.sa_handler = timeout;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGALRM, &act, 0);

    alarm(2);

    for (int i = 0; i < 3; i++) {
        puts("wait...");
        sleep(10);
    }

    return 0;
}

运行结果：

三、利用信号处理机制消除僵尸进程

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

void read_childproc(int sig) {
    int status;
    pid_t id = waitpid(-1, &status, WNOHANG);
    if (WIFEXITED(status)) {
        printf("Removed proc id: %d \n", id);
        printf("Child return value: %d \n", WEXITSTATUS(status));
    }
}

int main(int argc, char* argv[]) {
    pid_t pid;
    struct sigaction act;
    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGCHLD, &act, 0);

    pid = fork();
    if (pid == 0) {
        puts("Child process");
        sleep(10);
        return 12;
    }
    else {
        printf("Child proc id: %d \n", pid);
        pid = fork();
        if (pid == 0) {
            puts("Child process");
            sleep(10);
            exit(24);
        }
        else {
            printf("Child proc id: %d \n", pid);
            for (int i = 0; i < 5; i++) {
                puts("wait...");
                sleep(5);
            }
        }
    }
    return 0;
}

四、进程间通信

1.管道通信

  • 管道并非属于进程的资源，和套接字一样属于操作系统，也就不是fork函数复制的对象
#include<unistd.h>
// 功能：创建管道
// 参数：
//    filedes[0]--管道出口
//    filedes[1]--管道入口
// 返回值：成功时返回0，失败时返回-1
int pipe(int filedes[2]);
#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30

int main(int argc,char* argv[]){
	int fds[2];
	char str[]="Hello world";
	char buf[BUF_SIZE];
	pid_t pid;

	pipe(fds);
	pid = fork();
	if(pid==0){
		write(fds[1],str,sizeof(str));	
	}else{
		read(fds[0],buf,BUF_SIZE);
		puts(buf);
	}
	return 0;	
}

运行结果：输出"Hello world"

3.一个管道双向通信

#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30

int main(int argc, char* argv[]) {
    int fds[2];
    char str1[] = "C";
    char str2[] = "C++";
    char buf[BUF_SIZE];
    pid_t pid;

    pipe(fds);
    pid = fork();
    if (pid == 0) {
        write(fds[1], str1, sizeof(str1));
        sleep(2);// 向管道传递数据时，先读取数据的进程将得到数据，删除会导致父进程读不到数据
        read(fds[0], buf, BUF_SIZE);
        printf("Child proc output: %s \n", buf);
    }
    else {
        read(fds[0], buf, BUF_SIZE);
        printf("Parent proc output: %s \n", buf);
        write(fds[1], str2, sizeof(str2));
        sleep(3);	// 父进程先终止时会弹出命令提示符，但子进程还在运行，删除的话不会有问题
    }
    return 0;
}

运行结果：

Parent proc output: C 
Child proc output: C++ 

4.两个管道双向通信

#include<stdio.h>
#include<unistd.h>
#define BUF_SIZE 30

int main(int argc, char* argv[]) {
    int fds1[2];	// 父写子读
    int fds2[2];	// 父读子写
    char str1[] = "C";
    char str2[] = "C++";
    char buf[BUF_SIZE];
    pid_t pid;

    pipe(fds1);
    pipe(fds2);
    pid = fork();
    if (pid == 0) {
        write(fds2[1], str1, sizeof(str1));
        sleep(2);// 向管道传递数据时，先读取数据的进程将得到数据，删除会导致父进程读不到数据
        read(fds1[0], buf, BUF_SIZE);
        printf("Child proc output: %s \n", buf);
    }
    else {
        read(fds2[0], buf, BUF_SIZE);
        printf("Parent proc output: %s \n", buf);
        write(fds1[1], str2, sizeof(str2));
        sleep(3);	// 父进程先终止时会弹出命令提示符，但子进程还在运行，删除的话不会有问题
    }
    return 0;
}

运行结果：

Parent proc output: C 
Child proc output: C++

Lee_01
关注
专栏目录
【LINUX】进程管理
兜哥的博客
04-06 2350
进程是计算机系统中最重要的概念之一，在计算机系统中并行运行着大量的程序，这些程序不可能独占系统的全部资源，而是需要这些程序共享系统资源，所以这些程序在运行时会产生一定的竞争关系。那在这种情况下，系统资源怎么分配？运行程序该如何管理呢？操作系统为了解决这一系列的问题引入了进程的概念，用来作为操作系统分配和管理系统资源的基本单位。所以进程的出现是为了让系统资源的利用更加合理，从而提高系统的运行效率。定义进程，就避免不了提到另一个概念“程序”。
linux进程管理原理
02-24
因此，对进程及其调度进行一般管理就显得极为重要。在用户空间，进程是由进程标识符（PID）表示的。从用户的角度来看，一个PID是一个数字值，可惟一标识一个进程。一个PID在进程的整个生命期间不会更改，但PID可以在...
进程结束时shell提示符的出现
m1f2c3的专栏
04-18 383
结果如下，“main= 366"有两秒的延时 结果如下，shell提示符之后有两秒的延时，而且shell提示符并不是出现在最后面 这两个函数对比发现，无论main的pid怎样改变，其父进程的pid一直是205，并且shell提示符总是随着main的exit(0)出现(即使子进程提前呼叫exit函数，也无法使shell提示符出现)。
struct sigaction 和信号处理函数的一些说明--1
RichardYSteven的专栏
11-05 5248
转自：http://hi.baidu.com/phps/blog/item/b064b7b71944cff630add1b4.html linux 中信号相关的一个结构体 struct sigaction 主要在sigaction信号安装和sigqueue信号发送时会用到该结构位于/usr/include/bits/sigaction.h在里面可以找到该结构的描述 {我现在实现
linux进程管理
qq_55343342的博客
07-30 3644
linux进程管理
Linux进程管理命令
slgcsdn的博客
05-24 2738
1.ps命令 ps aux：查看系统中的所有进程，使用BS操作系统格式 ps -le：查看系统中的所有进程，使用LINUX标准命令格式 选项：a：显示一个终端的所有进程，除会话引线外； u：显示进程的归属用户及内存的使用情况； x：显示没有控制终端的进程； -l：长格式显示更加详细的信息； -e：显示所有进程； 常用的命令：ps aux：可以查看系统中所有的进程 ps -le：可以查看系统中所有的进程，而且还能看到进程额父进程的PID和进程优先级； ps -l：只能看到当前shell产生的进程； 僵尸进程
深入解析Linux 进程管理机制(超详细)
最新发布
qq_66544042的博客
08-14 2577
在现代系统中，这通常是正常的，因为现代系统通常使用虚拟内存管理来管理内存和硬盘之间的空间分配，而不需要显式的交换分区或交换文件。进程是运行在linux中的程序的一个实例，是管理事务的基本单元；进程的状态是变化的，其包括进程的创建、调度和消亡。这描述了交换空间的使用情况（在物理内存不足时，系统会使用硬盘作为额外的内存，称为交换空间）。命令来查看进程树状图。ni: nice value，改变过优先级的进程占用的 CPU 时间百分比。6.RES: 进程当前使用的、驻留在物理内存中的大小，单位是KB。
【Linux】Linux进程管理
Linux小白一只~正处于学习阶段，觉得我写的还好的请多多给我点赞呀,谢谢大家！！(๑＞ڡ＜)☆
08-07 4676
Linux进程管理
Linux进程管理学习心得
qq_51102425的博客
05-07 1507
1 学习目标 掌握进程属性与进程处理机制 熟练使用 fork(),exec() 等系统调用创建进程,处理系统请求 掌握实现进程同步的方法 熟悉终端常用的进程管理命令 2 fork() 函数 这次课程主要学习了fork() 函数的调用 fork() 函数执行后，系统会创建一个与原进程近乎相同的进程 fork() 函数可以返回两个值，原因在于调用成功后会复制原程序，得到两个fork() 函数 fork() 函数调用成功部分截图 案例 1 使用fork函数创建一个进程，创建成功后父子进程分别执
Linux 进程管理
秋叶原 && Mike || 麦克
04-21 4837
引言：        在Linux的内核的五大组成模块中，进程管理模块时非常重要的一部分，它虽然不像内存管理、虚拟文件系统等模块那样复杂，也不像进程间通信模块那样条理化，但作为五大内核模块之一，进程管理对我们理解内核的运作、对于我们以后的编程非常重要。同时，作为五大组成模块中的核心模块，它与其他四个模块都有联系。下面就对进程模块进行想写的介绍，首先要了解进程及其相关的概念。其次介
东南大学操作系统课程设计——Linux进程管理及其扩展
07-03
此资源包含完整实验报告（加上你的学号姓名即可提交）
Linux服务器配置与管理：linux进程管理.pptx
05-01
在Linux服务器管理中，进程管理是一项基础且至关重要的任务，它涉及到系统性能监控、资源调度以及问题排查。本文将深入探讨Linux的进程管理方法，特别是如何使用`ps`和`top`这两个命令来查看和监视进程状态。 首先...
linux linux进程管理 常用命令
08-15
Linux 进程管理常用命令 Linux 进程管理是 Linux 系统管理员和普通用户的一项重要任务，主要是监视系统进程的运行状况，并适时终止一些失控的进程。本文将为您介绍 Linux 进程管理的常用命令和应用场景。 1. ps ...
Linux安装（虚拟机和双系统两种方法）
热门推荐
Lee_01的博客
10-16 1万+
一、VMware虚拟机 1.下载并安装VMware： ①https://my.vmware.com/cn/web/vmware/free#desktop_end_user_computing/vmware_workstation_player/15_0 ②下载Ubuntu镜像文件：https://www.ubuntu.com/download/desktop 2.安装Linux ①点击VM...
实现进程互斥的方法
Lee_01的博客
04-09 4462
1软件方法： 1.1单标志法 /* PROCESS 0 */ while(turn != 0); /* critical section */ turn = 1; /* PROCESS 1 */ while(turn != 1); /* critical section */ turn = 0; 特点：1）进入临界区之前先检查turn，如果等于进程号，就可以进入临界区，否则循环等待，因此...
有关进程同步与互斥的经典问题
Lee_01的博客
04-09 2360
1生产者消费者问题 1.1使用二元信号量解决无限缓冲区的生产者消费者问题 //使用二元信号量解决无限缓冲区的生产者消费者问题 int count = 0; //count为缓冲区中的数据项个数 BinSem s = 1, delay = 0; //s为二元信号量，控制生产者和消费者进入临界区； //delay为二元信号量，处...
CentOS下解决视频解码问题（opencv）
Lee_01的博客
04-09 689
问题：安装了ffmpeg后，opencv中将视频转换为图片时还是报错 一、安装ffmpeg 先卸载已安装的ffmpeg 安装yasm：yum install yasm 下载ffmpeg：http://ffmpeg.org/ 解压：tar -xjvf ffmpeg-3.3.1.tar.bz2 配置ffmpeg，进入ffmpeg-3.3.1所在目录，依次执行以下命令： cd ffmp...
vim使用笔记
Lee_01的博客
08-08 183
工作模式 ~/.vimrc 配置文件 set number set mouse=a set autoindent "change tab to 4 space" set expandtab set softtabstop=4 set textwidth=80 set wrap set linebreak set wrapmargin=2 set spell spelllang=en_us "prompt when current file is changed by another progr
Linux进程管理基础教程
"Linux进程管理教程，适合初学者，PDF格式，主要讲解PID和进程管理相关参数，由红联提供，包含创建、启动、调度、挂起、恢复、管理和杀死进程的方法，以及Webmin的进程管理。" 在Linux操作系统中，进程管理是核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值