【Linux 系统编程】IPC 进程间通信全解:管道、有名管道与信号

Linux进程间通信IPC的几种方式简介 Linux进程通信的源头       linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T(原为American Telephone & Telegraph的缩写,也是中文译名美国电话电报公司由来)的贝尔实验室及BSD(加州大学伯克利分校的伯克利软件发布中心)在进程间通信方面的侧重点有所不同。前者对Unix早期的进程间通信手段 阅读详情

📖 摘要:本文系统梳理 Linux 进程间通信(IPC)三大传统手段——无名管道、有名管道、信号。全文适合系统编程初学者与面试复习者阅读。

🛠 实验环境:Ubuntu 22.04 / Linux 6.x,gcc 11,x86_64。


〇、IPC 全景图:先见森林,再见树木 🗺

IPC(Inter-Process Communication,进程间通信) 是指不同进程之间传递数据或事件通知的机制。由于每个进程拥有独立的虚拟地址空间,进程间天然隔离,因此通信必须借助内核提供的桥梁。

原笔记将 IPC 分为三大类,整理如下表:

分类代表机制适用场景备注
① 古老的通信方式无名管道、有名管道、信号同一主机随 UNIX 诞生,POSIX 标准
② System V IPC 对象共享内存★、消息队列、信号量集同一主机以 key 标识内核 IPC 对象;另有 POSIX IPC 一族(shm_open/mq_open/sem_open)应予补充
③ socket 通信网络套接字、UNIX 域套接字主要用于不同主机🔧 原笔记只提"网络通信";注意 UNIX 域 socket 也可用于同一主机,且效率更高

💡 记忆口诀:“管道传字节,信号传事件,共享内存传大块,socket 跨主机。”

                ┌──────────────── 同一主机 ────────────────┐
                │  无名管道(亲缘)  有名管道(任意)  信号(通知) │
   进程 A ◄────►│  System V: 共享内存 / 消息队列 / 信号量集  │◄────► 进程 B
                │  POSIX:   shm / mq / sem                │
                └──────────────────────────────────────────┘
                ┌──────────────── 不同主机 ────────────────┐
   进程 A ◄────►│              socket(网络通信)            │◄────► 进程 B
                └──────────────────────────────────────────┘

一、无名管道(anonymous pipe)🚇

1.1 定义与适用范围

⚠️ 无名管道没有路径名,只能经由继承的文件描述符访问,因此通常用于亲缘进程(父子、兄弟)之间;但只要 fd 能被传递(如 fork() 继承、或经 UNIX 域 socket 的 SCM_RIGHTS ancillary message 传递),无亲缘关系的进程同样可以使用。

有名管道则相反:它在文件系统中有一个 FIFO 特殊文件节点(有路径名),因此可以用于同一主机上任意进程间通信。

1.2 操作流程与 API

四步流程:

  1. 创建并打开管道:pipe()
  2. 读管道:read()
  3. 写管道:write()
  4. 关闭管道:close()
int pipe(int pipefd[2]);
项目说明
功能创建并打开一个无名管道
参数 pipefd出参,返回两个文件描述符:pipefd[0] → 读端;pipefd[1] → 写端
返回值成功 0;失败 -1,并置 errno

💡 助记:“0 读 1 写”(0 对应 stdin 的"入",1 对应 stdout 的"出",与标准流方向一致)。

1.3 代码实例 1:父子进程单向通信

/* pipe_basic.c
 * 编译: gcc pipe_basic.c -o pipe_basic
 * 运行: ./pipe_basic
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    int pipefd[2];
    pid_t pid;
    char buf[128];

    if (pipe(pipefd) == -1) {          /* fork 之前创建,子进程才能继承 */
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) { perror("fork"); exit(EXIT_FAILURE); }

    if (pid == 0) {                    /* ===== 子进程:写端 ===== */
        close(pipefd[0]);              /* 关键:关闭不用的读端 */
        const char *msg = "Hello, 我是子进程!";
        if (write(pipefd[1], msg, strlen(msg) + 1) == -1)
            perror("write");
        close(pipefd[1]);              /* 写完关闭,父进程 read 才能收到 EOF */
        exit(EXIT_SUCCESS);
    }

    /* ===== 父进程:读端 ===== */
    close(pipefd[1]);                  /* 关键:关闭不用的写端 */
    ssize_t n = read(pipefd[0], buf, sizeof(buf));
    if (n > 0)
        printf("父进程收到 %zd 字节: %s\n", n, buf);
    else if (n == 0)
        printf("管道已空且写端全部关闭 (EOF)\n");
    close(pipefd[0]);
    waitpid(pid, NULL, 0);             /* 回收子进程,防止僵尸 */
    return 0;
}

⚠️ 工程要点:父子进程中"不用的那一端"必须关闭。这不仅是为了整洁——写端是否全部关闭直接决定读端能否返回 0(EOF),见 1.4 特性 ③。

1.4 管道的本质与四大特性

本质:管道是内核中的一段缓冲区(不是真实文件,只存在于内存),数据遵循 FIFO(先进先出) 字节流方式存取,无消息边界。

⚠️

概念数值(x86_64 Linux)含义
管道容量(capacity)默认 65536 B(64K)缓冲区总大小;Linux 2.6.11 起为 16 页;2.6.35 起可用 fcntl(fd, F_SETPIPE_SZ) 调整,上限见 /proc/sys/fs/pipe-max-size(默认 1MB),可用 F_GETPIPE_SZ 查询
PIPE_BUF(原子写上限)4096 B≤ PIPE_BUF 的写操作保证原子性(多进程写不会交错);超过则不保证原子

面试中"管道大小是多少"若只答 64K 而不提 PIPE_BUF,属于答了一半。

四大特性:

#特性触发条件表现
1写阻塞读写端都在,管道写满write() 阻塞,直到有读者腾出空间
2读阻塞读写端都在,管道为空read() 阻塞,直到有数据到来
3读返回 0写端全部关闭先把残留数据读完, thereafter read() 不再阻塞,返回 0(等同文件 EOF)
4管道破裂读端全部关闭仍去写内核向写进程发送 SIGPIPE,默认动作是终止进程;write() 若返回则返回 -1,errno = EPIPE

1.5 代码实例 2:一条程序亲眼验证特性 ③ 与 ④

/* pipe_flags_demo.c
 * 编译: gcc pipe_flags_demo.c -o pipe_flags_demo
 */
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    /* ---- 场景一:写端全部关闭 → 读返回 0 ---- */
    int p1[2];
    pipe(p1);
    if (fork() == 0) {
        close(p1[0]);
        write(p1[1], "EOF-DEMO", 8);
        close(p1[1]);          /* 子进程退出,写端消失 */
        _exit(0);
    }
    close(p1[1]);              /* 父进程只留读端 */
    char c;
    int n = 0, r;
    while ((r = read(p1[0], &c, 1)) > 0)
        n++;
    printf("[场景一] 读完 %d 字节残留数据后, read 返回 %d (EOF, 不再阻塞)\n", n, r);
    wait(NULL);

    /* ---- 场景二:无读端仍写 → SIGPIPE ---- */
    int p2[2];
    pipe(p2);
    pid_t pid = fork();
    if (pid == 0) {
        close(p2[0]);          /* 关闭读端,管道无读者 */
        write(p2[1], "x", 1);  /* 触发 SIGPIPE,进程被默认终止 */
        _exit(0);              /* 理论上走不到这里 */
    }
    close(p2[1]);
    int st;
    waitpid(pid, &st, 0);
    if (WIFSIGNALED(st))
        printf("[场景二] 子进程被信号 %d 终止 (13 = SIGPIPE, 管道破裂)\n",
               WTERMSIG(st));
    return 0;
}

预期输出:

[场景一] 读完 8 字节残留数据后, read 返回 0 (EOF, 不再阻塞)
[场景二] 子进程被信号 13 终止 (13 = SIGPIPE, 管道破裂)

二、有名管道(FIFO)📮

2.1 定义

有名管道以特殊文件(FIFO 文件) 形式存在于文件系统中,ls -l 查看时文件类型位为 p。它解决了无名管道"必须亲缘"的限制:同一主机上任意两个进程,只要知道 FIFO 路径即可通信。

2.2 操作流程

五步流程:

  1. 创建有名管道文件:mkfifo()(或 shell 命令 mkfifo myfifo)
  2. 打开管道文件:open()
  3. 写管道文件:write()
  4. 读管道文件:read()
  5. 关闭管道文件:close()
  6. 💡 补充:不再使用时 unlink() 删除 FIFO 节点,避免残留。
int mkfifo(const char *pathname, mode_t mode);   /* <sys/types.h> <sys/stat.h> */
/* 成功 0;失败 -1。若路径已存在 FIFO 则失败(errno=EEXIST),故常先 access() 判断 */

⚠️ open 的阻塞语义(高频考点):以 O_RDONLY 打开 FIFO 会阻塞直到有进程以写方式打开;以 O_WRONLY 打开会阻塞直到有进程以读方式打开。即"读写两端互相等待对方就位"。加 O_NONBLOCK 可解除:无读者时 O_WRONLY | O_NONBLOCK 直接失败返回 -1。

2.3 代码实例 3:两个无关进程通过 FIFO 对话

读端 fifo_read.c:

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

#define FIFO_PATH "/tmp/my_fifo"

int main(void)
{
    if (access(FIFO_PATH, F_OK) == -1)            /* 不存在才创建 */
        if (mkfifo(FIFO_PATH, 0666) == -1) { perror("mkfifo"); return 1; }

    printf("读端: 等待写端打开...\n");
    int fd = open(FIFO_PATH, O_RDONLY);           /* 阻塞,直到写端 open */
    if (fd == -1) { perror("open"); return 1; }

    char buf[128];
    ssize_t n;
    while ((n = read(fd, buf, sizeof(buf))) > 0)  /* 写端全关后 read 返回 0 退出 */
        printf("读端收到 %zd 字节: %s\n", n, buf);

    close(fd);
    unlink(FIFO_PATH);                            /* 清理 FIFO 节点 */
    return 0;
}

写端 fifo_write.c:

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

#define FIFO_PATH "/tmp/my_fifo"

int main(void)
{
    if (access(FIFO_PATH, F_OK) == -1)
        if (mkfifo(FIFO_PATH, 0666) == -1) { perror("mkfifo"); return 1; }

    printf("写端: 等待读端打开...\n");
    int fd = open(FIFO_PATH, O_WRONLY);           /* 阻塞,直到读端 open */
    if (fd == -1) { perror("open"); return 1; }

    const char *msg = "Hello, FIFO! 我们并无亲缘关系。";
    if (write(fd, msg, strlen(msg) + 1) == -1)
        perror("write");
    close(fd);
    return 0;
}
gcc fifo_read.c  -o fifo_read
gcc fifo_write.c -o fifo_write
./fifo_read &        # 先启动任一端均可,另一端 open 时互相等待
./fifo_write

2.4 无名 vs 有名管道对比表

维度无名管道 pipe有名管道 FIFO
文件系统节点无有(类型为 p)
通信对象通常亲缘进程同主机任意进程
创建 APIpipe()mkfifo() / 命令 mkfifo
打开语义创建即得两端 fdopen() 读写两端互相阻塞等待
生命周期随进程 fd,进程退出即失效节点持久存在,需 unlink 清理
数据流向半双工(字节流)半双工(字节流)

三、信号(signal)🚦

3.1 概念

信号是进程间的通知机制,不携带数据载荷,是一种异步通知机制,常被类比为"软中断"——它模拟了硬件中断的"打断—处理—恢复"模型,但完全由软件层面(内核)递送。

⚠️:

  1. sigqueue() 发送信号时可附带一个整型值(union sigval),配合 SA_SIGINFO 的三参处理函数读取;
  2. 实时信号(SIGRTMIN~SIGRTMAX)支持排队,同一信号多次发送不会合并;而标准信号不排队(_pending 期间重复发送只记一次,故又称"不可靠信号")。

3.2 信号一览表(x86_64,kill -l 输出)

 1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
 6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL  10) SIGUSR1
11) SIGSEGV  12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG  24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS  34) SIGRTMIN  ...  64) SIGRTMAX

⚠️ 表中 32、33 号"消失" 并非笔记笔误,而是 x86 Linux 上这两个编号被 NPTL 线程库内部占用(glibc 用作 SIGCANCEL、SIGSETXID),因此 kill -l 显示的实时信号从 34 开始。读到此处不必怀疑表格,但应知其所以然。

3.3 常用信号详解(含勘误)

信号编号默认动作典型产生方式与说明
SIGINT2终止Ctrl+C,interrupt 打断前台进程
SIGQUIT3终止+coreCtrl+\
SIGKILL9终止强制杀死进程,不可捕获、不可忽略、不可阻塞
SIGSEGV11终止+core段错误(非法内存访问)
SIGPIPE13终止管道破裂:向无读端的管道写数据
SIGALRM14终止定时器到时(alarm()/setitimer())。原笔记 ✅补充:可用 signal 捕获实现定时任务
SIGCHLD17忽略⚠️子进程终止、停止(stop)或恢复(continue) 时都会向父进程发送 SIGCHLD;默认动作是忽略。父进程常捕获它来及时 wait() 回收僵尸进程
SIGCONT18继续/忽略让停止态进程继续执行
SIGSTOP19停止强制暂停,不可捕获、不可忽略
SIGTSTP20停止⚠️ SIGTSTP 是来自终端的停止信号,Ctrl+Z 触发,使进程进入停止态;它是可被捕获/忽略的(区别于 SIGSTOP)。至于进程停止后是否转为后台运行,由作业控制命令 bg/fg 决定,与信号本身无关
SIGUSR1/210/12终止预留给程序员自定义使用的"用户信号",进程间轻量通知的常用选择

3.4 信号的三种处理方式与注册

处理方式对应实参语义
忽略SIG_IGN不处理(SIGKILL/SIGSTOP 除外)
缺省SIG_DFL按操作系统默认动作处理
捕获自定义函数指针信号到达时执行用户函数
sighandler_t signal(int signum, sighandler_t handler);
项目说明
功能注册(设置)一个信号的处理方式
signum要注册的信号编号
handlerSIG_IGN / SIG_DFL / 自定义函数
返回值⚠️成功时返回该信号上一次(注册之前)的处理函数指针(previous handler);失败返回 SIG_ERR。** 返回旧值是链式恢复旧行为的关键,切勿误解为返回刚传入的 handler

💡 进阶提示:signal() 语义在不同 UNIX 历史版本中存在差异(早期 BSD 语义会在进入处理函数时重置为默认),可移植、严谨的生产代码应使用 sigaction()。

3.5 代码实例 4:注册 SIGINT(异步信号安全写法)

/* sig_catch.c
 * 编译: gcc sig_catch.c -o sig_catch
 * 运行后按 3 次 Ctrl+C 退出
 */
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

static volatile sig_atomic_t g_cnt = 0;   /* volatile + sig_atomic_t 双保险 */

static void sig_handler(int signum)
{
    (void)signum;
    g_cnt++;               /* 处理函数内只做最简操作;printf 非异步信号安全 */
}

int main(void)
{
    sighandler_t old = signal(SIGINT, sig_handler);
    if (old == SIG_ERR) { perror("signal"); return 1; }

    /* 直观展示勘误⑧:old 是"旧"处理方式(首次为 SIG_DFL),而非新 handler */
    printf("PID=%d  旧handler=%p  新handler=%p\n",
           getpid(), (void *)old, (void *)sig_handler);
    printf("请按 Ctrl+C,按满 3 次自动退出\n");

    while (g_cnt < 3) {
        pause();           /* 挂起,等待任意信号唤醒 */
        printf("捕获到 SIGINT,累计 %d 次\n", g_cnt);
    }
    printf("正常退出\n");
    return 0;
}

⚠️ 严谨性说明:信号处理函数运行在"异步上下文",只能安全地调用异步信号安全(async-signal-safe) 函数(如 write、_exit),printf/malloc 均不在其列(若信号打断了同函数的执行,可能死锁或破坏状态)。上例采用"处理函数置标志位、主循环检查打印"的标准模式,这也是面试加分点。

3.6 代码实例 5:sigaction 现代写法(推荐)

#include <signal.h>
#include <string.h>

struct sigaction sa;
sa.sa_handler = sig_handler;      /* 或 sa.sa_sigaction 三参版本 + SA_SIGINFO */
sigemptyset(&sa.sa_mask);         /* 处理期间不额外阻塞其他信号 */
sa.sa_flags = SA_RESTART;         /* 自动重启被信号打断的慢系统调用 */
if (sigaction(SIGINT, &sa, NULL) == -1) { perror("sigaction"); }

3.7 代码实例 6:父子进程用 SIGUSR1 “互传接力棒”

/* sig_pingpong.c
 * 编译: gcc sig_pingpong.c -o sig_pingpong
 * 演示信号作为"事件通知"在进程间的使用
 */
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

static volatile sig_atomic_t g_flag = 0;
static void on_usr1(int sig) { (void)sig; g_flag = 1; }

int main(void)
{
    pid_t pid = fork();
    if (pid == 0) {                          /* ===== 子进程 ===== */
        signal(SIGUSR1, on_usr1);
        kill(getppid(), SIGUSR1);            /* 先通知父进程:我已就绪 */
        for (int i = 0; i < 3; i++) {
            while (!g_flag) pause();
            g_flag = 0;
            printf("[子] 第 %d 次接到接力棒\n", i + 1);
            kill(getppid(), SIGUSR1);        /* 回传给父 */
        }
        _exit(0);
    }

    /* ===== 父进程 ===== */
    signal(SIGUSR1, on_usr1);
    while (!g_flag) pause();                 /* 等待子进程就绪,避免竞态 */
    g_flag = 0;
    for (int i = 0; i < 3; i++) {
        printf("[父] 第 %d 次发出接力棒\n", i + 1);
        kill(pid, SIGUSR1);
        while (!g_flag) pause();
        g_flag = 0;
    }
    waitpid(pid, NULL, 0);
    return 0;
}

💡 注意代码中"子进程先注册、再发就绪信号;父进程等就绪后才开始发棒"的顺序——若父进程抢先 kill,子进程尚未注册捕获函数,SIGUSR1 的默认动作是终止进程,程序会莫名夭折。这类竞态是信号编程的典型坑。


四、原笔记勘误与不严谨表述汇总 📌

#原笔记表述性质修正 / 严谨表述
①“interprocess communicate”英文标注不规范Inter-Process Communication
②无名管道"只能用在具有亲缘关系的进程间"过于绝对无路径名、靠继承 fd 访问,故通常用于亲缘进程;fd 可传递时非亲缘亦可
③"默认 64K 字节"未区分概念易误导64K 是容量(可用 F_SETPIPE_SZ 调整);PIPE_BUF=4096 才是原子写上限,二者不可混
④信号"不携带数据"不完整标准信号不携带;sigqueue() 可附带整型值;实时信号支持排队
⑤信号表 31 直接跳到 34缺说明(非错)32/33 被 NPTL 线程库占用(SIGCANCEL/SIGSETXID)
⑥SIGCHLD “子进程结束时发送给父进程”不完整子进程终止/停止/恢复均产生;默认动作为忽略
⑦SIGTSTP 解释混入"后台进程"表述混乱终端停止信号(Ctrl+Z),可捕获/忽略;前后台切换归作业控制(bg/fg)管
⑧signal() 返回值"成功:handler"错误成功返回注册前的旧处理函数指针;失败返回 SIG_ERR

五、高频面试题自测 ✅

  1. 管道大小是多少?write() 一定原子吗?——答:容量默认 64K 可调;≤ PIPE_BUF(4096) 才保证原子。
  2. 读端全关后写管道会发生什么?——答:SIGPIPE,默认终止进程,errno=EPIPE。
  3. signal() 的返回值是什么?——答:旧的处理方式。
  4. 哪两个信号不可捕获不可忽略?——答:SIGKILL、SIGSTOP。
  5. 如何避免僵尸进程?——答:捕获 SIGCHLD 后 wait/waitpid,或 signal(SIGCHLD, SIG_IGN)(POSIX 语义下由内核回收)。
  6. 有名管道 open() 为什么阻塞?——答:读写两端互相等待对方就位,O_NONBLOCK 可改变语义。

六、结语 🏁

管道解决"传字节",信号解决"传事件",二者与 System V/POSIX IPC、socket 一起构成了 Linux 进程协作的完整版图。学习 IPC 时,把每条特性都对应到一段可运行的代码上(如本文的六个实例),远比背诵表格牢固。

若本文对你的复习有帮助,欢迎点赞、收藏、评论三连 🙌 如有疏漏,评论区指正。

【Linux系统编程】进程间通信(IPC) 【Linux系统编程】进程间通信(IPC)(超详细) 阅读详情

相关推荐

蓝牙Mesh协议一基本概念

前言 蓝牙SIG联盟在2017年发布了蓝牙Mesh1.0的协议规格,基于低功耗广播包来实现的多对多的通信技术,Mesh协议建立在BLE的物理层和链路层上,所以也可以和BLE的蓝牙进行通信 本章主要介绍蓝牙Mesh的基本概念和协议中的层级结构,也是参考网上的资料,如有异议,欢迎留言指正 基本概念 广播和洪泛 蓝牙Mesh技术是基于BLE的广播报文来实现的,是一种洪泛的消息传输机制,Mesh网络的节点间通过3个广播信道进行通信。当蓝牙Mesh网络中的节点收到消息后会转发这条消息,大大增加了网络的覆盖范围;但

9753

有名管道和无名管道

1.  (1)数据传输     一个进程需要将它的数据发送给另一个进程 (2)资源共享     多个进程之间共享同样的资源 (3)通知事件     一个进程需要向另一个或一组进程发送消息,通知它们发生了某种事件 (4)进程控制     有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有操作,并能够及时知道它的状态改变 2.发展 L

zm1_1zm 1万+

用Coze平台30分钟打造《花光10亿》小游戏:零代码AI开发实战

本文详细介绍了如何利用字节跳动推出的Coze平台,在30分钟内零代码开发一款名为《花光10亿》的AI小游戏。通过配置提示词、集成图像生成插件、构建自动化工作流以及使用数据库功能,即使没有编程基础的用户也能快速将创意转化为可交互的智能应用,体验AI开发的便捷与高效。

weixin_29313547的博客 209

34、 Linux IPC进程间通信:无名管道(Pipe) 和有名管道(FIFO)

本文介绍了Linux系统中两种进程间通信(IPC)方式:无名管道(Pipe)和有名管道(FIFO)。重点分析了无名管道的特性与实现机制,包括: 无名管道仅适用于亲缘进程通信,通过pipe()创建读写描述符; 管道具有半双工、顺序读写、阻塞等特性,默认缓冲区64KB; 演示了读阻塞、写阻塞和管道破裂三种典型场景的代码实现; 当读端关闭后继续写入会导致管道破裂(SIGPIPE信号终止写进程)。 无名管道作为最基础的IPC方式,虽然功能有限,但在父子进程协同工作中仍具有重要价值。理解其底层机制有助于开发可靠的进程

weixin_46607526的博客 1208

Matlab机械臂建模:机器人工具箱的使用&&导入自己的机械臂模型

本文主要介绍如何在matlab中建立机械臂模型(前提要下载了Robotics Toolbox机器人工具箱~),并进行基于正逆运动学计算的轨迹运动。对于已有的Solidworks机械臂三维模型,如何导入Matlab,并对其进行运动控制。

m0_46427461的博客 5万+

MLC-LLM框架在安卓设备上的模型编译与部署全流程解析

本文详细解析了如何利用MLC-LLM框架在安卓设备上编译与部署大语言模型。从环境搭建、模型获取与量化编译,到最终的安卓应用打包与调试,提供了完整的实战流程。重点介绍了如何通过MLC-LLM将大型模型优化为适合移动端运行的格式,实现本地、低延迟、隐私安全的AI应用部署。

weixin_29251337的博客 475

Linux进程间通信:管道与信号

本文介绍了嵌入式Linux开发中两种核心的进程间通信(IPC)方式:管道和信号。管道分为无名管道(用于亲缘进程)和有名管道(通过FIFO文件实现),适用于持续性数据流传输;信号则提供异步事件通知机制,适合简单控制。文章通过具体代码示例演示了父子进程通过无名管道通信、独立进程通过有名管道交互,以及信号处理的实际应用。这两种IPC机制各有特点:管道适合大量数据传输,信号则适合轻量级通知。在实际嵌入式系统中,常将二者结合使用,形成高效的多进程协同方案。

2302_80623234的博客 915

折叠式共源共栅运放设计实战:Cadence Virtuoso完整流程

在模拟IC设计中,运放是信号链的核心模块,而共源共栅结构凭借高增益、高输出阻抗的特性,成为高性能放大器的经典选择。其中,折叠式共源共栅运放通过电流折叠技术,在不牺牲增益的前提下显著改善输出摆幅与输入共模范围,尤其适合1.8V低压工艺下的高动态范围应用。本文从共源共栅放大器的基本原理出发,解析其技术价值与典型应用场景,并基于0.18μm工艺,系统展示如何利用Cadence Virtuoso完成从电路结构分析、管子尺寸推导到原理图绘制、仿真调试的完整设计闭环。内容涵盖增益、带宽、相位裕度等关键指标的优化方法,以

weixin_34277853的博客 376

进程间通信-无名管道,有名管道,信号

目录进程进程间通信 进程 (一) 进程间通信 (一)进程间通信几种方式 (1)管道 (2)信号

蒲公英的诗与远方 1123

【Pytorch】DCGAN实战(三):二次元动漫头像生成

文章目录1.实现效果2.环境配置2.1Python2.2Pytorch、CUDA2.3Python IDE3.具体实现3.1数据预处理(data.py)(1)导入包(2)定义数据类3.2模型Generator,Discriminator,权重初始化(model.py)(1)导入包(2)Generator(3)Discriminator(4)权重初始化3.3网络训练(net.py)(1)导入包(2)创建类3.4 主函数(main.py)(1)导入文件(2)定义超参数(3)实例化(4)进行训练4.训练过程4.1

qq_44031210的博客 4922

34、婴儿监视器应用开发指南

本文详细介绍了基于 ESP32 和 Edge Impulse 开发婴儿监视器应用的全过程,涵盖音频处理、机器学习推理、ESP RainMaker 平台集成以及内存监控等功能。通过实现 AppAudio、AppRmaker 和 AppMem 三个核心类,完成了婴儿哭声的实时检测与远程通知,并通过合理的内存管理优化,有效节省了 ESP32 的内部 RAM 资源。文章还提供了完整的代码示例和配置说明,适用于物联网和嵌入式 AI 应用开发爱好者参考学习。

python9snake的博客 96

Linux-进程间通信-有名管道-无名管道-信号量

open()必须两个进程同时进行,而且必须是一读一写 (管道 满 write阻塞 管道 空 read阻塞)无名管道主要用于父子间进程的通信--->使用接口pipe(int fd[2]) //fd[0]存放读端 fd[1]中存放写端。4.正常创建的文件是在磁盘上存储,速度比较慢,在管道创建文件实际是在内核上,内存调用速度快。半双工-->通信方式可以是A到B也可以是B到A,但在某一时刻只能是一个方向。通信间进程(IPC机制):管道,信号量,共享内存,消息队列,套接字。

XiaoBinbest的博客 1034

YOLOv12创新改进 | 全网独家创新篇、小目标检测改进 | AAAI 2025 | 引入HS-FPN中的HFP和SDP创新点,从频域增强小目标特征,淘汰FPN进行升级,助力YOLOv12有效涨点

本文提出了HS-FPN(高频和空间感知特征金字塔网络),通过HFP(高频感知)模块增强小目标特征,SDP(空间依赖感知)模块捕获像素间空间依赖关系。实验在AI-TOD等小目标数据集上验证了该方法的有效性,相比FPN显著提升检测性能。文章详细介绍了HS-FPN的网络结构、核心代码实现及在YOLOv12中的应用方法,并提供多种改进版本的yaml配置文件,为小目标检测任务提供了有效的解决方案。

Ai缝合怪、助力小伙伴高效发论文 344

Linux系统编程——IPC进程间通信:管道

本文介绍了Linux系统中两种基础的进程间通信(IPC)方式:无名管道(pipe)和有名管道(FIFO)。无名管道仅支持具有亲缘关系的进程间通信,通过pipe()函数创建,随进程退出自动释放;有名管道则突破了亲缘关系限制,通过mkfifo()创建,在文件系统中可见,需要手动清理。两者均为半双工、基于队列的特殊文件,不支持定位操作。文章详细阐述了它们的核心特性、读写行为规则、编程顺序及核心函数,并通过示例代码演示了具体实现方法,最后对比了两者的主要差异,为Linux IPC编程提供了实用指导。

lufrednow_的博客 768

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Linux:进程间通信IPC(interprocess)——管道、信号

Linux进程间通信(IPC)方式主要包括三类:1)基础IPC如管道(无名管道用于亲缘进程,有名管道支持任意进程)和信号;2)System V IPC对象如共享内存和信号量;3)支持网络通信的socket。管道通过内核队列实现数据传递,具有阻塞特性;信号用于异步通知事件,包含64种类型,其中SIGKILL(9)和SIGSTOP(19)不可屏蔽。关键区别在于:管道传输数据内容,信号仅作事件通知。文中详细介绍了管道创建函数pipe/mkfifo、信号处理函数signal/kill/alarm等接口的使用方法及特

2301_81830380的博客 857

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

嵌入式LInux--进程间通信介绍、管道、信号

Linux作为多任务系统,能够同时运行几个进程。通常,各个进程必须尽可能保持独立,避免彼此干扰。这对于保护数据和确保系统稳定性都很有必要。但有时候,应用程序必须彼此通信。;;;。,必须防止这种情况。因此内核不仅提供了共享数据的机制,同样提供了协调对数据访问的机制。内核仍然采用了来自System V的机制。用户空间应用程序和内核自身都需要保护资源,特别是后者。在SMP系统上,各个CPU可能同时处于核心态,在理论上可以操作所有现存的数据结构。为阻止CPU彼此干扰,需要通过锁保护内核的某些范围。

张哈哈的博客 1217

uc_12_进程间通信IPC_有名管道_无名管道

进程间通信 有名管道 无名管道 管道符 内存壁垒

wwwwood的博客 1102

进程间通信、无名管道、有名管道

线程通信通过全局变量即可。进程间通信是相互独立的,但是所有进程都共用一份内核空间,所以进程和进程之间的通信可以通过内核去进行。

2303_78438820的博客 1198

linux高级编程(IPC进程间通信)

1、古老的通信方式无名管道 有名管道 信号2、IPC对象通信消息队列(用的相对少,这里不讨论)共享内存信号量集3、socket通信网络通信线程信号,posix() sem_init(信号量)特例:古老的通信方式中信号是唯一的异步通信所有的通信方式中共享内存是唯一的最高效。

qq_54094530的博客 1107

【Linux】匿名管道pipe和有名管道fifo详解

进程间通信IPC 进程间通信是操作系统提供的一种机制,用于多个进程之间进行数据通信,实现资源协调与共享。 IPC:Interprocess Communication 进程间通信 例如在单任务处理器中,多个进程之间就依靠着进程间通信 调度CPU,使得多个进程高效率并发执行 Linux中进程间通信的方式: 管道:半双工通信方式,分为匿名管道(pipe)和有名管道(fifo),用于具有亲缘关系之间的进程通信 消息队列:进程利用消息队列通过发送和接收消息进行通信 信号:主要用于消息的通知和进程控制,不能传

努力让自己的能力配得上梦想. 1669

【Linux系统编程(IPC)】无名管道,命名管道,消息队列,共享内存,信号,信号量,Socket

进程间通信:IPC(InterProcess Communication)微信的聊天也是属于进程间通信,是基于网络的。本篇的进程间通信基于单机的。A进程和B进程之间创建一个通道,A和B都能从中读写数据,这是真正意义上的进程间通信。进程间通信:● 单机版:A和B跑在同一个PC上● 多机版:A和B在不同的PC上(基于网络通信)进程间通信(IPC)的方式有:● 管道(无名管道和命名管道)● 消息队列● 信号量● 共享内存● Socket● Streams。

路人的博客 1208

Linux 进程间通信:有名管道与无名管道详解及实践

有名管道(也称为 FIFO,First In First Out)是一种存在于文件系统中的管道文件可用于任意进程间的通信(无需父子 / 亲缘关系);以文件形式存在于磁盘(但实际数据存储在内存缓冲区);传输效率较高,但不保证数据的可靠传输(无原子性、重传等机制);遵循 “先进先出” 的字节流传输规则。无名管道是一种仅存在于内存中的管道仅能用于父子进程(或亲缘进程)间通信(依赖 fork 传递文件描述符);无需手动删除,进程结束后自动释放;读端(pipefd [0])和。

2302_81526349的博客 948

Linux进程间通信:无名管道与有名管道的原理与实践

在多任务操作系统中,进程间通信(IPC)是实现协作的核心机制。三、有名管道(Named Pipe / FIFO):跨进程的公共通道。管道的本质:一种基于文件描述符的通信方式,实现数据流动的“桥梁”。二、无名管道(Anonymous Pipe):父子进程的私有通道。核心分类:无名管道(匿名管道)与有名管道(命名管道)。一、引言:为什么需要进程间通信(IPC)?四、无名管道 vs 有名管道:对比与选型。代码示例:父子进程通信。代码示例:双向通信实现。五、常见问题与调试技巧。非阻塞模式下的竞态条件。

2301_80067496的博客 943

Linux系统编程4(进程间通信IPC)

(1)简单本地亲缘进程通信:优先选无名管道(实现简单,无需额外文件)(2)简单本地任意进程通信:选有名管道(无需亲缘关系,实现简单)(3)异步通知/事件触发:选信号(适用于快速通知,如异常处理)(4)高效本地数据共享:选共享内存+信号量(效率最高,需配合同步机制)(5)跨主机/网络通信:选Socket(通用性强,支持TCP/UDP)

qq_45021186的博客 793

无名管道、有名管道、信号、信号处理

进程间通信(IPC)是指在不同进程之间交换数据或信息的机制。消息队列允许一个或多个进程向队列中写入消息,同时允许一个或多个进程读取这些消息。提供高效的进程间通信,但需要同步机制(如互斥锁)来避免数据竞争。只能用于具有亲缘关系的进程间通信(如父子进程)。提供一种在不同主机上的进程之间进行通信的机制。提供一种同步机制,用于控制对共享资源的访问。(20):挂起进程(如 Ctrl+Z)。(2):中断信号(如 Ctrl+C)。(3):退出信号(如 Ctrl+\)。提供高效的进程间通信,但需要同步机制。

m0_71564676的博客 970

嵌入式解谜日志之Linux操作系统—进程间的通信(IPC):无名管道,有名管道,信号通信5

在操作系统中,是指不同进程之间传递数据、共享资源或协调行为的机制。由于进程拥有独立的内存空间(隔离性),不能直接访问彼此的内存,因此需要操作系统提供专门的 IPC 机制。

2201_75637288的博客 1143
上一篇: Linux系统编程进阶:进程回收、程序替换与多线程并发模型
下一篇: Linux进程间通信:信号、消息队列、共享内存完整笔记
Horn Still Sounds
博客等级 码龄5年 10粉丝 46原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址