【Linux操作系统】进程详解(下)

最新推荐文章于 2023-03-09 20:36:05 发布
最新推荐文章于 2023-03-09 20:36:05 发布
阅读量1k 收藏 9
点赞数 8
分类专栏： linux 文章标签： linux 运维 进程 守护进程 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65835264/article/details/127183869
版权
本文通过示例代码详细介绍了 Linux 中进程相关函数的使用方法，包括解决父子进程共用光标问题、守护进程的创建流程及其实现。并通过具体实例展示了 getpid/getppid、exit/_exit、wait/waitpid 函数的应用。
摘要由CSDN通过智能技术生成

文章目录

前言

前文【Linux操作系统】进程详解(上)详细讲解了进程相关概念的知识。
本文详细介绍进程相关函数和守护进程的相关内容。

一、父子进程共用光标问题

1.1 验证

代码如下（示例）：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
    pid_t pid;
    int fd;
    char ch;
    if((fd=open("./hello.txt",O_RDONLY))==-1)
    {
        PRINT_ERR("open error");
    }
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        lseek(fd,5,SEEK_SET);
        read(fd,&ch,1);
        printf("这是子进程%c\n",ch);
    }else{
        sleep(5);
        read(fd,&ch,1);
        printf("这是父进程%c\n",ch);
    }
    close(fd);
    return 0;
}

结果展示：
在这里插入图片描述
总结：
将子进程的光标向后移动5位后输出的是6，父进程因为和子进程共用的一个光标所以父进程在读取的时候并不是1，而是输出了7。
所以为了避免父子进程共用光标的问题，我们不应该在创建进程函数fork前打开文件，应该在各自的进程内打开或者可以打开文件两次，父子进程使用不同的文件描述符。

1.2 规避共用光标问题使用多进程拷贝同一个文件

代码如下（示例）：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int file_init_len(const char *src,const char *dest)
{
    int fd,fd1;
    int len;
    if((fd=open(src,O_RDONLY))==-1)
    {
        PRINT_ERR("open src error");
    }
    if((fd1=open(dest,O_RDWR|O_CREAT|O_TRUNC,0666))==-1)
    {
        PRINT_ERR("open dest error");
    }
    len=lseek(fd,0,SEEK_END);
    close(fd);
    close(fd1);
    return len;
}
int file_copy(const char *src,const char *dest,int start,int len)
{
    int fd,fd1;
    int count =0;
    int ret;
    char buf[128]={0};
    if((fd=open(src,O_RDONLY))==-1)
    {
        PRINT_ERR("open src error");
    }
    if((fd1=open(dest,O_WRONLY))==-1)
    {
        PRINT_ERR("open dest error");
    }
    lseek(fd, start, SEEK_SET);
    lseek(fd1, start, SEEK_SET);
    while((ret=read(fd,buf,sizeof(buf)))!=0)
    {
        count+=ret;
        if(count>=len)
        {
            write(fd1,buf,ret-(count-len));
            break;
        }
        write(fd1,buf,ret);
    }
    close(fd);
    close(fd1);
    return 0;
}
int main(int argc,const char * argv[])
{
    pid_t pid;
    int len;
    //1.判断传参是否正确./a.out srcfile destfile
    if(argc!=3)
    {
        fprintf(stderr, "input error,try again\n");
        fprintf(stderr, "usage:./a.out srcfile destfile\n");
        return -1;
    }
    //2.求源文件有多少字节
    len=file_init_len(argv[1],argv[2]);
    //3.父子进程拷贝
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        file_copy(argv[1],argv[2],0,len/2);
    }else{
        file_copy(argv[1],argv[2],len/2,len-len/2);
    }
    return 0;
}

结果展示：
在这里插入图片描述
总结：
父子进程调用拷贝函数都打开了文件，所以并不是共用一个光标。

二、进程相关函数

2.1 getpid/getppid函数

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

pid_t getpid(void);
功能：获取当前进程的进程号
参数：无
返回值：总是会成功了，返回进程的pid

pid_t getppid(void);
功能：获取父进程的进程号
参数：无
返回值：总是会成功了，返回进程的ppid

代码如下（示例）：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
    pid_t pid;
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        printf("这是子进程");
        printf("pid=%d,ppid=%d\n",getpid(),getppid());
    }else{
        sleep(1);
        printf("这是父进程");
        printf("pid=%d,ppid=%d,cpid=%d\n",getpid(),getppid(),pid);
    }
    return 0;
}

结果展示：
在这里插入图片描述
总结：
getpid用来获取当前进程的进程号，getppid用来获取当前进程的父进程号。

2.2 exit/_exit函数

return本身并不是用来结束进程的，return只有在main函数中，退出main函数的栈的时候整个进程会结束，但是如果return放在其他函数中，并不会结束进程。

#include <unistd.h>
void _exit(int status);
功能：用来结束一个进程，它是系统调用，退出进程的时候不会刷新缓冲区
参数：
    @status:进程退出的时候的状态值 （一般 0成功，1失败）
返回值:无

#include <stdlib.h>
void exit(int status);
功能：用来结束一个进程，它是库函数，退出进程的时候会刷新缓冲区
参数：
    @status:进程退出的时候的状态值 
    （一般 EXIT_SUCCESS 0成功，EXIT_FAILURE 1失败）
返回值:无

exit代码如下（示例）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)
    
int main(int argc,const char * argv[])
{
    pid_t pid;
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        printf("这是子进程\n");//打印
        printf("111111");//打印
        exit(EXIT_SUCCESS);
        printf("222222\n");//不打印
    }else{
        printf("这是父进程\n");
        while(1);
    }
    return 0;
}

结果展示：
在这里插入图片描述
_exit代码如下（示例）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)
    
int main(int argc,const char * argv[])
{
    pid_t pid;
    pid = fork();
    if(pid == -1){
        PRINT_ERR("fork error");
    }else if(pid == 0){
        printf("这是子进程\n");//打印
        printf("111111");//不打印
        _exit(EXIT_SUCCESS);
        printf("222222\n");//不打印
    }else{
        printf("这是父进程\n");
        while(1);
    }
    return 0;
}

结果展示：
在这里插入图片描述
总结：
从以上两个代码进行对比可知
exit在结束进程的时候会进行刷新缓冲区，而_exit则不会刷新缓冲区。

2.3 wait/waitpid函数

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

pid_t wait(int *wstatus);
功能：阻塞等待子进程结束，子进程结束的时候为子进程回收资源，并能够获取到子进程退出时候的状态
参数：
    @wstatus:接收子进程退出的状态 
        （其中8-15这8个bit位是子进程退出的状态）
        （其中0-6这7个bit为是信号号）
返回值：成功返回后回收掉资源的子进程的pid
       失败返回-1，置位错误码
        
 WIFEXITED(wstatus)   //如果子进程是通过exit/_exit/return main 这是正常结束程序的话，它返回真
                      //如果是信号杀死的进程，这个函数返回假
 WEXITSTATUS(wstatus) //获取进程退出的状态
 WIFSIGNALED(wstatus) //如果收到信号这个函数返回真
 WTERMSIG(wstatus)    //获取信号号    

pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：指定回收的子进程资源
参数：
    @pid:进程号
        > 0   回收这个指定pid进程的资源
        -1    回收任意子进程的资源  wait(NULL) == waitpid(-1,NULL,0);
         0    回收同组的任意子进程的资源
	    <-1   首先对这个值取绝对值，和这个绝对值同组的进程的资源都可以被回收         
 @wstatus:子进程退出的状态
 @options:标志位
	    0:阻塞回收资源
        WNOHANG：非阻塞回收资源
返回值：成功返回后回收掉资源的子进程的pid
       失败返回-1，置位错误码

wait代码如下（示例）：

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
    pid_t pid;

    pid = fork();
    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        printf("子进程\n"); //会显示
        printf("******************\n"); //会显示
        exit(25); //进程在这里已经结束了，刷新缓冲区
        
    } else {
        int status;
        printf("父进程\n");
        wait(&status);
        if (WIFEXITED(status)) { //子进程正常退出它为真
            printf("status = %d\n", WEXITSTATUS(status)); //打印子进程退出码 25
        } 
        if(WIFSIGNALED(status)){ //子进程被信号杀死它为真
            printf("signo = %d\n",WTERMSIG(status));  //打印信号号
        }
    }
    return 0;
}

结果展示：
在这里插入图片描述

waitpid代码如下（示例）：

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
     pid_t pid;

    pid = fork();
    if (pid == -1) {
        PRINT_ERR("fork error");
    } else if (pid == 0) {
        printf("子进程\n"); //会显示
        printf("******************\n"); //会显示
        sleep(3);
        exit(125); //进程在这里已经结束了，刷新缓冲区

    } else {
        int status;
        printf("父进程\n");
        waitpid(pid,NULL,0);
    }
    return 0;
}

结果展示：
在这里插入图片描述
总结：
常见的用法： wait(NULL);
wait(NULL) == waitpid(-1,NULL,0);

三、守护进程

3.1 守护进程的概念

守护进程是一个后台运行的进程，不依附当前的终端，随着系统启动而启动，随着系统的终止而终止，相当于window系统的服务。

3.2 守护进程的创建流程

1.创建出一个孤儿进程(不依赖于终端)
父进程结束子进程没被父进程回收

2.新建一个会话

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

pid_t setsid(void);
功能：创建一个新的会话，如果当前进程不是组长进程，
      创建的会话id，组id就是当前pid的值
参数：
    @无
返回值：成功返回pid，失败返回-1置位错误码

3.将当前进程对应的路径切换到根目录

#include <unistd.h>

int chdir(const char *path);
功能：切换路径的函数
参数：
    @path:路径
返回值：成功返回0，失败返回-1置位错误码

4.设置umask的值

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

mode_t umask(mode_t mask);
功能：设置掩码
参数：
    @mask:掩码的值
返回值：总是会成功，返回mask

5.进行文件描述重定向(脱离终端了，向终端上写东西会有问题)

#include <unistd.h>
dup相当于拷贝，光标互相影响。
int dup(int oldfd);
功能： dup函数的功能，拷贝fd,产生一个新的文件描述符nfd，
       nfd产生的原则最小为使用原则，fd和nfd都可以操作同一个
       文件，fd和nfd共用同一个光标
参数：
    @oldfd:旧的文件描述符
返回值：成功返回nfd,失败返回-1置位错误

重点看dup2
int dup2(int oldfd, int newfd);
功能：dup2函数相当于文件描述符的重定向，
     把newfd重定向到oldfd中了，以后向newfd写内容就是在向odlfd对应的文件中写内容
参数：
    @oldfd:旧文件描述符
    @newfd:新文件描述符
返回值：成功返回newfd,失败返回-1置位错误码

3.3 文件描述重定向实例

dup代码如下（示例）：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)

int main(int argc,const char * argv[])
{
    int fd,nfd;
    if((fd=open("./hi.txt",O_RDONLY))==-1)
    {
        PRINT_ERR("open file error");
    }
    if ((nfd = dup(fd)) == -1)
    {
        PRINT_ERR("dup fd error");
    }
    printf("fd=%d,nfd=%d\n",fd,nfd);
    char ch;
    lseek(fd,3,SEEK_SET);
    read(fd,&ch,1);
    printf("fd=%c\n",ch);
    read(nfd,&ch,1);
    printf("nfd=%c\n",ch);
    return 0;
}

结构展示：
在这里插入图片描述
总结：
dup函数的功能：拷贝fd，产生一个新的文件描述符nfd
nfd产生的原则最小为使用原则，fd和nfd都可以操作hello.txt文件，fd和nfd共用同一个光标

dup2代码如下（示例）：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PRINT_ERR(msg)                                      \
    do                                                      \
    {                                                       \
        printf("%s %s %d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)

int main(int argc, const char *argv[])
{
    int fd;
    if ((fd = open("./hi.txt", O_RDWR)) == -1)
    {
        PRINT_ERR("open file error");
    }
    if ((dup2(fd, 1)) == -1)
    {
        PRINT_ERR("dup fd error");
    }
    printf("---------------\n");

    return 0;
}

结构展示：
在这里插入图片描述
总结：
dup2函数相当于文件描述符的重定向，把文件描述符1(标准输出)重定向到fd中了，以后向1写内容就是在向fd对应的文件中写内容。

3.4 创建守护进程实例

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#define PRINT_ERR(msg) \
    do                 \
    {                  \
        printf("%s %s %d\n",__FILE__,__func__,__LINE__);      \
        perror(msg);   \
        return -1;     \
    } while (0)
int main(int argc,const char * argv[])
{
    pid_t pid;
    pid=fork();
    if(pid==-1)
    {
        PRINT_ERR("fork error");
    }
    else if(pid==0)
    {
        //1.创建孤儿进程
        //2.新建会话
        if(setsid()==-1)
        {
            PRINT_ERR("setsid error");
        }
        //3.切换到根目录
        if(chdir("/")==-1)
        {
            PRINT_ERR("chdir error");
        }
        //4.设置掩码
        umask(0);
        //5.关闭其他文件描述符
        //getdtablesize()获取系统中的最大文件描述符个数
        for (int i = 3; i <= getdtablesize(); i++) 
        {
            close(i);
        }
        //6.创建日志文件
        int fd;
        if((fd=open("my.log",O_RDWR|O_CREAT|O_APPEND,0666))==-1)
        {
            PRINT_ERR("open file error");
        }
        //7.文件描述符重定向
        dup2(fd,0);
        dup2(fd,1);
        dup2(fd,2);
        //8.开启自己的服务
        while(1)
        {
            write(fd,"我是夜猫徐\n",strlen("我是夜猫徐\n"));
            sleep(3);
        }
    }
    else
    {
        //创建孤儿进程需要退出父进程
        printf("父进程退出\n");
        exit(EXIT_SUCCESS);
    }
    return 0;
}

结果展示：
sudo ./a.out执行守护进程
在这里插入图片描述
cd /
在这里插入图片描述
vi my.log
在这里插入图片描述

总结

以上就是今天要讲的内容，本文以详细的代码示例介绍了进程相关函数的使用和守护进程的创建方法以父子进程共用光标的问题。如有错误请海涵可以私信博主，望有所收获。

夜猫徐
关注
专栏目录
linuxpv操作实验_Linux的进程的PV操作
weixin_39807352的博客
12-22 516
实验四Linux中进程的P,V操作实验目的：1、通过Linux下的进程基本操作，感性认识进程的互斥与同步。2、分析进程争用临界资源的现象，学会解决进程互斥的方法实验工具：一台装有WindowsXP操作系统的机器(安装了Linux虚拟系统)预备知识：1、PV操作的含义：PV操作由P操作原语和V操作原语组成(原语是不可中断的过程)，对信号量进行操作，具体定义如下：P(S)：①将信号量S的值减1，即S...
实验六 进程间通信（下）
LET ME FLY
04-20 2687
一、实验名称：实验六 进程间通信（下） 二、实验日期：2014/4/3 三、实验目的： l  通过实验理解共享内存通信 l  通过实验理解Linux信号量 l  了解Linux信号量与消息缓冲通信、内存共享通信之间的差异 l  布置作业1 四、实验的步骤和方法：   第六次小课进程间通信（下） 第一部分本周大课内容回顾   l  共享内存 l  L
实验5 利用信号量实现进程互斥
江南、寻你的博客
05-11 1816
【实验目的】 理解互斥概念、信号量机制及信号量结构； 掌握信号量的使用方法； 掌握PV操作的定义； 掌握PV操作实现互斥的方法。 【实验环境】VMware Workstation、RedHat 【实验步骤】 一、父子进程以非互斥方式共享访问临界资源 创建父子进程，父子进程共享一个临界资源,每个进程循环进入该临界区3次；父进程每次进入临界区后显示“parent in”，出临界区显示“parent out”。 子进程每次进入临界区后显示“child in”，出临界区显示“child out”。
Linux系统调用中的dup
y632481222的博客
03-09 383
n}\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\ndup2函数\ndup2函数是Linux系统API中的一员，它的作用是：将一个文件描述符指向的文件改为另一个文件描述符指向的文件。\n\n printf(\"fd的文件描述符是：%d，fd1的文件描述符是：%d\\n\",fd,fd1);
Linux——文件描述符（fd）与重定向、dup/dup2
weixin_61857742的博客
11-24 2669
操作系统根据调用的write的进程，通过task_struct结构体内部指针，找到files_struct，再通过files_struct内的fd_array指针数组，依照write传入的具体fd值（下标），找到对应的file结构体，就找到了相关文件。即标准输入、标准输出、标准错误。fd_array是一个数组，里面存放的是指针，每一个指针都指向一个file结构体。关闭一个文件时，fd_array中相关指针会指向空，当再其他文件打开时，按照从0开始寻找空指针的方式，找到该空指针，让其指向新的文件。
linux操作系统详解（Linux不再难懂）
08-15
Linux 操作系统详解 一、什么是 Linux 操作系统？ Linux 是一套免费使用和自由传播的类 Unix 操作系统，是一个基于 POSIX 和 UNIX 的多用户、多任务、支持多线程和多 CPU 的操作系统。它能运行主要的 UNIX 工具...
开发Linux操作系统后台服务进程详解
03-04
守护进程在Linux操作系统中扮演着重要的角色，它们作为后台服务，独立于控制终端，执行预设的任务或响应特定事件。常见的守护进程有inetd（Internet服务器）、httpd（Web服务器）、crond（作业规划进程）和lpd（打印...
Linux系统进程与磁盘管理详解
最新发布
09-20
内容概要：本文详细介绍了 Linux 系统下的进程管理和磁盘操作相关概念，以及常用的命令和应用场景。首先解释了进程的概念及其组成部分，接着详述了进程的状态及各种进程相关的命令（如ps、top等）。其次介绍文件描述...
【Linux操作系统】进程概念详解
m0_57018588的博客
03-20 2245
Linux操作系统，进程概念的讲解，冯诺依曼体系结构的理解，操作系统的概念，进程PCB，上下文数据，fork子进程，进程状态，进程优先级，环境变量。
最新整理Linux操作系统的进程管理详解.doc
02-27
在Linux操作系统中，进程管理是系统管理的核心组成部分，它涉及到如何创建、控制、调度和终止进程。本篇文章将深入解析Linux中的进程管理机制，并通过常用的命令工具如`ps`、`kill`、`pgrep`等来阐述其具体操作。 ...
从零开始的FPGA学习13-串口RS232详解
m0_49325388的博客
07-06 3614
从零开始的FPGA学习13-串口RS232详解原理RS232 通信协议工程整体框图串口数据接收模块波形图： 原理 RS232 通信协议 RS232 是 UART 的一种，没有时钟线，只有两根数据线，分别是 rx 和 tx，这两根线都是 1bit 位宽的。其中 rx 是接收数据的线，tx 是发送数据的线。 串口数据的发送与接收是基于帧结构的，即一帧一帧的发送与接收数据。每一帧除了中间包含 8bit 有效数据外，还在每一帧的开头都必须有一个起始位，且固定为 0；在每一帧的结束时也必须有一个停止位，且固定为 1
UART,SPI,IIC,RS232通信时序和规则
qq_45236840的博客
07-31 2462
一.UART 1.串口通信方式 2.串口通信步骤 注意： 串口协议规定，闲置时必须是高电平。 校验位：是使用奇偶校验。 停止位必须高电平。 一个0和多个0区分是靠掐时间。 异步通信：时钟各不一样。 二.IIC通信 注意： 发一个字节先发高位，再发低位， ...
Linux进程基本知识详解
weixin_59371851的博客
08-01 5757
哈喽，小伙伴们大家好，进程是操作系统中非常重要的一个概念，今天我将在linux系统下带大家了解进程的一些基本知识。事不宜迟，拿好小本本，我们赶紧开始吧~
Linux 进程编程入门
一口Linux的专栏
04-26 6378
关于进程和线程的关系，之前一口君写过这几篇文章，大家可以参考下。 本文从头带着大家一起学习Linux进程 《搞懂进程组、会话、控制终端关系，才能明白守护进程干嘛的？》 《[粉丝问答6]子进程进程的父进程关系》 《多线程详解，一篇文章彻底搞懂多线程中各个难点》 《一个多线程的简单例子让你看清线程调度的随机性》 Linux 进程篇 一、进程相关概念 了解进程的时候先来了解几个问题，明白以下问题，就懂了进程的概念 1.什么是程序，什么是进程，两者之间的区别？ 程序是静态的概念，gcc xxx.c -o pro
C中进程与线程的基本使用（结合代码讲解）
我要出家当道士
12-04 2663
具体介绍了linux环境下的进程与线程的实际使用，并结合 C 编写的代码进行讲解。文章中具体的说明了进程与线程的代码编程方法，进程与线程使用上的区别，线程中子线程释放的不同方式与区别，互斥锁的具体使用流程等等。
Linux C编程之八 文件操作相关函数
weixin_30828379的博客
05-14 192
一、整体大纲 st_mode整体介绍： st_mode详细介绍： 二、Linux文件操作相关函数 1. stat 作用：获得文件信息，也可以获取文件大小。 头文件 #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> 函数原型 ...
Linux系统编程——文件描述符的复制：dup()和dup2()
行者三个石的博客
07-20 505
原文链接：https://blog.csdn.net/tennysonsky/article/details/45870459 dup() 和 dup2() 是两个非常有用的系统调用，都是用来复制一个文件的描述符，使新的文件描述符也标识旧的文件描述符所标识的文件。 这个过程类似于现实生活中的配钥匙，钥匙相当于文件描述符，锁相当于文件，本来一个钥匙开一把锁，相当于，一个文件描述符对应一个文件，现在，我们去配钥匙，通过旧的钥匙复制了一把新的钥匙，这样的话，旧的钥匙和新的钥匙都能开启这把锁。对比于 dup()
Linux内核中的dup系统调用
qingkongyeyue的博客
03-28 1016
转自http://www.51testing.com/html/49/n-832449-2.html 2、内核初始化中的相关源码分析 static int init(void * unused) {  ...  if (sys_open((const char __user *) "/dev/console", O_RDWR, 0)   printk(KE
复制文件描述符(dup、dup2函数) 和 文件共享
Bit_Dong的博客
08-23 1269
所谓文件共享指的是同一个文件（譬如磁盘上的同一个文件，对应同一个 inode）被多个独立的读写体同时进行 IO 操作。多个独立的读写体大家可以将其简单地理解为对应于同一个文件的多个不同的文件描述符，譬如多次打开同一个文件所得到的多个不同的 fd，或使用 dup()（或 dup2）函数复制得到的多个不同的 fd 等。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夜猫徐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值