进程间通信—管道

Codex接入MATLAB MCP服务器:从配置到实战的全流程记录 模型上下文协议(MCP)为AI编程工具提供了连接外部软件的标准接口,就像给AI装上万能USB,使其能直接操控本地的复杂应用。在MATLAB这类闭源重型工具中,AI编程因许可证、工作区隔离而难以形成闭环,而通过官方MCP服务器,Codex能够调用MATLAB引擎执行代码、读取变量并返回图表结果,将代码生成与运行验证真正打通。这一方案在神经网络拟合、控制系统阶跃响应、图像处理以及hprof文件分析等工程场景中,能显著提升自动化效率。文章围绕Codex桌面版接入MATLAB MCP的全流程,涵盖环境准备、配置命令 阅读详情

1. 管道

Linux 使用fork创建子进程,父进程与子进程并不共享堆栈段和数据段,他们之间通过管道进行通信。管道是一种两个进程之间进行单向通信的机制。管道称为半双工管道。管道具有以下特点:

(1) 数据只能由一个进程流向另一个进程(一个读管道,一个写管道),如果需要进行全双工通信,需要建立两个管道。

(2) 管道只能用于父子进程或者兄弟进程间的通信。

除了以上的局限性,管道还有一些不足

(1) 管道没有名字(无名管道)。

(2) 管道的缓冲区大小是受限制的。

(3) 管道所传输的是无格式的字节流。

使用管道通信时,两端的进程向管道读写数据是通过创建管道时,系统设置的文件描述符。通过管道通信的两个进程,一个向管道写数据,每次写到管道缓冲区的末尾,一个从管道读数据,每次从管道缓冲区头读出数据。

管道使用pipe()函数创建,函数原型如下:

#include <unistd.h>
int pipe(int pipefd[2]);

管道的两端分别用描述符pipefd[0]和pipefd[1]来表示。但是两端的读写是固定的,即一端只能用于读,pipefd[0]。另一端只能用于写,pipefd[1]。

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
using namespace std;

static void signal_child(int siginfo) {

    int status;
    pid_t child;
    if (siginfo == SIGCHLD) {
        child = wait(&status);
        cout << "parent wait" << endl;
    }
}
int main(void) {

    int fd[2];
    pid_t pid;
    char c;

    pipe(fd);
    signal(SIGCHLD, signal_child);
    if ((pid = fork()) < 0) {
        cerr << "fork erro" << endl;
        exit(-1);
    }
    if (pid == 0) {
        close(fd[0]);
        write(fd[1], "C", 1);
    }
    else {
        //sleep(1);
        close(fd[1]);
        if (read(fd[0], &c, 1) < 0) {
            cerr << "parent read error" << endl;
            exit(-1);
        }
        cout << "parent read " << c << endl;
    }
    exit(0);
}

父子进程fork创建子进程,并将已打开的描述符复制到子进程中。


父进程需要关闭写管道,子进程需要关闭读管道。



由于子进程可能早于父进程先执行完毕,于是使用signal函数检测是否SIGCHLD信号,而该信号默认是忽略,因此需要添加一个信号处理函数,完成父进程对子进程的回收,避免产生僵尸进程。

2. FIFO

由于管道没有名字,它只能用于具有亲缘关系的进程间通信。使用有名管道FIFO,可以完成无亲缘关系的进程相互通信。FIFO提供了一个路径名与之关联,以FIFO的文件形式存在于文件系统中。  

FIFO特点如下:
(1) 可以使连个不具有亲缘关系的两个进程实现通信。

(2) 该管道可以通过路径名指出,并且在文件系统是可见的。在简历关到后,两个进程就可以把它当作文件,进行读写操作。

(3) FIFO严格遵循了先进先出规则。从缓冲区头部进行读操作,写操作将数据添加到缓冲区尾部。

FIFO使用mkfifo()函数创建,函数原型如下:

int mkfifo(const char* pathname, mode_t mode)

pathname为FIFO的路径名,mode为创建该文件当前用户,用户组,其他用户的读写可执行权限。如果当前路径已经存在了FIF0文件,返回EEXIST操作。

读管道程序mkfifo_r.cpp,将对管道的读操作设置为非阻塞。

#include <iostream>
#include <cstdio>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
using namespace std;

#define P_FIFO "/tmp/p_fifo"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)

int main(void) {

    char cache[100];
    int fd;

    if (access(P_FIFO, F_OK) == 0) {  // 判断文件是否存在 
        execlp("rm", "-f", P_FIFO, NULL);  // 存在并删除
        cout << "access" << endl;
    }
    
    if (mkfifo(P_FIFO, FILE_MODE) < 0) 
        cout << "Createnamed pipe failed" << endl;
 
    fd = open(P_FIFO, O_RDONLY | O_NONBLOCK);
    while(1) {
        memset(cache, 0, sizeof(cache)); // 每次清空缓冲区,避免与下一次接受的混乱
        if (read(fd, cache, 100) == 0) 
            cout << "no data" << endl;
        else 
            cout << "get data " << cache << endl;
        sleep(1);
    } 
    close(fd);
}

写操作mkfifo_w.cpp如下:

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

#define P_FIFO "/tmp/p_fifo"
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) 

int main(int argc, char** argv) {

    if (argc < 2) {
        cout << "usage : a.out data" << endl;
        return 0;
    }
    int fd;
    fd = open(P_FIFO, O_WRONLY | O_NONBLOCK);
    write(fd, argv[1], sizeof(argv[1]));
    close(fd);
}    

下面关于管道或者FIFO的读出与写入的若干规则

(1) 如果请求读出的数据量多于管道或FIFO中当前可用数据量,那么只返回这些可用的数据。

(2) 如果请求写入的数据的字节数小于或等于PIPE_BUF,那么write保证原子。如果有两个进程同时网一个管道或FIFO写,先写入第一个进程的数据,在写入第二个进程的数据,或者相反。不会出现两个进程的数据混杂在一起被写入到管道或FIFO。如果请求写入的字节大于PIPE_BUF,write操作不能保证原子。

(3)  O_NONBLOCK标志的设置对write操作的原子性并没有影响。原子性完全是由所请求字节数是否小于等于PIPE_BUF决定的。然而当一个管道或FIFO设置成非阻塞时,来自write的返回值取决于待写的字节数以及管道或FIFO当前可用空间大小。如果待写字节数小于等于PIPE_BUF:

a.  如果管道或FIFO有足够的字节存放请求的字节数,所有字节都写入。

b.  如果该管道或FIFO剩余的空间不足以存放请求的字节,那么立即返回一个EAGAIN错误。因为设置了O_NONBLOCK,进程不会被阻塞。但是内核无法在接受部分数据的同时仍保证write操作的原子性。,于是它必须返回一个错误。

如果待写的字节数大于PIPE_BUF:

a.  如果该管道或FIFO至少有1字节空间,那么内核写入该管道或FIFO能容纳数目的数据字节,同时返回写入的字节数。

b.  如果管道或者FIFO满了,那么立即返回一个EAGAIN错误。

(4) 如果向一没有为读打开的管道或FIFO写入时,那么内核将产生一个SIGPIPE信号,

让 ABAP 开发更聪明的搭档:SAP Joule for Developers 与 ABAP AI Capabilities 全面实战 摘要:SAP已将生成式AI集成到ABAP开发工具中,推出Joule for Developers功能。该功能直接嵌入Eclipse开发环境,提供代码解释、生成、测试构造和遗留代码迁移等辅助功能。Joule支持ABAP Cloud项目开发,能围绕当前开发对象提供上下文相关的建议,帮助开发者高效完成应用开发与迁移任务。启用该功能需升级ADT并获取相应许可,典型应用场景包括RAP应用构建和S/4HANA迁移中的代码重构。官方资源提供了多个实践案例,帮助开发者快速上手这一AI辅助开发功能。(149字) 阅读详情

相关推荐

555时基芯片的5种经典电路设计:从方波发生器到PWM调光实战

本文深入解析了555时基芯片的5种经典电路设计,从基础的无稳态方波发生器、单稳态触发器,到实用的占空比可调PWM信号源,并重点介绍了如何引入TVS保护电路增强系统鲁棒性。最后通过一个带保护的PWM LED调光台灯实战项目,综合展示了信号生成、功率驱动与电路保护的核心技术,是电子爱好者掌握模拟电路设计与应用的绝佳指南。

weixin_29207439的博客 495

linux进程间通信--命名管道

我们可以使用mkfifo(FIFO_FILE, 0666 | S_IFIFO)函数创建一个命名管道来实现进程间的通信。 在对管道进行读写之前需要open打开它,在打开的时候需指定打开的模式:1.O_RDONLY;2.O_WRONLY;3.O_RDWR 当我们单独使用O_RDONLY或者O_WRONLY方式打开管道时,默认是被阻塞的,除非另一个进程用相对应的方式打开同一管道,这时才能读...

235

WordPress主题开发实战:从零开始手把手教你创建自定义主题(含常用函数大全)

本文是一份WordPress主题开发实战指南,从零开始手把手教你创建自定义主题。内容涵盖主题核心文件结构、模板层级与循环机制、函数与钩子的运用,并附有详细的常用函数大全,帮助开发者彻底掌握主题开发的核心技能,实现从使用者到创造者的转变。

weixin_27943395的博客 257

IPC:匿名管道和命名管道

IPC:匿名管道和命名管道

591

数据库实验报告--MySQL

数据库完整版报告--MySQL 包括数据库创建、表的创建、视图以及授权和触发器的创建等内容,全是精华!看完点赞加收藏O(∩_∩)O~。

Mortalz7 4924

从软体机器人到鞋垫分析:Abaqus超弹性材料(Ogden模型)仿真配置全流程

本文详细介绍了Abaqus中Ogden模型在超弹性材料仿真中的应用全流程,涵盖从实验数据导入、参数拟合到模型构建与求解优化的关键步骤。特别针对鞋垫分析等生物力学场景,提供了单元选择、接触设置和并行计算等实用技巧,帮助工程师实现高精度仿真分析。

weixin_42525385的博客 400

linux中与文件相关的一些常量--文件类型

st_mode以及inode中的i_mode是用特征位来表示文件类型的,特征位的定义如下(8进制): S_IFMT 0170000 文件类型的位遮罩,也就是mask共18位,换成2进制00 1111 0000 0000 0000, S_IFSOCK 0140000 socket S_IFLNK 0120000 符号链接(symbolic link) S_IFREG...

jinking01的专栏 1236

电池管理系统(BMS)系列—状态估计之SOH

BMS系列文章,介绍了SOH估计

zxx52113140的博客 1849

理解文件的属性

ls command is one of the most frequently used command in Linux. I believe ls command is the first command you may use when you get into the command prompt of Linux Box. We usels command daily ba

u011279649的专栏 1039

FFmpeg魔改指南:让RTMP协议完美兼容H265的三种方法(含SRS适配技巧)

本文详细介绍了三种让RTMP协议兼容H265编码的FFmpeg魔改方案,包括基于官方补丁的标准改造、Intel的SVT-HEVC集成方案以及金山云的自定义扩展方案。文章重点解析了各方案的实现原理与适配技巧,并提供了在SRS 6.0服务器上进行深度配置和性能调优的完整实战指南,帮助开发者解决H265推流至传统RTMP服务器的兼容性问题。

weixin_29290947的博客 197

5.3-集群电源模式解析

DSU-120 DynamIQ™集群支持9种电源模式,包括正常运行(ON)、完全断电(OFF)、三种数据保持模式(FUNC_RET、FULL_RET、MEM_RET)、两种调试模拟模式(OFF_EMU、MEM_RET_EMU),以及系统恢复模式(WARM_RST、DBG_RECOV)。这些模式通过智能管理电源状态,在保持数据完整性的同时实现功耗优化,并为系统调试和故障恢复提供支持。不同模式在RAM保持、逻辑断电和调试能力方面各有侧重,满足从正常运行到深度调试等不同场景需求。

baron-周贺贺-代码改变世界ctw 117

进程间通信

背景 各进程的内存地址相互独立 进程间的通信需要有操作系统的支持. 共享存储 Linux系统如何实现共享存储: //注:通过“增加页表项/段表项”即可将同一片共享内存区映射到各个进程的地址空间中(第三章内容) // 通过 shm_open 系统调用,申请一片共享内存区 int shm_open(......); // 通过 mmap 系统调用,将共享内存区映射到进程自己的地址空间 void * mmap (......); 为避免出错,各个进程对共享空间的访问应该是互斥的。各个进程需要自己来实现

markey1的博客 2283

一桶令牌的时间账本:四类限流算法的边界推演与Guava RateLimiter源码精读

限流的难点不在背出算法名,而在算清每一笔账:按哪一秒计数、超额请求排队还是拒绝、空闲后能否突发、集群总量如何约束。本文在可复现的虚拟时间实验台上对比固定窗口、滑动窗口、漏桶与令牌桶,实测边界双倍突发与分桶滑动的真实上界,拆解Nginx limit_req的千分位记账与延迟机制,纠正Resilience4j常被误称漏桶的说法,并逐行精读Guava SmoothRateLimiter的预消费、懒惰补账与预热积分,复刻迷你限流器与其完成七万次零差异对账,最后给出集群配额、分层防护与参数确定的方法。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 86万+

进程间通信之管道

目录 前言 进程间通信的目的: 一.管道 1.1 匿名管道 1.1.1 匿名管道的使用场景 1.1.2 匿名管道实现通信的原理 1.1.3 怎么创建管道 1.1.4 怎么实现进程间通信 1.1.5 管道通信额四种情况 1.1.6 匿名管道的特征 1.2 命名管道 1.2.1 命名管道的原理 1.2.2 创...

weixin_57023347的博客 4302

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

【Linux】进程间通信——管道

【Linux】进程间通信——管道

weixin_60478154的博客 3734

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【Linux学习】进程间通信之 匿名管道 与 基于管道的进程池

进程间通信-1,进程间通信的目的,什么是管道,管道的原理,匿名管道,基于管道实现一个进程池。

2301_77509762的博客 4511

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

【Linux】基于管道进行进程间通信

介绍进程间通信的概念,认识基于管道进行进程间通信,认识匿名管道和命名管道,基于管道简单实现进程池!在进程池中加入日志函数!

YoungMLet的博客 3335

十一、进程间通信——管道

进程间通信(IPC,InterProcess Communication)是指在不同进程之间传播或交换信息。IPC的方式通常有管道(包括匿名管道和命名管道)、消息队列、信号量、共享内存等。进程间通信的本质就是,让不同的进程看到同一份资源。由于各个运行进程之间具有独立性,这个独立性主要体现在数据层面,而代码逻辑层面可以私有也可以公有(例如父子进程),因此各个进程之间要实现通信是非常困难的。

weixin_54447296的博客 3357

进程间通信——管道

文章目录进程间通信介绍进程间通信目的进程间通信发展进程间通信分类管道什么是管道匿名管道实例代码用fork来共享管道原理站在文件描述符角度-深度理解管道站在内核角度-管道本质管道读写规则命令行中的 `|` 管道中,进程间是兄弟关系管道特点命名管道创建一个命名管道匿名管道与命名管道的区别命名管道的打开规则用命名管道实现server&client通信 进程间通信介绍 进程间通信目的 数据传输:一个进程需要将它的数据发送给另一个进程 资源共享:多个进程之间共享同样的资源。 通知事件:一个进程需要向另一个

aaaaaaaWoLan的博客 2875

Linux 进程间通信(管道)

进程间通信、匿名管道、命名管道 ...

2201_75663820的博客 2735

深入了解linux系统—— 进程间通信之管道

进程间通信与管道 进程间通信(IPC)是指在同一台计算机或不同计算机上的进程之间进行数据交换的技术。由于进程具有独立性,必须通过操作系统提供的共享资源实现通信。常见的IPC方式包括管道、共享内存、消息队列、信号/信号量以及套接字。 管道分为匿名管道和命名管道。匿名管道通过pipe()系统调用创建,适用于父子进程间的单向通信。其本质是一个由操作系统维护的无名文件,父子进程通过继承文件描述符访问同一资源。代码示例展示了子进程写入、父进程读取的通信过程,验证了管道的数据传输功能。 管道通信存在四种典型情况:单向读

LH__1314的博客 1629

Linux之进程间通信(管道)

什么是管道?1、管道是Unix中最古老的进程间通信的形式。2、我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。管道只能进行单向通信,用来传输资源:数据。我们按下面的步骤来分析:1、首先,父进程分别以读和写的方式,打开了一个文件。2、然后,父进程fork创建了一个子进程,我们知道,子进程会继承父进程,指向同一个文件。3、我们规定,父进程对文件写入,子进程对文件读取。关闭父子进程各自不需要的功能。即:父进程关闭读的文件描述符,子进程关闭写的文件描述符。

zdlynj的博客 3006

【进程间通信】管道和命名管道

一个文件被打开了两次,因为他们打开的方式不一样,所以他们的标记为也一定不一样,它们在内存中的file结构体一定是存在两份的,但是文件的属性和操作集合都是一样的,所以文件属性和操作集合以及文件缓冲区是存在一份的,每个file结构体中会有一些基本的属性(读写位置等等),其次还会有一些指针,分别指向自己的属性和方法集合以及缓冲区。我们可以看到fd数字是一个文件描述符数组,所以Linux管道是复用了很多文件部分的代码的,所以在通信的时候很多还是文件的操作。管道是Unix中最古老的进程间通信的形式。

bushibrnxiaohaij的博客 1446

管道实现进程间通信之命名管道

管道通信之命名管道

xbhinsterest11的博客 1055

【进程间通信:管道】

Linux中管道如何构建?如何正常使用管道通信?以及使用管道通信时一些不容易被发现的Bug?

m0_68872612的博客 1316
上一篇: Select函数实现原理分析
下一篇: 生产者消费者同步
SegmentFault_
博客等级 码龄11年 6粉丝 26原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值