C/C++进程超详细详解【中部分】(系统性学习day07)

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: C/C++进程超详细详解【中部分】(系统性学习day07)

前言

上篇博客对C/C++进程的上部分进行了详细讲解,本篇博客将继续讲解和补充关于线程的知识点。


一、守护进程

1.概念

(1)守护进程,

   也就是通常所说的Daemon进程,是Linux中的后台服务进程。

   它是一个生存期较长的进程,通常独立于控制终端并且周期性的执行某种任务或等待处理某些发生的事件

   守护进程常常在系统引导装入时启动,在系统关闭时终止

   Linux系统有很多守护进程,大多数服务都是用守护进程实现的

(2)终端

   在Linux中,每一个系统与用户进行交流的界面称为终端,每一个从此终端开始运行的进程都会依附于这个终端,这个终端就称为这些进程的控制终端,当控制终端被关闭时,相应的进程都会被自动关闭。

守护进程能够突破这种限制,它从被执行开始运转,直到整个系统关闭才会退出。

如果想让某个进程不因为用户或终端或其他的变化而受到影响,就必须把这个进程变成一个守护进程。

2.守护进程创建的原理(如图清晰可见)

3.守护进程的实现(代码块

void init_deamon(void)
{
    /*************** start ****************************/
    pid_t pid;
    int i,max_fd;
 
    //1,创建子进程
    if((pid = fork()) < 0){
        perror("fork");
        exit(1);
    }else if(pid > 0)
        exit(0);
 
    //2,创建新会话
    if(setsid() < 0){
        perror("setsid");
        exit(1);
    }
    //3,再创建子进程
    if((pid = fork()) < 0){
        perror("fork");
        exit(1);
    }else if(pid > 0)
        exit(0);
 
    //4,修改守护进程的工作目录
    chdir("/");
 
    //5,关闭进程父进程的所有的文件描述符
    max_fd = sysconf(_SC_OPEN_MAX);
    for (i = 0; i < max_fd;i++)
        close(i);
    //6,将标准输入,标准输出和标准错误重定向到/dev/null
    open("/dev/null",O_RDWR);
    dup(0);
    dup(0);
 
    //7,消除umask影响
    umask(0);
    /*************** end ****************************/
}

二、dup和dup2

1,复制文件描述符

int dup(int oldfd);
//参数 ---- 要复制的文件描述符
//返回值 ----成功:新的文件描述符,失败:-1
例如: 
int main(void)
{
    char str[] = "hello world";
    int fd1,fd2;
    fd1 = open("1.txt",O_RDWR|O_CREAT,0666);
    if(fd1 < 0){
        perror("open");
        exit(1);
    }
    write(fd1,str,strlen(str));
    fd2 = dup(fd1);   //复制文件描述fd1
    strcpy(str,"farsight");
    write(fd2,str,strlen(str));
    close(fd1);
    return 0;
}

2.文件描述符重定向

int dup2(int oldfd, int newfd);
//参数1 --- 目标文件描述符
//参数2 --- 要重定向的文件描述符
//返回值 ---- 成功0,失败:-1
例如: 
int main(void)
{
    char str[] = "hello world";
    int fd1,fd2;
    fd1 = open("1.txt",O_RDWR|O_CREAT,0666);
    if(fd1 < 0){
        perror("open");
        exit(1);
    }
    fd2 = open("2.txt",O_RDWR|O_CREAT,0666);
    if(fd1 < 0){
        perror("open");
        exit(1);
    }
    write(fd1,str,strlen(str));
    dup2(fd1,fd2);  //将fd2重定向到fd1
    strcpy(str,"farsight");
    write(fd2,str,strlen(str));
    close(fd1);
    return 0;
}

三、系统日志

1,打开日志

#include <syslog.h>
void openlog(const char *ident, int option, int facility);
//参数1 ------  //日志标签,自定义,方便查找日志信息
//参数2 ------  选项:
                LOG_CONS     如果消息不能发送给日志,则发送到控制台
                LOG_NDELAY   不延迟打开套接字,并发送消息
                LOG_NOWAIT   创建子进程,不阻塞发送消息给日志
                LOG_PERROR   发送日志,同时发送到标准错误文件
                LOG_PID      在消息中加入进程的ID
//参数3 ------   进程类型:
                    LOG_DAEMON      守护进程
                    LOG_FTP          tfp服务进程
                    LOG_KERN      内核进程
                    LOG_LPR       打印服务进程
                    LOG_MAIL      邮件服务进程
实例如下:
    openlog("mydaemon",LOG_PID,LOG_DAEMON);

2,向日志中写消息

void syslog(int priority, const char *format, ...);
//参数1 ----- 消息的优先级
               LOG_EMERG      非常紧急的错误
               LOG_ALERT      必须马上处理的错误
               LOG_CRIT       关键性错误
               LOG_ERR        一般错误
               LOG_WARNING    警告
               LOG_NOTICE     需要注意的消息
               LOG_INFO       正常消息
               LOG_DEBUG      调试消息
//参数2 -----向日志中写消息的格式
//变参 ----- 类似于printf的变参
例如: 
    syslog(LOG_ERR,"fopen:%s",strerror(errno));
    
运行测试:
     grep mydaemon /var/log/syslog -n
    203:Sep 26 23:36:26 ubuntu mydaemon[28968]: fopen:No such file or directory
3,关闭日志

void closelog(void);

四,文件锁

1.概念

为了解决进程之间的互斥问题,引入咨询锁

采用锁文件的方式取代创建文件的方式

   需遵循“君子协定”

   共享锁(shared Lock)和互斥锁(exculusive lock)

   对整个文件上锁或者文件的某个部分上锁(记录锁定)

2,给整个文件上锁

#include <sys/file.h>
int flock(int fd, int operation);
//参数1 ---- 文件描述符
//参数2 ---- 锁的类型:LOCK_SH  LOCK_EX  LOCK_UN
//返回值 ---成功:0,失败:-1

实例代码如下:

代码一:

int main(int argc,char **argv)
{
    int fd;
    int i;
 
    if(argc != 2){
        fprintf(stderr,"Usage: %s <filename>\n",argv[0]);
        exit(0);
    }
 
    if((fd = open(argv[1],O_RDWR)) < 0){
        perror("open");
        exit(1);
    }
 
    while(1){
        printf("等待获取锁\n");
        //获取互斥锁
        if(flock(fd,LOCK_EX) < 0){
            perror("flock");
            exit(1);
        }
 
        for(i = 0; i < 7; i++){
            printf("正在上厕所\n");
            sleep(1);
        }
        //释放锁
        if(flock(fd,LOCK_UN) < 0){
            perror("flock");
            exit(1);
        }
        printf("上完厕所出来了....\n");
        sleep(1);
    }
    return 0;
}
 

代码二:

int main(int argc,char **argv)
{
    int fd;
    int i;
 
    if(argc != 2){
        fprintf(stderr,"Usage: %s <filename>\n",argv[0]);
        exit(0);
    }
 
    if((fd = open(argv[1],O_RDWR)) < 0){
        perror("open");
        exit(1);
    }
 
    while(1){
        printf("等待着上厕所\n");
        //获取互斥锁
        if(flock(fd,LOCK_EX) < 0){
            perror("flock");
            exit(1);
        }
        for(i = 0; i < 7; i++){
            printf("正在上厕所...\n");
            sleep(1);
        }
        //释放锁
        if(flock(fd,LOCK_UN) < 0){
            perror("flock");
            exit(1);
        }
        printf("上完厕所!\n");
        sleep(1);
    }
    return 0;
}

3,给文件的某个区域上锁

#include <unistd.h>
#include <fcntl.h>
int fcntl(int fd, int cmd, ... /* arg */ );
 struct flock {
       short l_type;    /* Type of lock: F_RDLCK, F_WRLCK, F_UNLCK */
       short l_whence;  /* How to interpret l_start:
                           SEEK_SET, SEEK_CUR, SEEK_END */
       off_t l_start;   /* Starting offset for lock */
       off_t l_len;     /* Number of bytes to lock */
       pid_t l_pid;     /* PID of process blocking our lock
                           (set by F_GETLK and F_OFD_GETLK) */
   };

实例代码如下:

//定义锁的结构体--设置锁的区域
     struct flock fl = {
         .l_whence = SEEK_SET,
        .l_start = 100,
        .l_len  = 1024,
    };
 
    while(1){
        printf("等待获取锁\n");
        //获取互斥锁
        fl.l_type = F_WRLCK;   //设置锁的类型
        if(fcntl(fd,F_SETLKW,&fl) < 0){
            perror("flock");
            exit(1);
        }
 
        for(i = 0; i < 7; i++){
            printf("正在上厕所\n");
            sleep(1);
        }
        //释放锁
        fl.l_type = F_UNLCK;    //解锁
        if(fcntl(fd,F_SETLK,&fl) < 0){
            perror("flock");
            exit(1);
        }
        printf("上完厕所出来了....\n");
        sleep(1);
    }

五,进程间通信

1.分类

在linux中进程间通信分为三类:

(1)早期的进程间通信

   无名管道

   有名(命名)管道

   信号

(2)system V IPC

   消息队列

   共享内存

   信号灯(量)

(3)unix域套接字

2,无名管道

2.1 无名管道通信原理

2.2 用法

#include <unistd.h>
int pipe(int pipefd[2]);
//参数 ---- 保存管道两端文件描述符的数组
//返回值 ---成功:0,失败:-1
实例代码如下:
int main(void)
{
    int fd[2];
    pid_t pid;
    char buf[100];
 
    //创建无名管道
    if(pipe(fd) < 0){   //pipe()会在内核中创建无名管道,然后将管道两端的文件描述符返回给当前进程
        perror("pipe");
        exit(1);
    }
 
    //创建子进程
    if((pid = fork()) < 0){
        perror("fork");
        exit(1);
    }else if(!pid){  //子进程执行:从键盘获取字符串,写到管道中
        close(fd[0]);  //关闭读端
        while(1){
            fgets(buf,sizeof(buf),stdin);
            write(fd[1],buf,strlen(buf));   //向管道中写数据
        }
    }else{  //父进程执行:从管道读数据,打印到屏幕上
        close(fd[1]); //关闭写端
        while(1){
           if(read(fd[0],buf,sizeof(buf)) < 0){
                perror("read");
                exit(1);
           }
           printf("%s",buf);
        }
    }
 
    return 0;
}


总结

       本篇文章针对进程进行超详细讲解和补充,希望能够帮到大家!

       以后还会给大家展现更多关于嵌入式和C语言的其他重要的基础知识,感谢大家支持懒大王!

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
相关文章
|
22天前
麒麟系统mate-indicators进程占用内存过高问题解决
【10月更文挑战第7天】麒麟系统mate-indicators进程占用内存过高问题解决
108 2
|
25天前
|
资源调度 Linux 调度
Linux c/c++之进程基础
这篇文章主要介绍了Linux下C/C++进程的基本概念、组成、模式、运行和状态,以及如何使用系统调用创建和管理进程。
29 0
|
9天前
|
编译器 C语言 C++
配置C++的学习环境
【10月更文挑战第18天】如果想要学习C++语言,那就需要配置必要的环境和相关的软件,才可以帮助自己更好的掌握语法知识。 一、本地环境设置 如果您想要设置 C++ 语言环境,您需要确保电脑上有以下两款可用的软件,文本编辑器和 C++ 编译器。 二、文本编辑器 通过编辑器创建的文件通常称为源文件,源文件包含程序源代码。 C++ 程序的源文件通常使用扩展名 .cpp、.cp 或 .c。 在开始编程之前,请确保您有一个文本编辑器,且有足够的经验来编写一个计算机程序,然后把它保存在一个文件中,编译并执行它。 Visual Studio Code:虽然它是一个通用的文本编辑器,但它有很多插
|
25天前
|
消息中间件 Linux API
Linux c/c++之IPC进程间通信
这篇文章详细介绍了Linux下C/C++进程间通信(IPC)的三种主要技术:共享内存、消息队列和信号量,包括它们的编程模型、API函数原型、优势与缺点,并通过示例代码展示了它们的创建、使用和管理方法。
22 0
Linux c/c++之IPC进程间通信
|
25天前
|
Linux C++
Linux c/c++进程间通信(1)
这篇文章介绍了Linux下C/C++进程间通信的几种方式,包括普通文件、文件映射虚拟内存、管道通信(FIFO),并提供了示例代码和标准输入输出设备的应用。
17 0
Linux c/c++进程间通信(1)
|
25天前
|
Linux C++
Linux c/c++之进程的创建
这篇文章介绍了在Linux环境下使用C/C++创建进程的三种方式:system函数、fork函数以及exec族函数,并展示了它们的代码示例和运行结果。
28 0
Linux c/c++之进程的创建
|
29天前
|
Java 编译器 C++
c++学习,和友元函数
本文讨论了C++中的友元函数、继承规则、运算符重载以及内存管理的重要性,并提到了指针在C++中的强大功能和使用时需要注意的问题。
16 1
|
2月前
|
监控
MASM32写的免费软件“ProcView/系统进程监控” V1.4.4003 说明和下载
MASM32写的免费软件“ProcView/系统进程监控” V1.4.4003 说明和下载
|
2月前
|
C++
【C++案例】一个项目掌握C++基础-通讯录管理系统
这篇文章通过一个通讯录管理系统的C++项目案例,详细介绍了如何使用C++实现添加、显示、删除、查找、修改和清空联系人等功能。
36 3
|
24天前
麒麟系统mate-indicators进程占用内存过高问题解决
【10月更文挑战第5天】麒麟系统mate-indicators进程占用内存过高问题解决
95 0

相关实验场景

更多