C语言：进程

最新推荐文章于 2024-09-27 19:15:27 发布
最新推荐文章于 2024-09-27 19:15:27 发布
阅读量1k 收藏 25
点赞数 13
分类专栏： C 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58233509/article/details/139608954
版权

一、进程标识符pid

类型pid_t，16位整型数三万多个。2的16次方65535.

进程标识是顺次向下使用。与文件描述符不一样。
       pid_t getpid(void);
       pid_t getppid(void);

进程正常终止

1.从main函数返回

2.调用exit

3.调用_exit或_Exit

4.最后一个线程从启动例程返回

5.最有一个线程调用了pthread_exit

进程异常终止

调用abort

接到一个信号并终止

最后一个进行对其取消请求做出响应

二、进程的产生

fork

系统调用，只存在linux环境，duplicating意味着拷贝，克隆。
fork后父子进程的区别：fork返回值不一样，pid不同，ppid也不同，未决信号和文件锁不继承，资源利用量归零。
init进程：所有进程的祖先进程（1号 ）
调度器的调度策略会决定哪个程序先运行。

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


int main()
{
    pid_t pid;
    printf("[%d]:Begin() \n",getpid() );
    pid = fork();
    if(pid <0)
    {
        perror("fork()");
        exit(1);
    }
    else if(pid == 0)
    {
        //子进程
        printf("[%d]:Child is working \n",getpid() );
    }
    else
    {
        //父进程
        printf("[%d]:Parent is working \n",getpid() );
    }
    printf("[%d]:end() \n",getpid() );
    return 0;
}

如果把输出打印在终端上begin会打印一次（行缓存），如果打印在文件中begin会打印两次（全缓冲）fork也会拷贝缓冲区内容。

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


int main()
{
    pid_t pid;
    printf("[%d]:Begin() ",getpid() );
    fflush(NULL);//需要刷新缓冲区  !!!非常重要
    
    pid = fork();
    if(pid <0)
    {
        perror("fork()");
        exit(1);
    }
    else if(pid == 0)
    {
        //子进程
        printf("[%d]:Child is working \n",getpid() );
    }
    else
    {
        //父进程
        printf("[%d]:Parent is working \n",getpid() );
    }
    printf("[%d]:end() \n",getpid() );
    return 0;
}


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

#define LEFT  30000000
#define RIGHT 30000200

int main()
{
    pid_t pid;
    int i,j,mark;
    for(i = LEFT;i< RIGHT;i++)
    {
        pid = fork();
        if(pid <0)
            exit(1);
        else 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);
        }
        else
        {

        }

    }

    return 0;
}

fork采用写时拷贝技术，读的情况是不会改变的。谁改变的话，谁就拷贝一份。

vfork

vfork在fork时，指定同一个数据块，不会拷贝，已废弃。

三、进程的消亡与释放资源

wait,waitpid,wait3,wait4

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

       pid_t wait(int *wstatus);

       pid_t waitpid(pid_t pid, int *wstatus, int options);
wait用状态接受，可以用宏进行接受判断。（死等）

waitpid,可以接受指定的pid。（options，可以设置不死等 WNOHANG）

wait，相当于wiatpid(-1,&status,0)

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define LEFT  30000000
#define RIGHT 30000200

int main()
{
    pid_t pid;
    int i,j,mark;
    for(i = LEFT;i< RIGHT;i++)
    {
        pid = fork();
        if(pid <0)
            exit(1);
        else 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);
        }
        else
        {

        }
        
    }
    int st;
    for(i = LEFT;i<RIGHT;i++)
//        wait(&st);
        wait(NULL);  //收尸

    return 0;
}

优化：上面程序使用了200个进程比较消耗资源，采用限制进程的方式对其进行改进。（1.分块法）（2.交叉分配法）（3.池类算法：上游负责仍数据，下游负责抢        ）

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define LEFT  30000000
#define RIGHT 30000200
#define N 3

int main()
{
    pid_t pid;
    int i,j,mark;
    int n;
    for(n = 0;n<N;n++)
    {
        pid = fork();
        if(pid < 0)
        {
            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:%d]%d is a primer \n",n,getpid(),i);
            }
            exit(0);
        }
    }
    for(n=0;n<N;n++)
    {
        wait(NULL);
    }
    return 0;
}

四、exec函数族

       extern char **environ;
       int execl(const char *pathname, const char *arg, ...
                       /* (char  *) NULL */);（路径）
       int execlp(const char *file, const char *arg, ...
                       /* (char  *) NULL */);（有环境变量）
       int execle(const char *pathname, const char *arg, ...
                       /*, (char *) NULL, char *const envp[] */);
       int execv(const char *pathname, char *const argv[]);
       int execvp(const char *file, char *const argv[]);
       int execvpe(const char *file, char *const argv[],
                       char *const envp[]);

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

int main()
{
    puts("Begin");
    fflush(NULL); //不刷新的话缓冲区会直接被替换

    execl("/bin/date","date","+%s",NULL);//出错会继续放下运行，成功就返回
    perror("execl()");
    exit(1);

    puts("End");
    return 0;
}


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

int main()
{
    puts("Begin");
    int pid;
    fflush(NULL);
    pid = fork();
    if(pid <0)
    {
        perror("fork");
        exit(1);
    }
    else if(pid == 0)
    {
        fflush(NULL);
        execl("/bin/date","date","+%s",NULL);
        perror("execl");
        exit(1);
    }
    else
    {
        
    }

    wait(NULL);
    puts("End");


    return 0;

}

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

int main()
{
    puts("Begin");
    int pid;
    fflush(NULL);
    pid = fork();
    if(pid <0)
    {
        perror("fork");
        exit(1);
    }
    else if(pid == 0)
    {
        fflush(NULL);
        //execl("/usr/bin/sleep","sleep","100",NULL);
        execl("/usr/bin/sleep","lxj","100",NULL);// ps -axf 可以看到名字
        perror("execl");
        exit(1);
    }
    else
    {
        
    }

    wait(NULL);
    puts("End");


    return 0;

}

五、用户权限及组权限

-rwsr-xr-x 1 root root 68208 Feb  6 04:49 /usr/bin/passwd*

u+s：别的用户调用可执行文件时，会切换到当前的用户（user）执行。如：passwd命令（红色）,sudo命令

g+s：别的用户调用可执行文件时，会切换到同组（group）用户的身份去执行（绿色）

real effective save（exec函数族会鉴定权限）


       uid_t getuid(void);
       uid_t geteuid(void);
        pid_t getgid(void);
       pid_t getegid(void);

         getuid() returns the real user ID of the calling process.

       geteuid() returns the effective user ID of the calling process.

       getgid() returns the real group ID of the calling process.

       getegid() returns the effective group ID of the calling process.

       int setuid(uid_t uid);
       int setgid(gid_t gid);
        int setreuid(uid_t ruid, uid_t euid);
       int setregid(gid_t rgid, gid_t egid);

         

mysu.c

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

int main(int argc,char*argv[])
{
    puts("Begin");
    if(argc <3)
    {
        printf("Usage...\n");
        return 1;
    }
    pid_t pid;
    pid = fork();
    if(pid<0)
    {
        printf("fork\n");
        exit(1);    
    }
    else if(pid ==0)
    {
        setuid(atoi(argv[1]) );
        printf("getuid = %d \n",getuid() );
        execvp(argv[2],argv+2);
        perror("execvp()");
        exit(1);
    }
    else
    {
    }
    wait(NULL);
    puts("End");


    return 0;

}

chown root mysu（添加root用户权限）
chmod u+s （改变权限为 u+s）
./mysu 0 cat /etc/shadow

六、观摩课：解释器文件

也成为脚本文件。sh后缀的文件 #! 开头。

#!/bin/sh

ls 
whoami
cat /etc/shadow

ps

修改/etc/passwd

 56 john:x:1001:1001::/home/john:/usr/bin/top
  56 john:x:1001:1001::/home/john:/usr/local/bin/mysh

七、system

The  system()  library function uses fork(2) to create a child process that executes the shell command specified in command using
       execl(3) as follows:

           execl("/bin/sh", "sh", "-c", command, (char *) NULL);

       system() returns after the command has been completed.
 

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

int main()
{
    system("date +%s > /tmp/out");
 
    return 0;

}

八、进程会计

       int acct(const char *filename);
进程消亡时，会将进程信息写入文件中。

man 2 acct
man 5 acct

九、进程时间

    #include <sys/times.h>

       clock_t times(struct tms *buf);

   struct tms {
               clock_t tms_utime;  /* user time */
               clock_t tms_stime;  /* system time */
               clock_t tms_cutime; /* user time of children */
               clock_t tms_cstime; /* system time of children */
           };

十、守护进程

守护进程又叫精灵进程。满足脱离控制终端，是一个会话（session,标识sid）的leader和一个进程组的leader

  • Process ID(PID)
    Linux中标识进程的一个数字，它的值是不确定的，是由系统分配的（但是有一个例外，启动阶段,kernel运行的第一个进程是init，它的PID是1，是所有进程的最原始的父进程），每个进程都有唯一PID，当进程退出运行之后，PID就会回收，可能之后创建的进程会分配这个PID
  • Parent Process ID(PPID)
    字面意思，父进程的PID
  • Process Group ID(PGID)
    PGID就是进程所属的Group的Leader的PID，如果PGID=PID，那么该进程是Group Leader
  • Session ID(SID)
    和PGID非常相似，SID就是进程所属的Session Leader的PID，如果SID==PID，那么该进程是session leader

Session和Group都是管理多个进程的方式，同一个Group的进程属于同一个Session，一个Session里可以包含多个Group

ps -axj 查看tty为？代表脱离控制终端，PID,SID,PGID相同。 PPID为1         

    pid_t setsid(void);
       int setpgid(pid_t pid, pid_t pgid);
       pid_t getpgid(pid_t pid);

       pid_t getpgrp(void);                 /* POSIX.1 version */
       pid_t getpgrp(pid_t pid);            /* BSD version */

       int setpgrp(void);                   /* System V version */
       int setpgrp(pid_t pid, pid_t pgid);  /* BSD version */

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


#define FILENAME "/tmp/out"

static int daemonize()
{
    int pid;
    int fd;
    pid = fork();
    if(pid < 0)
    {
        return -1;
    }
    if (pid == 0)
    {
        fd= open("/dev/null",O_RDWR);
        if(fd <0)
        {
            return -1;
        }
        printf("child fd= %d \n",fd);
        dup2(fd,0);//关闭0 ，让0 指向fd的文件表项, 即标准输出置为空设备
        printf("child fd= %d \n",fd);
        dup2(fd,1);
        dup2(fd,2);
        if(fd >2)
        {
            close(fd);
        }
        setsid(); //实现守护进程的函数
        chdir("/");  //设置工作路径为根路径
//        umask(0);
        return 0;
    }
    else
    {
        return -1;
    }
}

int main()
{
    FILE*fp;
    int count;

    int ret = daemonize();
    printf("ret = %d \n",ret);
    if(ret != 0)
        exit(1);

    fp = fopen(FILENAME,"w");
    if(fp == NULL)
    {
        perror("fopen()");
        exit(1);
    }
    for(count = 0;;count++)
    {
        fprintf(fp,"%d \n",count);

        fflush(fp);
        sleep(1);
    }
    fclose(fp);
    return 0;
}

单实例守护进程：锁文件 /var/run/name.pid。

启动脚本文件：/etc/rc.local。进行添加 

十一、系统日志

/var/log目录下的文件。syslogd服务进行统一管理。

文件名是：syslog

     #include <syslog.h>

       void openlog(const char *ident, int option, int facility);
       void syslog(int priority, const char *format, ...);
       void closelog(void);

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

#define FILENAME "/tmp/out"

static int daemonize()
{
    int pid;
    int fd;
    pid = fork();
    if(pid < 0)
    {
        return -1;
    }
    if (pid == 0)
    {
        fd= open("/dev/null",O_RDWR);
        if(fd <0)
        {
            return -1;
        }
        printf("child fd= %d \n",fd);
        dup2(fd,0);//关闭0 ，让0 指向fd的文件表项, 即标准输出置为空设备
        printf("child fd= %d \n",fd);
        dup2(fd,1);
        dup2(fd,2);
        syslog(LOG_INFO,"child fd = %d",fd);
        if(fd >2)
        {
            close(fd);
        }
        setsid(); //实现守护进程的函数
        chdir("/");  //设置工作路径为根路径
//        umask(0);
        return 0;
    }
    else
    {
        exit(1);
    }
}

int main()
{
    FILE*fp;
    int count;
    openlog("mydaemon",LOG_PID,LOG_DAEMON);

    int ret = daemonize();
    printf("ret = %d \n",ret);
    if(ret != 0)
    {
        syslog(LOG_ERR,"daemonize() failed");
        exit(1);
    }
    else
    {
        syslog(LOG_INFO,"daemonize() successed ret = %d",ret);
    }
    fp = fopen(FILENAME,"w");
    if(fp == NULL)
    {
        syslog(LOG_ERR,"fopen():%s",strerror( errno));
        exit(1);
    }
    syslog(LOG_INFO,"%s was opened",FILENAME);
    for(count = 0;;count++)
    {
        fprintf(fp,"%d \n",count);

        fflush(fp);
        syslog(LOG_DEBUG,"%d is printed",count);
        sleep(1);
    }
    fclose(fp);
    closelog();
    return 0;
}

only-lucky
关注
专栏目录
C语言进程
m0_60252840的博客
09-29 788
一、进程环境 1.虚拟地址空间 栈：局部变量，函数的形参；未初始化值随机；生命周期随函数的调用结束而结束 堆：用户自行申请和释放，动态开辟 bss段：未初始化的局部静态变量和全局变量;初始值为0 data段：已初始化的局部静态变量和全局变量；生命周期从定义开始到进程结束 文本段 2.环境表 extern char **environ #include <stdio.h> #include <stdlib.h> extern char **enviro...
C语言：标准与实现
11-17
### C语言：标准与实现 #### 一、版本更新历史 **版本号 0.9 (发布日期: 07-01-04)** - **主要变化**: 此版本为初始版本。 **版本号 0.9a (发布日期: 07-06-04)** - **主要变化**: - 整本书改用16开本进行排版，...
C语言-进程-线程
qq_33406021的博客
05-06 1079
USER: 启动这些进程的用户PID: 进程的ID%CPU 进程占用的CPU百分比；%MEM 占用内存的百分比；VSZ：进程占用的虚拟内存大小（单位：KB）RSS：进程占用的物理内存大小（单位：KB）
C语言-进程
最新发布
2301_76460223的博客
09-27 1127
在 C 语言中，进程通常被认为是一个正在执行的程序的实例。从操作系统的角度来看，进程包含了程序的代码、数据、堆、栈以及各种系统资源（如文件描述符、信号处理等）。每个进程都在自己独立的内存空间中运行，与其他进程相互隔离，以确保安全性和稳定性。在 C 语言编程中，可以通过系统调用和库函数来操作进程。例如，可以使用fork系统调用创建一个新的进程，新创建的子进程会继承父进程的一部分资源，但拥有独立的内存空间和运行状态。
C语言进程结构
life_liver的专栏
03-09 799
C语言的程序被加载到内存以后，可以有如下结构：   text段，用来存储二进制代码 initialized data段，通常简称data段，用来存储显式初始化的全局变量，如 int a=9; uninitialized data段，通常称作bss（block started by symbol），用来存储未显式初始化的全局变量，如int a; 尽管操作系统内核会将a初始化为0； he
C语言 进程
Claroja
01-01 466
基础 内核通过exec创建进程 进程内部调用exit或_exit和_Exit来退出进程 创建进程 1.exec启动一个新程序，替换原有的进程,pid不会改变 2.system创建一个新进程,并等待 3.fork创建一个新进程 ...
c语言多进程多线程编程
07-21
C语言作为一门底层且强大的编程语言，提供了丰富的系统调用接口来实现多进程和多线程编程。 **多进程（Multiprocessing）** 1. **进程定义**：进程是程序的一次执行实例，每个进程都有自己的独立内存空间，包括...
Linux C语言：共享内存在进程间通信中的应用与示例
在Linux环境下，C语言编程中实现进程间通信的一个重要方法是使用共享内存。共享内存是一种高效的通信方式，因为它允许不同的进程直接访问同一块内存区域，而无需通过消息传递。本文档主要讲解如何利用C语言提供的...
Linux下C语言修改进程名称的方法
12-31
本文实例讲述了Linux下C语言修改进程名称的方法。分享给大家供大家参考。具体如下： #include #include #include ./util/setproctitle.c // extern char **environ; // int main(int argc , char *argv[]) // { /...
c语言多进程多线程编程.doc
03-14
C语言多进程多线程编程概述 多进程编程是计算机系统中的一种重要机制，通过创建多个进程来实现程序的并发执行，提高系统的效率和性能。在C语言中，多进程编程通过系统调用来实现，系统调用fork()可以创建一个新的...
进程管理 C语言代码
06-08
本代码是关于进程管理的C语言源代码，适合于做操作系统的实验
c语言进程开发，创建与删除
05-21
一个进程管理的开发程序，可以对进程进行创建，删除，添加，等一此列功能，希望可以帮助大家
进程管理程序c语言实现
03-10
用C语言实现对进程的管理，结构简单明了。
C语言 进程
疯
03-02 4662
进程 是一种抽象概念，从来没有统一的标准定义： fork()函数用来创建一个新的进程，新创建的这个进程的data数据段，stack堆栈段等进程基本的内容以及当前程序状态指针PC-point也完全和父进程相同！也就是说fork创建的子进程是父进程的副本，新创建的这个进程，Linux会为它分配对应的内存页来保存与父进程完全相同data、stack、进程运行到的目前的状态。但是对于程序段text，父进程...
进程
Damage
07-18 411
参见：Linux C编程一站式学习   1.进程控制   1）fork函数：   fork函数的特点概括起来就是“调用一次，返回两次”，在父进程中调用一次，在父进程和子进程中各返回一次。从上图可以看出，一开始是一个控制流程，调用fork之后发生了分叉，变成两个控制流程，这也就是“fork”（分叉）这个名字的由来了。子进程中fork的返回值是0，而父进程中fork的返回值则是子进程...
linux下C的fork函数应用实例
weixin_33695450的博客
01-02 327
最近在复习考试，顺便把一些心得写下来吧。 题目：写出一段程序，创建4个子进程，每个子进程都打印“Hello”后立刻终止，父进程等待4个子进程都终止后，打印“Bye”，然后终止。 答：这里有两种结构的程序，各位看哪种顺眼就看哪种吧~ #include<stdio.h>#include<stdlib.h>#include<sys/types...
c语言—进程
qq_45812787的博客
07-14 399
进程映像： 程序：储存在磁盘中的可执行的文件(二进制文件、脚本文件) 进程：在系统中运行的程序 进程映像：进程的内存的分布情况 text 代码段： 存储的是二进制的指令、常量数据，权限是只读的（可执行），如果强行修改会产生段错误 data 数据段： 存储的是初始化过的全局变量、被初始化过的静态局部变量 bss 静态数据段：存储的是未初始化过的全局变量、未初始化过的静态局部变量,程序运行前会清零 heap 堆： 由程序员手动管理的，手动申请、释放的，使用比较麻烦，特点是：足够大，理论上无限大
C语言进程——基础
Stars____的博客
04-25 6619
什么是进程 什么是程序 一组可以被计算机直接识别的 有序 指令 的集合。 通俗讲：C语言编译后生成的可执行文件就是一个程序。 那么程序是静态还是动态的？ 程序是可以被存储在磁盘上的，所以程序是静态的。 那什么是进程 进程是程序的执行过程，是动态的，随着程序的使用被创建，随着程序的结束而消亡。 可以说进程是一个独立的可调度的任务。 进程是程序执行的最小单位。 进程是资源(内存资源)管理的最小单位。 一个程序可以只有一个进程，此时正在运行的这个程序也叫进程。 一个程序也可以有多个进程，此时正在运行的这个程序
掌握C语言：隐藏进程源码实战项目解析
资源摘要信息:"本文档为一份关于C语言的训练材料，内容涉及如何隐藏进程以及C语言项目实战案例。材料中提到的源码可以从其他论坛获取，并可用于将Microsoft语音识别训练功能集成到语音引擎中。文档还提到了将该源码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值