linux进程

最新推荐文章于 2024-11-18 21:05:40 发布
最新推荐文章于 2024-11-18 21:05:40 发布
阅读量51 收藏
点赞数
文章标签： linux bash 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ifdenf/article/details/133828929
版权

进程

1.进程标识符PID

类型 pid_t；命令ps;进程号是顺次向下使用；getpid();getppid();

  • ps axf 查看进程树
  • ps axm
  • ps ax -L
  • ps -ef

2.进程的产生

  • fork()
    - 注意理解关键字： duplicating，意味着拷贝 克隆 一模一样等含义； - fork 后父子进程的区别 ： fork 的返回值不一样， pid不同 ，ppid也不同， 未决信号与文件锁不继承，资源利用量清0； - init进程:1号， 是所以进程的祖先进程 pid == 1；调度器的调度策略来决定哪个进程先运行；fflush()的重要性。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    printf("%d start !\n",getpid());
    fflush(NULL);//记得刷新 否则begin放到缓冲区 父子进程fork复制的缓冲区里各有一句begin

    pid_t pid = fork();

    if (pid == 0){
        printf("child %d\n",getpid());
    }else{
        printf("parent %d\n",getpid());
    }
    getchar();
    printf("pid %d end\n",getpid());
    return 0;
}


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

#define LEFT 2
#define RIGHT 200

int main()
{
    pid_t pid = 0;
    int i,j,mark;

    for (i = LEFT;i <= RIGHT;i++){
        pid = fork();
        if (pid == 0){
            mark = 1;
            for (j = 2;j < i/2;j++){
                if (i%j == 0){
                    mark = 0;
                    break;
                }
            }
            if (mark) {
                printf("%d is a primer\n",i);
            }
            exit(0);//记得结束子进程
        }
    }
    getchar();

    exit(0);
}
//孤儿进程和僵尸进程
//读时共享，写时复制
  • vfork()

3.进程的消亡以及释放资源

  • wait();
  • waitpid();
  • waitid();
  • wait3();
  • wait4();
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>

#define N 3
#define LEFT 100000002
#define RIGHT 100000200
//分块；交叉分配；进程池
//交叉算法计算 池类算法涉及到竞争
int main()
{
    printf("[%d] start !\n",getpid());
    fflush(NULL);//记得刷新 否则begin放到缓冲区 父子进程的缓冲区里各有一句begin
    pid_t pid = 0;
    int i,j,mark;

    for (int n = 0;n < N;n++){
        pid = fork();
        if (pid < 0){
            perror("fork");
            for (int k = 0;k < n;k++){
                wait(NULL);
            }
            exit(1);
        }

        if (pid == 0){
            for (i = LEFT+n;i <= RIGHT;i+=N){
                mark = 1;
                for (j = 2;j <= i/2;j++){
                    if (i%j == 0){
                        mark = 0;
                        break;
                    }
                }
                if (mark) {
                    printf("%d is a primer\n",i);
                }
            }
            printf("[%d] exit\n",n);
            exit(0);
        }

    }

    int st,n;
    for (n =0 ;n < N;n++){
        //wait(NULL);
        wait(&st);
        printf("%d end\n",st);
    }

    exit(0);
}

//bash:bourne shell

exec函数族

exec 替换 当前进程映像

  • extern char **environ
  • execl();
  • execlp();
  • execle();
  • execv();
  • execvpa();
  • 注意刷新fflush流；

进程调用一种 exec 函数时，该进程完全由新程序替换，而新程序则从其 main 函数开始执行。因为调用 exec 并不创建新进程，所以前后的进程 ID （当然还有父进程号、进程组号、当前工作目录……）并未改变。exec 只是用另一个新程序替换了当前进程的正文、数据、堆和栈段（进程替换）。

进程间通信：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

include <stdio.h>
#include <unistd.h>
 
int main(int argc, char *argv[])
{
 printf("before exec\n\n");
 
 /* /bin/ls：外部程序，这里是/bin目录的 ls 可执行程序，必须带上路径（相对或绝对）
	   ls：没有意义，如果需要给这个外部程序传参，这里必须要写上字符串，至于字符串内容任意
	   -a，-l，-h：给外部程序 ls 传的参数
	   NULL：这个必须写上，代表给外部程序 ls 传参结束
	*/
	execl("/bin/ls", "ls", "-a", "-l", "-h", NULL);
 
 // 如果 execl() 执行成功，下面执行不到，因为当前进程已经被执行的 ls 替换了
	perror("execl");
 printf("after exec\n\n");
 
 return 0;
}
一个小shell
//lhq yyds
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <wait.h>
#include <glob.h>
#include <string.h>

#define BUFSIZE 1024
#define DELIMS " \t\n"

extern char **environ;

static int cd(char *path){
    int ret = chdir(path);
    if (ret == -1){
        perror("chdir");
    }
    return ret;
}

static void readrc(char *name){
    FILE *fp;
    fp = fopen(name,"r+");
    //处理文件内容
    fclose(fp);
}

static void prompt()
{
    char pwd[BUFSIZE];
    char name[BUFSIZE];
    getcwd(pwd,BUFSIZE);
    getlogin_r(name,BUFSIZE);
    printf("%s %s $ ",name,pwd);
}

static int parse(char *linebuf,glob_t *globres){
    char *tok;
    int flag = 0;
    

    while (1){
        tok = strsep(&linebuf,DELIMS);
        if (tok == NULL){
            break;
            return -1;
        }else if(strcmp(tok,"cd") == 0){
            char *path = strsep(&linebuf,DELIMS);
            return cd(path);
        }else if(tok[0] == '\0'){
            continue;
        }

        glob(tok,GLOB_NOCHECK|GLOB_APPEND*flag,NULL,globres);//第一次不能append glob_argv中是随机值 GLOB_NOCHECK | (GLOB_APPEND*flag)==0 第一次不append
        flag = 1;
    }
    return 1;
}


//之后记得 将 ctrl+c 转为 stdout:\n 将ctrl+d 转为 退出+再见标语
int main()
{
    printf("This is YSHELL\n");

    pid_t pid;
    char *linebuf = NULL;
    size_t lienbuf_size = 0;
    glob_t globres;//解析命令行

    //读取配置文件
    char *yshrc = "/home/yixingwei/.yshrc";//填一个绝对路径
    readrc(yshrc);

    while(1){
        prompt();


        //获取命令
        getline(&linebuf,&lienbuf_size,stdin);
        //解析命令
        int ret = parse(linebuf,&globres);
        
        if (ret == -1){
            
        }else if (ret == 0){//内部命令
            
        }else if (ret == 1){//外部命令
            fflush(NULL);
            pid = fork();
            if (pid < 0){
                perror("fork()");
                exit(1);
            }else if(pid == 0){
                execvp(globres.gl_pathv[0],globres.gl_pathv);
                perror("execl()");
                exit(1);
            }
        }
        waitpid(pid,NULL,0);
    } 
    
    exit(0);
}

用户权限以及组权限

  • u+s 当其他用户调用该可执行文件时，会切换成当前可执行文件的user的身份来执行

  • g+s

  • uid/gid

    • r real
    • e effective

函数

  • getuid() 返回 real
  • geteuid() 返回 effective
// mysudo
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>

int main(int argc,char **argv)
{
    if (argc < 3){
        fprintf(stderr,"Useage");
        exit(1);
    }

    pid_t pid;

    pid = fork();
    if (pid == 0){
        setuid(atoi(argv[1]));
        execvp(argv[2],argv+2);
        perror("execvp()");
        exit(1);

    }else {
        wait(NULL);
    }

    exit(0);
}


$ su
# chown root ./mysudo
# chmod u+s ./mysudo

//Linux chown（英文全拼：change owner）命令用于设置文件所有者和文件关联组的命令。利用 chown 将指定文件的拥有者改为指定的用户或组，用户可以是用户名或者用户 ID，组可以是组名或者组 ID，文件是以空格分开的要改变权限的文件列表，支持通配符。 。
$ ./mysudo 0 /etc/shadow
  • getgid
  • getegid
  • setuid 设置effective
  • setgid 设置effective
  • setreuid 交换 r e //是原子的交换
  • setregid 交换 r e

解释器文件

system()

可以理解成 fork+exec+wait 封装

进程会计

  • acct()

进程时间

  • times()

守护进程

  • 会话 sesion 标识是sid
  • 终端
  • setsid()
  • getpgrp()
  • getpgid()
  • setpgid()
  • 单实例守护进程：锁文件/var/run/name.pid
  • 启动脚本文件：/etc/rc*…

系统日志

  • syslogd 服务
  • openlog
  • syslog
  • closelog
#include <stdio.h>
#include <stdlib.h>
#include <sys/syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <syslog.h>

#define FNAME "/tmp/out"

static int deamonize(){
    int fd;
    pid_t pid;
    pid = fork();

    if (pid < 0){
        return -1;
    }

    if (pid > 0){
        exit(0);
    }

    fd = open("/dev/null",O_RDWR);//输出都忽略
    if (fd < 0){
        return -1;
    }
    if (pid == 0){
        printf("test");
        fflush(NULL);
        dup2(fd,0);
        dup2(fd,1);
        dup2(fd,2);
        if (fd > 2){
            close(fd);
        }
        setsid();//脱离终端
        //umask();
        chdir("/");
    }
    return 0;
}

int main()
{
    FILE* fp;

    //开启日志服务
    openlog("print i",LOG_PID,LOG_DAEMON);

    if (deamonize()){
        syslog(LOG_ERR,"init failed!");
    }else{
        syslog(LOG_INFO,"successded!");
    }

    fp = fopen(FNAME,"w+");
    if (fp == NULL){
        syslog(LOG_ERR,"write file failed!");
        exit(1);
    }

    syslog(LOG_INFO,"%s opened",FNAME);

    for(int i = 0; ;i++){
        fprintf(fp,"%d\n",i);
        fflush(NULL);
        syslog(LOG_DEBUG,"%d 写入",i);
        sleep(1);
    }

    closelog();
    fclose(fp);
    exit(0);
}


 journalctl _PID=XXX

文章目录


syslog(LOG_INFO,“successded!”);
} 

fp = fopen(FNAME,"w+");
if (fp == NULL){
    syslog(LOG_ERR,"write file failed!");
    exit(1);
}

syslog(LOG_INFO,"%s opened",FNAME);

for(int i = 0; ;i++){
    fprintf(fp,"%d\n",i);
    fflush(NULL);
    syslog(LOG_DEBUG,"%d 写入",i);
    sleep(1);
}

closelog();
fclose(fp);
exit(0);

}


~~~ bash
 journalctl _PID=XXX

文章目录

Linux进程控制
Junds0的博客
01-22 2220
第1关：进程等待 本关任务： 创建子进程； 等待子进程退出。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include<sys/types.h> #include<sys/wait.h> int g_i4event; int process_wait(void) { /********Begin****
Linux进程管理
Android系统优化
03-17 3324
Linux是类Unix系统，借鉴了Unix的设计并实现相关接口，但并非Unix。Linux系统中万物皆为文件，这种抽象方便操作数据或设备，只需一套统一的系统接口open, read, write, close即可完成对文件的操作Linux是单内核，支持动态加载内核模块，可在运行时根据需求动态加载和卸载部分内核代码；Linux内核支持可抢占；Linux内核创建进程，采用独特的fork()系统调用，创建进程较高效；
Linux进程——Linux下常见的进程状态
EterNity_TiMe_的计算机学习之路
05-03 2349
在了解Linux中进程的分类时，我们通常是先了解操作系统的进程，因为二者有一定的联系，了解操作系统能更好理解进程在操作系统中的运行关系。进程状态在进程中也极为重要，希望大家能理解透彻！
Linux查看进程
肩上风骋的博客
04-15 3270
LINUX查看进程。
linux 进程 status,Linux 进程状态详解
weixin_42178963的博客
04-29 3240
目的为了对进程从产生到消亡的整个过程进行跟踪和描述，就需要定义各种进程的各种状态并制定相应的状态转换策略，以此来控制进程的运行。粗略分类运行态：进程占用CPU，并在CPU上运行；就绪态：进程已经具备运行条件，但是CPU还没有分配过来；阻塞态：进程因等待某件事发生而暂时不能运行；当然理论上上述三种状态之间转换分为六种情况；运行 → 就绪：这是有调度引起的，主要是进程占用CPU的时间已耗尽。就绪 → ...
Linux 进程调度策略
小羊苏C的博客
03-16 3193
进程分类 有两种传统的分类法： 方法一 CPU密集 I/O密集 方法二 交互 （比如记事本） 批处理 （比如后台、编译器进程） 实时 进程抢占 进程是可抢占的，在新的进程进入TASK_RUNNING状态，表示可以运行的时候，内核会检查他们的动态优先级。如果比当前的进程优先级高就调用调度器进行调度。 调度算法和调度类 SCHED_FIFO 一个先入先出的实时过程。当调度器将CPU分配给进程时，它会将进程描述符保留在运行队列列表中的当前位置。如果没有其他更高优先级的实时进程可以运行，那
Linux进程优先级的调整
wbsyga的博客
08-31 6800
Linux进程优先级：top、renice、nice
Linux进程控制——Linux进程终止
EterNity_TiMe_的计算机学习之路
05-12 2010
进程终止相对于其他的进程控制来说，是很好理解的。我们主要介绍了进程终止，在明白错误码和退出码之后，相信能理解父进程是怎么得到子进程信息的。让我们期待下一节——进程等待与替换！
Linux进程控制【创建、终止、等待】
北 海的博客
03-16 6941
进程创建后，需要对其进行合理管理，光靠OS是无法满足我们的需求的，此时可以运用进程控制相关知识，对进程进行手动管理，如创建进程、终止进制、等待进程等，其中等待进程可以有效解决僵尸进程问题
Linux进程管理进程优先级nice
s1429583654的博客
10-10 2746
进程管理——————优先级nice命令的使用
Linux进程的睡眠和唤醒
07-14
1 Linux进程的睡眠和唤醒 在Linux中，仅等待CPU时间的进程称为就绪进程，它们被放置在一个运行队列中，一个就绪进程的状 态标志位为TASK_RUNNING。一旦一个运行中的进程时间片用完， Linux 内核的调度器会剥夺这个...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案 Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一...
东南大学操作系统课程设计——Linux进程管理及其扩展
07-03
此资源包含完整实验报告（加上你的学号姓名即可提交）
Linux进程调度器的设计--Linux进程的管理与调度(十七） - 嵌入式Linux中文站1
08-03
Linux进程调度器的设计是操作系统核心中的重要组成部分，其主要任务是高效、公平地分配CPU时间给系统中的各个进程，以确保系统的响应速度和整体性能。本文将深入探讨Linux进程调度器的基本原理、进程分类及其对应的...
Linux进程间通讯视频教程
06-29
本教程通过6个视频，深入浅出地讲解了Linux进程间通信的关键概念和技术。 首先，我们来了解一下什么是进程间通信。在Linux系统中，进程是程序的一次执行实例，每个进程都有自己的独立内存空间，因此它们之间的数据...
Linux编辑/etc/fstab文件不当，不使用快照；进入救援模式
feng68_的博客
11-14 689
如果遇到任何问题，您可能需要进一步的故障排除，比如检查文件系统的完整性或修复文件系统错误。1)当出现以下警告时不要慌，如果文件系统默认挂载为只读模式，将其重新挂载为读写模式就好了，应该是吧。您可以选择1继续，或者选择2以只读模式挂载文件系统，或者选择3跳过直接进入shell。后面加)， 把只读模式改成读写模式 ，然后ctrl+x重启。然后会出现一串红色的字，太快了，看不清，然后就重启成功了。如果您在虚拟控制台（VC）1或VC2中，可以使用。获取root权限，这样您就可以编辑。2）挂载根文件系统为读写模式。
操作系统实验：在linux下用c语言模拟进程调度算法程序
m0_68165821的博客
11-15 907
进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。进程执行时，每运行一个时间片，进程还需要的时间片数减1，运行进程占用处理机的时间片数加1，然后比较占用CPU的时间片数是否与该进程的轮转时间片数相等，若相等则说明已达到轮转时间，应将现运行的进程排列就绪队列的末尾，调度队列上的首进程运行，且改变它们的进程状态，直至所有进程完成各自的时间片。（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
『 Linux 』文件与网络套接字的内部关系
最新发布
小侯宝的博客
11-18 607
假设使用浏览器在线观看视频,网速突然变慢或者是视频数据没有到达时,浏览器将希望从套接字收取更多的数据来显示视频,但由于数据尚未到达,浏览器操作数据的进程可能需要等待,对应的这个浏览器进程将会被添加到该套接字。对应的方法集则是特定于网络协议套接字操作的方法,对应结构体中包含了一系列的函数指针,这些函数指针定义了网络套接字在不同协议栈(如TCP,UDP等)下的行为,包括套接字的创建。方法集在文件指向网络时,主要的操作作用域是对上的,通常情况下在进行网络通信时,数据的生产位置是位于用户层/应用层的,而。
【Linux】多线程（中）
Eristic0618的博客
11-14 1419
本篇文章围绕Linux中的多线程展开讲解，包含线程互斥的概念、互斥量mutex和相关API、互斥量原理、重入和线程安全、死锁、线程同步和条件变量等内容
Linux进程调度实现分析
资源摘要信息:"Linux进程调度" Linux进程调度是操作系统的核心功能之一，它负责决定在多个可执行进程中哪个将获得CPU的使用权。良好的进程调度机制可以保证系统的高效运行，使得各个进程能够公平、高效地共享CPU...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值