第二章 Linux多进程开发（3）

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

2.10 进程间通信简介

01 进程间通讯概念

  1. 进程是一个独立的资源分配单元，不同进程
    (这里所说的进程通常指的是用户进程)之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
  2. 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( IPC: Inter Processes Communication )。
  3. 进程间通信的目的:
    • 数据传输: 一个进程需要将它的数据发送给另一个进程
    • 通知事件: 一个进程需要向另一个或一组进程发送消息，通知它 (它们)发生了某种事件(如进程终止时要通知父进程)
    • 资源共享:多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。
    • 进程控制: 有些进程希望完全控制另一个进程的执行 (如 Debug 进程)，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

02 Linux进程间通信的方式

在这里插入图片描述

2.11 匿名管道概述

03匿名管道

在这里插入图片描述

在这里插入图片描述

04 管道的特点

  • 管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同
  • 管道拥有文件的特质 : 读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作
  • 一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少
  • 通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。
  • 在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的
  • 从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。
  • 匿名管道只能在具有公共祖先的进程 (父进程与子进程，或者两个兄弟进程，具有亲缘关系) 之间使用。

在这里插入图片描述

05 为什么可以使用管道进行进程间通信

在这里插入图片描述
父进程里面的5往管道里面写数据，子进程6就可以从管道里面读数据了
子进程里面的5往管道写数据，父进程里面的6就可以从管道里面读数据了
如此便实现了通过管道进行进程间通信

06管道的数据结构

在这里插入图片描述
数据结构：环形的队列
可以循环利用空间

07匿名管道的使用

//创建匿名管道
#include<unistd.h>
int pipe(int pipefd[2]);
//查看管道缓冲大小命令
ulimit -a
//查看管道缓冲大小函数
#include<unistd.h>
long fpathconf(int fd, int name);

2.12父子进程通过匿名管道通信


/*
    #include <unistd.h>
    int pipe(int pipefd[2]);
        功能：创建一个匿名管道，用来进程间通信。
        参数：int pipefd[2] 这个数组是一个传出参数。
            pipefd[0] 对应的是管道的读端
            pipefd[1] 对应的是管道的写端
        返回值：
            成功 0
            失败 -1

    管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞

    注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
*/

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret == -1){
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid>0){
        //父进程
        //从管道的读取端读取数据
        char buf[1024] = {0};
        int len = read(pipefd[0], buf,sizeof(buf));
        printf("parent recv: %s,pid : %d \n",buf,getpid());

    }else if(pid ==0){
        //子进程
        //写数据
        char *str = "hello,i am child";
        write(pipefd[1],str,strlen(str));
        
    }

    return 0;
}

在这里插入图片描述
循环发送接收数据

// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret == -1){
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid>0){
        //父进程
        //从管道的读取端读取数据
        printf("i am parent process , pid :%d, ppid : %d\n",getpid(),getppid());
        char buf[1024] = {0};
        while(1){
            //父子进程都可以读写，如果父进程先读后写，子进程必须先写后读，反过来也可以。
            //不能两个一起读或者两个一起写，这样会陷入死锁
            int len = read(pipefd[0], buf,sizeof(buf));
            printf("parent recv: %s,pid : %d \n",buf,getpid());

            //向管道写数据
            char *str = "hello,i am parent";
            write(pipefd[1],str,strlen(str));
            sleep(1);
        }
        

    }else if(pid ==0){
        //子进程
        //写数据
        printf("i am child process , pid :%d, ppid : %d\n",getpid(),getppid());
        char buf[1024] = {0};
        while(1){

            //向管道写数据
            char *str = "hello,i am child";
            write(pipefd[1],str,strlen(str));
            sleep(1);

            int len = read(pipefd[0], buf,sizeof(buf));
            printf("child recv: %s,pid : %d \n",buf,getpid());


        }
        
        
    }

    return 0;
}

管道查看缓冲区大小：ulimit -a
在这里插入图片描述
使用fpathconf
在这里插入图片描述

#include<unistd.h>
#include<sys/types.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main(){

    int pipefd[2];
    //int ret = pipe(pipefd);
    pipe(pipefd);

    //获取管道的大小
    long size = fpathconf(pipefd[0],_PC_PIPE_BUF);
    printf("pipe size : %ld \n", size);

    return 0;
}

在这里插入图片描述
和使用命令ulimit -a查出来的一样4k

2.13 匿名管道通信案例

上面写的代码有点小问题，将上述父进程里面的sleep注释掉，再运行，我们可以发现上面parent接受的信息来自自己，明显不合理。
在这里插入图片描述

解决：加入bzero（str，n）函数，能够将内存块（字符串）的前n个字节清零。但是没有解决问题。

其实我们真正开发的时候，管道的某一端要么是读端，要么是写端，不会读和写兼顾，代码改成如下方式，便可正常运行。
在这里插入图片描述

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

int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret == -1){
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid>0){
        //父进程
        //从管道的读取端读取数据
        printf("i am parent process , pid :%d, ppid : %d\n",getpid(),getppid());

        //关闭写端
        close(pipefd[1]);

        char buf[1024] = {0};
        while(1){
            //父子进程都可以读写，如果父进程先读后写，子进程必须先写后读，反过来也可以。
            //不能两个一起读或者两个一起写，这样会陷入死锁
            int len = read(pipefd[0], buf,sizeof(buf));
            printf("parent recv: %s,pid : %d \n",buf,getpid());

            //向管道写数据
            // char *str = "hello,i am parent";
            // write(pipefd[1],str,strlen(str));
            //sleep(1);
        }
        

    }else if(pid ==0){
        //子进程
        //写数据
        printf("i am child process , pid :%d, ppid : %d\n",getpid(),getppid());

        //关闭读端
        close(pipefd[0]);

        char buf[1024] = {0};
        while(1){

            //向管道写数据
            char *str = "hello,i am child";
            write(pipefd[1],str,strlen(str));
            //sleep(1);

            // int len = read(pipefd[0], buf,sizeof(buf));
            // printf("child recv: %s,pid : %d \n",buf,getpid());
            //能够将内存块（字符串）的前n个字节清零
            //bzero(buf,1024);


        }
        
        
    }

    return 0;
}

父子进程间通信案例

/*
    实现 ps aux | grep xxx 父子进程间通信

    子进程：ps aux,子进程结束后，将数据发送给父进程
    父进程：获取到数据，过滤

    pipe()
    execlp()
    子进程将标准输出 stdout_fileno 重定向到管道的写端。 dup2

*/

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

int main(){

    //创建管道（要在进程之前创建）
    int fd[2];
    int ret = pipe(fd);

    if(ret == -1){
        perror("pipe");
        exit(0);
    }

    //创建进程
    pid_t pid = fork();

    if(pid > 0){
        //父进程
        //关闭写端
        close(fd[1]);
        //从管道读取
        char buf[1024] = {0};
        
        int len = -1;
        while(( len = read(fd[0],buf,sizeof(buf)-1))>0 ){
            //过滤数据输出
            printf("%s",buf);
            //清空一下数组里面的内容
            memset(buf,0,1024);
        }
        wait(NULL);
        

    }else if(pid ==0){
        //子进程
        //关闭读端
        close(fd[0]);
        //写数据
        //文件描述符重定向 stdout_fileno -> fd[1]
        dup2(fd[1],STDOUT_FILENO);
        //执行ps aux 
        execlp("ps","ps","aux",NULL);
        perror("execlp");
        exit(0);


    }else{
        perror("fork");
        exit(0);
    }




    return 0;
}

2.14 管道的读写特点和管道设置为非阻塞

管道的读写特点
使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）
1、所有的指向管道写端的文件描述符都关闭（管道写端引用计数为0），有进程从管道的读端读数据，那么管道中剩余的数据被读取之后，再次read会返回0，就像读到文件末尾一样。
2、如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。
3、如果所有指向管道读端的文件描述符都关闭（管道的读端引用计数为0），这个时候有进程向管道中写数据，那么该进程会收到一个信号SIGPIPE，通常会导致进程异常终止。
4、如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置才能再次写入数据并返回。

总结：
	读管道：
		管道中有数据：
			read返回实际读到的字节数
		管道中无数据：
			写端被全部关闭：read返回0（相对于读到文件的末尾）
			写端没有完全关闭：read阻塞等待写入数据
	
	写管道：
		管道读端全部关闭：
			进程异常终止（进程收到SIGPIPE信号）
		管道读端没有全部关闭：
			管道已满：write阻塞
			管道没有满：write将数据写入，并返回实际写入的字节数


// 子进程发送数据给父进程，父进程读取到数据输出
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
/*

    设置管道非阻塞
    int flags = fcntl(fd[0],F_GETFL); //获取原来的flag
    flags |= O_NONBLOCK;  //修改flag的值
    fcntl(fd[0],F_SETFL,flags); //设置新的flag

*/
int main(){

    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret == -1){
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid>0){
        //父进程
        //从管道的读取端读取数据
        printf("i am parent process , pid :%d, ppid : %d\n",getpid(),getppid());

        //关闭写端
        close(pipefd[1]);

        char buf[1024] = {0};

        int flags = fcntl(pipefd[0],F_GETFL); //获取原来的flag
        flags |= O_NONBLOCK;  //修改flag的值
        fcntl(pipefd[0],F_SETFL,flags); //设置新的flag

        while(1){
            int len = read(pipefd[0], buf,sizeof(buf));
            printf("len: %d\n",len);
            printf("parent recv: %s,pid : %d \n",buf,getpid());
            memset(buf,0,1024);
            sleep(1);
        }
    }else if(pid ==0){
        //子进程
        //写数据
        printf("i am child process , pid :%d, ppid : %d\n",getpid(),getppid());

        //关闭读端
        close(pipefd[0]);

        char buf[1024] = {0};
        while(1){

            //向管道写数据
            char *str = "hello,i am child";
            write(pipefd[1],str,strlen(str));
            sleep(5);

        } 
    }

    return 0;
}

从运行结果我们可以看出刚开始管道没有内容，所以len返回-1，parent接受的内容为空。
后来child开始写入内容，父进程返回的长度为16，接收到内容，
child写入后休眠5秒，len返回-1，返回-1，返回-1
在这里插入图片描述
如果不设置阻塞，结果会如下所示
在这里插入图片描述

2.15 有名管道介绍及使用

  • 匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道 (FIFO)也叫命名管道、FIFO文件

  • 有名管道 (FIFO)不同于匿名管道之处在于它提供了一个路径名与之关联，以 FIFO的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过 FIFO不相关的进程也能交换数据

  • 一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/0系统调用了 (如read()、write()和close()) 。与管道一样，FIFO也有-个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。EIFO的名称也由此而来:先入先出。

  • 有名管道 (FIFO)和匿名管道 (pipe) 有一些特点是相同的，不一样的地方在于

    • 1、FIFO 在文件系统中作为一个特殊文件存在，但 FIFO中的内容却存放在内存中
    • 2、当使用 FIFO的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用
    • 3、FIFO 有名字，不相关的进程可以通过打开有名管道进行通信。

有名管道的使用

在这里插入图片描述

有名管道读写小例子

write.c

//向管道写数据
#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
int main(){

    //1、判断文件是否存在
    int ret = access("test",F_OK);
    if(ret == -1){
        printf("管道不存在，创建管道\n");

        //2、创建管道文件
        ret = mkfifo("test",0664);
        if(ret == -1){
            perror("mkfifo");
            return -1;
        }

        printf("管道创建成功。\n");
    }else{
        printf("管道文件已经存在。\n");
    }

    //3、打开管道（以只写的方式）
    int fd = open("test",O_WRONLY);
    if(fd == -1){
        perror("open");
        return -1;
    }

    //写数据
    for(int i=0;i<100;i++){
        char buf[1024];
        sprintf(buf,"hello,%d \n",i);
        printf("write data : %s\n",buf);
        write(fd,buf,strlen(buf));
        sleep(1);
    }
    close(fd);


    return 0;
}

read.c

//从管道读数据

#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
int main(){

    //打开文件
    int fd = open("test",O_RDONLY);
    if(fd == -1){
        perror("open");
        return -1;
    }

    //读取数据
    while(1){
        char buf[1024]={0};
        int len = read(fd,buf,sizeof(buf));
        if(len == 0){
            printf("写端断开连接了。。。\n");
            break;//使用break而不是return -1原因，如果使用return就直接退出程序，不会走后面的关闭操作了
        }
        printf("receive buf : %s \n",buf);
    }
    close(fd);

    return 0;
}

注：只执行其中一个函数，会处于阻塞，必须两个同时运行才可以

2.16 有名管道实现简单版聊天功能

在这里插入图片描述

chatA.c

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
int main(){

    //1、判断是否存在有名管道这个文件
    int ret = access("fifo1",F_OK);
    if(ret == -1){
        //不存在，创建该文件
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1",0664);
        if(ret == -1){
            perror("mkfifo");
            return -1;
        }
    }

    //判断fifo2
    ret = access("fifo2",F_OK);
    if(ret == -1){
        //不存在，创建该文件
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2",0664);
        if(ret == -1){
            perror("mkfifo");
            return -1;
        }
    }

    //2、以只写的方式打开管道fifo1
    int fdw = open("fifo1",O_WRONLY);
    if(fdw == -1){
        perror("open");
        return -1;
    }
    printf("打开fifo1管道成功，等待写入。。。。\n");

    //3、以只读的方式打开管道fifo2
    int fdr = open("fifo2",O_RDONLY);
    if(fdr == -1){
        perror("open");
        return -1;
    }
    printf("打开fifo2管道成功，等待读取数据。。。。\n");

    //4、循环的写读数据
    char buf[128];
    while(1){
        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        //write第三个参数 需要读取的数据量 要写128不能写strlen(buf),因为buf未复制，strlen(buf)=0
        int ret = write(fdw,buf,128);
        if(ret == -1){
            perror("write");
            return -1;
        }

        //5、读管道
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret <= 0){
            perror("read");
            return -1;
        }
        printf("buf: %s \n",buf);
    }

    //6、关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

chatB.c

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
int main(){

    //1、判断是否存在有名管道这个文件
    int ret = access("fifo1",F_OK);
    if(ret == -1){
        //不存在，创建该文件
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo1",0664);
        if(ret == -1){
            perror("mkfifo");
            return -1;
        }
    }

    //判断fifo2
    ret = access("fifo2",F_OK);
    if(ret == -1){
        //不存在，创建该文件
        printf("管道不存在，创建对应的有名管道\n");
        ret = mkfifo("fifo2",0664);
        if(ret == -1){
            perror("mkfifo");
            return -1;
        }
    }

    //2、以只读的方式打开管道fifo1
    int fdr = open("fifo1",O_RDONLY);
    if(fdr == -1){
        perror("open");
        return -1;
    }
    printf("打开fifo1管道成功，等待读取数据。。。。\n");

    //3、以只写的方式打开管道fifo2
    int fdw = open("fifo2",O_WRONLY);
    if(fdw == -1){
        perror("open");
        return -1;
    }
    printf("打开fifo2管道成功，等待写入数据。。。。\n");

    //4、循环的写读数据
    char buf[128];
    while(1){

        //5、读管道
        memset(buf,0,128);
        ret = read(fdr,buf,128);

        if(ret <= 0){
            perror("read");
            return -1;
        }
        printf("buf: %s \n",buf);

        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);


        //写数据
        ret = write(fdw,buf,128);
        if(ret == -1){
            perror("write");
            return -1;
        }

        
    }

    //6、关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

运行成功就能聊天，但是只能说一句回一句，并且a先说话

一直特立独行的橙
关注
Linux 多进程开发（上）
weixin_43412762的博客
03-11 1633
Linux 多进程开发 2.1 进程概述 2.2 进程状态转换 2.3 进程创建 2.4 exec 函数族 2.5 进程控制
c++webserver/第二章 多进程开发
公仔面
02-20 1919
1.Linux下的PCB 2.进程状态转换 1.三态 2.五态 3.ps命令. //静态查看进程 ps aux(查看当前全部进程) | ajx 4.top命令 //动态查看进程 5.kill命令 //杀死进程 kill -9/SIGKILL pid 强制杀死进程 killall -name 进程名 根据进程名杀死 6.进程关系 ppid 父进程 pid 当前进程 pgid 进程组号 7.进程函数 1.创建进程 pid_t fork(void); /* 创建一个进程 返回值
第六、七章 嵌入式Linux开发
wjrzm2001的博客
10-22 2901
嵌入式Linux
Linux应用开发【第四章】Linux进程间通信应用开发
韦东山嵌入式专栏
12-13 2233
文章目录4 Linux进程间通信应用开发4.1 初识进程4.1.1 进程的概念4.1.1.1 程序4.1.1.2 进程4.1.1.3 进程和程序的联系4.1.1.4 进程和程序的区别4.1.2 进程的操作（创建、结束、回收）4.1.2.1 创建进程4.1.2.2 结束进程4.1.2.3 回收进程4.2 进程为什么需要通信4.3 进程通信之管道通信4.3.1 无名管道4.3.1.1 特点4.3.1.2 创建无名管道4.3.1.3 读、写、关闭管道4.3.1.4 无名管道实现进程间通信4.3.2 有名管道4.3
Linux多进程开发
qq_53099212的博客
09-10 3160
Linux多进程开发
第二章 Linux基础网络配置及用户管理
yjun89的博客
06-24 4275
在开始熟悉Linux操作命令之前，我们必须先搭建好Linux操作系统环境，我们这里选用的是Linux的发行版本为Ubuntu，在安装好Ubuntu操作系统后，我们还需要在系统上进行一系列的初始操作，比如设置管理员密码、网络配置、基线加固等配置。
Linux系统-进程概念
~
03-03 7585
Linux进程概念零、前言一、冯诺依曼体系结构二、操作系统三、进程1、描述进程-PCB2、查看进程3、获取进程标示符4、创建进程-fork()5、进程状态6、僵尸进程7、孤儿进程8、进程优先级9、环境变量1)测试PATH2)测试HOME3)如何获取环境变量4)命令行变量 零、前言 本章主要讲解操作系统的一些基础概念知识，为进程的学习做铺垫 一、冯诺依曼体系结构 概念： 冯诺依曼体系结构规定了硬件上的数据流动，而大部分计算机都遵守冯诺依曼体系，如笔记本，服务器等 示图： 计算机基本硬件组成
《linux设备驱动开发详解》插图汇总
专注嵌入式软硬件开发。
10-25 3662
该文档所有插图均来自宋宝华老师的《linux设备驱动开发详解——-基于最新的linux4.0内核》一书。截图出来仅做平时网页查阅学习。
嵌入式开发高频面试题——第五章 Linux操作系统常见面试题（上）
Java、C语言、嵌入式开发，计算机科学与技术专业
09-06 1346
自旋锁（spinlock）：适用于短期的忙等待，不能在自旋锁保护的代码中调用可能引发睡眠的操作。信号量（semaphore）：用于长时间锁定，可以睡眠。互斥量（mutex）：用于长时间的锁定，允许睡眠。读写锁（rwlock）：允许多个读者同时访问，或者一个写者独占访问。：一种高效的读写锁实现，适合读多写少的场景。
【Linux内核设计思想】二、编译内核及内核开发的特点
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
02-05 2825
Linux内核设计思想第二篇，内核的编译以及内核开发的特点。
嵌入式Linux应用程序开发详解第7章进程控制开发_castle4qn_linux_
09-30
在多进程环境中，同步是确保数据一致性、避免竞争条件的关键。Linux提供了一些同步原语，如互斥锁（mutex）、信号量（semaphore）和条件变量（condition variable）。互斥锁用于保护共享资源的独占访问，信号量可以...
嵌入式Linux应用程序开发详解第8章进程间通信_linux_
10-02
在嵌入式Linux系统中，进程间通信（IPC，Inter-Process Communication）是多个独立运行的进程之间交换数据...通过深入学习第8章的内容，开发者将能够更好地应对多进程环境下的设计挑战，实现更高效、可靠的嵌入式应用。
嵌入式Linux应用程序开发第9章多线程编程
07-12
"嵌入式Linux应用程序开发第9章多线程编程" 本章主要讲解了 Linux 中的多线程编程，包括 Linux 线程的基本概念、创建及使用、属性设置、同步与互斥问题的处理等内容。通过学习本章，读者将掌握 Linux 中线程的基本...
Linux应用开发-第四章Linux的多进程开发（1）
Abcd_cnom的博客
07-06 1203
在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。子进程和父进程是运行在不同的内存空间中，它们内存空间的内容是一样的（文件读写和映射不会影响另外一个内存空间）注意：fork之后父子进程共享文件，fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。PCB(Processing Control Block)进程控制块，维护进程相关的信息
Linux下的systemd/service
最新发布
zxz_Fine的博客
11-05 284
开机自启任务
Linux：网络协议socket
Au_ust的博客
11-05 740
我们之前学的通信是本地进程间通信，如果我们想在网络间通信的话，就需要用到二者的ip地址，分别被称为源IP地址和目的IP地址，被存入ip数据包中，其次我们还需要遵循一些通信协议。TCP协议：传输层协议，有连接，可靠传输，面向字节流（无明确边界的字节序列），难UDP协议：传输层协议，无连接，不可靠传输，面向数据流（以数据包为单位），简单网络通信的本质也是进程间通信，你怎么知道你要和哪个进程通信？
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
m0_73093743的博客
11-02 447
只能建立一个对象的设计模式。
[linux 驱动]PWM子系统详解
weixin_49406449的博客
11-04 690
搜索“rockchip,rk3328-pwm”，发现在./drivers/pwm/pwm-rockchip.c 出现，所以 pwm6 的驱动是pwm-rockchip。任何 PWM 设备实例都可以被注册到 pwm_class 下，用户空间应用可以通过 /sys/class/pwm 访问这些设备，实现对 PWM 功能的控制。struct pwm_device *pwm: 这是指向 PWM 设备结构体的指针，该结构体是在调用 pwm_request 函数时获取的。这是指向该控制器的 PWM 通道的数组或链表。
Linux——Linux基础指令
辰多代码的博客
11-05 464
比 more 更强大的分页器，支持前后翻页和搜索。1：移动文件或目录（前提是目标文件或目录不存在）。：重命名文件或目录（前提是目标文件或目录存在）。:：显示系统上当前登录的用户及其相关信息。：显示网络连接、路由表和网络接口统计信息。：统计文件的行数、字数和字节数。：显示当前工作目录的完整路径。：列出目录中的文件和子目录。：显示或设置系统日期和时间。：在目录层次结构中搜索文件。：显示系统中正在运行的进程。：配置或显示网络接口信息。：显示当前用户的用户名。：更新现有文件的时间戳。：查找可执行文件的位置。
深入学习嵌入式Linux应用程序开发：第二章Shell命令
"嵌入式Linux应用程序开发详解的第二章主要涵盖了Linux的基础命令，包括Shell的概念、用户管理、系统相关、文件目录、打包压缩、文件比较合并、网络相关以及Linux的启动过程和INIT进程配置。此外，章节内容还强调了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值