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

简介: 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日志并进行多维度分析。
相关文章
|
4天前
|
算法 API C++
使用C++进行系统级编程的深入探索
【5月更文挑战第23天】本文探讨了C++在系统级编程中的应用,强调其接近底层、高性能、可移植性和面向对象编程的优势。关键技术和最佳实践包括:内存管理(智能指针和RAII原则)、多线程(std::thread和同步原语)、系统调用与API、以及设备驱动和内核编程。编写清晰代码、注重性能、确保安全稳定及利用开源库是成功系统级编程的关键。
|
5天前
|
存储 负载均衡 Linux
【Linux 系统】进程间通信(匿名管道 & 命名管道)-- 详解(下)
【Linux 系统】进程间通信(匿名管道 & 命名管道)-- 详解(下)
|
5天前
|
消息中间件 Unix Linux
【Linux 系统】进程间通信(匿名管道 & 命名管道)-- 详解(上)
【Linux 系统】进程间通信(匿名管道 & 命名管道)-- 详解(上)
|
5天前
|
缓存 Linux 调度
【Linux 系统】进程控制 -- 详解
【Linux 系统】进程控制 -- 详解
|
5天前
|
Java 调度
【JAVA学习之路 | 提高篇】进程与线程(Thread)
【JAVA学习之路 | 提高篇】进程与线程(Thread)
|
5天前
|
存储 Unix Linux
【Linux 系统】进程信号 -- 详解(下)
【Linux 系统】进程信号 -- 详解(下)
|
5天前
|
NoSQL Linux Shell
【Linux 系统】进程信号 -- 详解(上)
【Linux 系统】进程信号 -- 详解(上)
|
5天前
|
消息中间件 存储 安全
【Linux 系统】进程间通信(共享内存、消息队列、信号量)(下)
【Linux 系统】进程间通信(共享内存、消息队列、信号量)(下)
|
5天前
|
消息中间件 算法 Linux
【Linux 系统】进程间通信(共享内存、消息队列、信号量)(上)
【Linux 系统】进程间通信(共享内存、消息队列、信号量)(上)
|
6天前
|
算法 编译器 C语言
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL(下)
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL
13 0