精华内容
下载资源
问答
  • Linux进程间通信

    2021-05-10 16:40:52
    system V IPC机制下的共享内存本质是一段特殊的内存区域,进程间需要共享的数据被放在该共享内存区域中,所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。这样一个使用共享内存的进程可以...

    66b52468c121889b900d4956032f1009.png

    8种机械键盘轴体对比

    本人程序员,要买一个写代码的键盘,请问红轴和茶轴怎么选?

    system V IPC机制下的共享内存本质是一段特殊的内存区域,进程间需要共享的数据被放在该共享内存区域中,所有需要访问该共享区域的进程都要把该共享区域映射到本进程的地址空间中去。这样一个使用共享内存的进程可以将信息写入该空间,而另一个使用共享内存的进程又可以通过简单的内存读操作获取刚才写入的信息,使得两个不同进程之间进行了一次信息交换,从而实现进程间的通信。

    共享内存允许一个或多个进程通过同时出现在它们的虚拟地址空间的内存进行通信,而这块虚拟内存的页面被每个共享进程的页表条目所引用,同时并不需要在所有进程的虚拟内存都有相同的地址。

    进程对象对于共享内存的访问通过key(键)来控制,同时通过key进行访问权限的检查。

    二.共享内存的使用

    在Linux中提供了一组函数接口用于使用共享内存,它们声明在头文件 sys/shm.h中。查看共享内存ipcs #查看共享内存

    ipcrm -m shmid #删除共享内存相应的函数为#include

    #include

    #include

    key_t ftok(const char *pathname, int proj_id);

    int shmget(key_t key, int size, int shmflg);

    void *shmat(int shmid, const void *shmaddr, int shmflg);

    int shmdt(const void *shmaddr);

    int shmctl(int shmid, int cmd, struct shmid_ds *buf);

    2.1.ftok函数key_t ftok(const char *pathname, int proj_id);

    函数ftok用于创建一个关键字,可以用该关键字关联一个共享内存段。参数pathname为一个全路径文件名,并且该文件必须可访问。

    参数proj_id通常传入一非0字符

    通过pathname和proj_id组合可以创建唯一的key

    如果调用成功,返回一关键字,否则返回-1

    2.2.shmget函数int shmget(key_t key, int size, int shmflg);

    函数shmget用于创建或打开一共享内存段,该内存段由函数的第一个参数唯一创建。函数成功,则返回一个唯一的共享内存标识号(相当于进程号,唯一的标识着共享内存),失败返回-1。参数key是一个与共享内存段相关联关键字如果事先已经存在一个与指定关键字关联的共享内存段,则直接返回该内存段的标识,表示打开,如果不存在,则创建一个新的共享内存段。key的值既可以用ftok函数产生,也可以是IPC_PRIVATE(用于创建一个只属于创建进程的共享内存,主要用于父子通信),表示总是创建新的共享内存段;

    参数size指定共享内存段的大小,以字节为单位;

    参数shmflg是一掩码合成值,可以是访问权限值与(IPC_CREAT或IPC_EXCL)的合成。IPC_CREAT表示如果不存在该内存段,则创建它。IPC_EXCL表示如果该内存段存在,则函数返回失败结果(-1)。如果调用成功,返回内存段标识,否则返回-1

    2.3.shmat函数void *shmat(int shmid, const void *shmaddr, int shmflg);

    `

    函数shmat将共享内存段映射到进程空间的某一地址。参数shmid是共享内存段的标识 通常应该是shmget的成功返回值

    参数shmaddr指定的是共享内存连接到当前进程中的地址位置。通常是NULL,表示让系统来选择共享内存出现的地址。

    参数shmflg是一组位标识,通常为0即可。

    如果调用成功,返回映射后的进程空间的首地址,否则返回(char *)-1。

    2.4.shmdt函数int shmdt(const void *shmaddr);

    函数shmdt用于将共享内存段与进程空间分离。参数shmaddr通常为shmat的成功返回值。

    函数成功返回0,失败时返回-1.

    注意,将共享内存分离并没删除它,只是使得该共享内存对当前进程不在可用。

    2.5.shmctl函数int shmctl(int shmid, int cmd, struct shmid_ds *buf);

    函数shmctl是共享内存的控制函数,可以用来删除共享内存段。参数shmid是共享内存段标识 通常应该是shmget的成功返回值

    参数cmd是对共享内存段的操作方式,可选为IPC_STAT,IPC_SET,IPC_RMID。通常为IPC_RMID,表示删除共享内存段。

    参数buf是表示共享内存段的信息结构体数据,通常为NULL。

    例如shmctl(kshareMem,IPC_RMID,NULL)表示删除调共享内存段kHareMem

    三.实例

    3.1.具有亲属关系的调用///

    /// @file 01_relation_share.cpp

    /// @author AverageJoeWang([email protected])

    ///

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #define PERM S_IRUSR|S_IWUSR

    using std::cout;

    using std::endl;

    //两个有亲属关系进程进行通信

    int main(int argc, char* argv[])

    {

    int shmid = shmget(IPC_PRIVATE, 1024, PERM);

    if(-1 == shmid)

    {

    fprintf(stderr, "Create share memory error: %sna", strerror(errno));

    exit(1);

    }

    if(fork > 0)//父进程

    {

    char *p_addr = (char*)shmat(shmid, NULL, 0);//获取该段共享内存

    memset(p_addr, '

    展开全文
  • 进程间通信--管道

    2021-05-22 15:29:00
    进程间通信有哪些途径呢?1.信号2.管道3.消息队列4.信号量5.共享内存管道:管道就是将一个程序的输出与另一个程序的输入连接起来的单向通道。它是UNIX/Linux中古老而最广泛的进程间通信的方式。特别是在s...

    http://blog.csdn.net/deep_explore/article/details/6928530

    2011

    在网络程序设计中,如果没有进程间通信,那么软件的功能肯定会大打折扣。

    进程间通信有哪些途径呢?

    1.信号

    2.管道

    3.消息队列

    4.信号量

    5.共享内存

    管道:

    管道就是将一个程序的输出与另一个程序的输入连接起来的单向通道。它是UNIX/Linux中古老而最广泛的进程间通信的方式。特别是在shell中。

    在C语言中我们用Pipe()函数来建立管道:

    ===============

    系统调用: pipe();

    函数声明: int pipe( int fd[2] );

    返回值:     0 on success

    -1 on error: errno = EMFILE (no free descriptors)

    EMFILE (system file table is full)

    EFAULT (fd array is not valid)

    注意: fd[0] 用来从管道中读, fd[1] 用来向管道中写

    数组中的第一个元素(fd[0])是从管道中读出数据的句柄,第二个元素(fd[1])是向

    管道写入数据的句柄。也即是说,fd[1]的写入由 fd[0]读出。

    使用pipe在子进程中读入数据,然后在父进程中读出数据的例子:

    ====================================================================

    #include

    #include

    #include

    int main()

    {

    int fd[2];

    pid_t childpid;

    int nbytes;

    char string[] = "Hello,world!\n";

    char readbuffer[80];

    pipe(fd);

    if((childpid = fork()) == -1){

    perror("fork error");

    exit(1);

    }

    if(childpid == 0){

    //close child process read pipe

    close(fd[0]);

    //write data by write pipe

    write(fd[1], string, strlen(string));

    printf("Sended string:%s", string);

    _exit(0);

    }else{

    //close parent process write pipe

    close(fd[1]);

    // read data by read pipe

    nbytes = read(fd[0], readbuffer, sizeof(readbuffer));

    printf("Received string:%s", readbuffer);

    }

    return 0;

    }

    编译运行

    ==========

    [root@explore code]# ./a.out

    Received string:Hello,world!

    Sended string:Hello,world!

    >使用 dup()函数

    有时候我们需要将子进程当中的管道的句柄定向到标准 I/O(stdin/stdout)上去。这样,

    在子进程中使用 exec()函数调用外部程序时,这个外部程序就会将管道作为它的输入/输出。

    这个过程可以用系统函数 dup()来实现。其函数原型如下:

    系统调用: dup();

    函数声明: int dup( int oldfd );

    返回值:     new descriptor on success

    -1 on error: errno = EBADF (oldfd is not a valid descriptor)

    EBADF (newfd is out of range)

    EMFILE (too many descriptors for the process)

    虽然原句柄和新句柄是可以互换使用的,但为了避免混淆,我们通常会将原句柄关闭

    (close)

    。同时要注意,在 dup()函数中我们无法指定重定向的新句柄,系统将自动使用未

    被使用的最小的文件句柄(记住,句柄是一个整型量)作为重定向的新句柄。请看下面的

    例子:

    ......

    ......

    pipe(fd);

    childpid = fork();

    if(childpid == 0)

    {

    /* 关闭子进程的文件句柄 0(stdin) */

    close(0);

    /* 将管道的读句柄定义到 stdin */

    dup(fd[0]);

    execlp(“

    sort” “

    , sort” NULL);

    ,

    ......

    }

    >使用 dup2()函数

    在 Linux 系统中还有一个系统函数 dup2()。单从函数名上我们也可以判断出它和 dup()

    函数的渊源。下面是它的原型:

    系统调用: dup2();

    函数声明: int dup2( int oldfd, int newfd );

    返回值:     new descriptor on success

    -1 on error: errno = EBADF (oldfd is not a valid descriptor)

    EBADF (newfd is out of range)

    EMFILE(too many descriptors for the process)

    注意: 旧句柄将被 dup2()自动关闭

    显然,原来的 close 以及 dup 这一套调用现在全部由 dup2()来完成。这样不仅简便了程

    序,更重要的是,它保证了操作的独立性和完整性,不会被外来的信号所中断。在原来的

    dup()调用中,我们必须先调用 close()函数。假设此时恰好一个信号使接下来的 dup()调用不

    能立即执行,这就会引发错误(进程没有了 stdin )

    。使用 dup2()就不会有这样的危险。下

    面的例子演示了 dup2()函数的使用:

    ......

    pipe(fd);

    .

    childpid = fork();

    if(childpid == 0)

    {

    /* 将管道的读入端定向到 stdin */

    dup2(0, fd[0]);

    execlp("sort", "sort", NULL);

    ......

    }

    >使用 popen()/pclose()函数

    看了 dup2()函数,一定有人会想,既然能把 close 和 dup 合成一个函数,那么有没有把

    fork、exec 和 dup()结合的函数呢?答案是肯定的。它就是 linux 的系统函数 popen():

    库函数: popen();

    函数声明: FILE *popen ( char *command, char *type);

    返回值: new file stream on success

    NULL on unsuccessful fork() or pipe() call

    NOTES: creates a pipe, and performs fork/exec operations using "command"

    popen()函数首先调用 pipe()函数建立一个管道,然后它用 fork()函数建立一个子进程,

    运行一个 shell 环境,然后在这个 shell 环境中运行"command"参数指定的程序。数据在管道

    中流向由"type"参数控制。这个参数可以是"r"或者"w",分别代表读和写。需要注意的是,

    "r"和"w"两个参数不能同时使用!在 Linux 系统中,popen 函数将只使用"type"参数中第一

    个字符,也就是说,使用"rw"和"r"作为"type"参数的效果是一样的,管道将只打开成读状态。

    使用 popen 打开的管道必须用 pclose()函数来关闭。还记得 fopen 和 fclose 的配对使用

    吗?这里再次显示了管道和文件的相似性。

    库函数: pclose();

    函数声明: int pclose( FILE *stream );

    返回值:

    exit status of wait4() call

    -1 if "stream" is not valid, or if wait4() fails

    NOTES: waits on the pipe process to terminate, then closes the stream.

    下面是popen和pclose的例子,但是在没有运行成功,情景如下:

    #include

    #define MAXSTRS 5

    int main()

    {

    int cntr;

    FILE *pipe_fp;

    char *strings[MAXSTRS] = { "roy", "zixia", "gouki", "supper", "mmwan"};

    // create pipe with popen

    if((pipe_fp = popen("sort", "w")) == NULL ){

    perror("popen failed");

    exit(1);

    }

    // Processing loop

    for(cntr = 0; cntr < MAXSTRS; cntr++){

    fputs(strings[cntr], pipe_fp);

    fputs('\n', pipe_fp);

    }

    //close pipe

    pclose(pipe_fp);

    return 0;

    }

    编译运行

    ===========

    [root@explore code]# gcc popen_pclose.c

    popen_pclose.c: In function ‘main’:

    popen_pclose.c:11:3: warning: incompatible implicit declaration of built-in function ‘exit’ [enabled by default]

    popen_pclose.c:16:3: warning: passing argument 1 of ‘fputs’ makes pointer from integer without a cast [enabled by default]

    /usr/include/stdio.h:684:12: note: expected ‘const char * __restrict__’ but argument is of type ‘int’

    [root@explore code]# ./a.out

    Segmentation fault (core dumped)

    popen()\pclose()的例子

    #include

    int main()

    {

    FILE *pipein_fp, *pipeout_fp;

    char readbuffer[80];

    // create a pipe to "ls read pipe"

    if((pipein_fp = popen("ls", "r")) == NULL){

    perror("popen");

    exit(1);

    }

    // create a pipe to "sort write"

    if((pipeout_fp = popen("sort", "w")) == NULL){

    perror("popen");

    exit(1);

    }

    // Processing loop

    while(fgets(readbuffer, 80, pipein_fp)){

    fputs(readbuffer, pipeout_fp);

    }

    // close pipe

    pclose(pipein_fp);

    pclose(pipeout_fp);

    return 0;

    }

    编译运行

    ============

    [root@explore code]# gcc popen_pclose_2.c

    popen_pclose_2.c: In function ‘main’:

    popen_pclose_2.c:9:3: warning: incompatible implicit declaration of built-in function ‘exit’ [enabled by default]

    popen_pclose_2.c:14:3: warning: incompatible implicit declaration of built-in function ‘exit’ [enabled by default]

    [root@explore code]# ./a.out

    a.out

    gentmp.c

    pipe.c

    popen_pclose_2.c

    popen_pclose.c

    以下是一些在管道的使用中需要注意的问题:

    1. ipe()的调用必须在 fork()之前;

    p

    2.及时关闭不需要的管道句柄;

    3.使用 dup()之前确定定向的目标是最小的文件句柄;

    4.管道只能实现父子进程间的通信,如果两个进程之间没有 fork()关系,就必须考虑

    其他的进程通信方法。

    展开全文
  • 基于DBus的进程间通信(IPC)喜洋洋posted @ 2012年4月15日 21:46inwith tags, 314 阅读最近在研究进程间通信,linux下进程间通信的方式主要有Pipe(管道),FIFO(命名管道),信号,共享内存,消息队列,信号灯等,这些...

    基于DBus的进程间通信(IPC)

    喜洋洋

    posted @ 2012年4月15日 21:46

    in

    with tags

    , 314 阅读

    最近在研究进程间通信,linux下进程间通信的方式主要有Pipe(管道),FIFO(命名管道),信号,共享内存,消息队列,信号灯等,这些方式各有

    各得特点,如管道是linux下命令行中常用的,用于父子进程的通信。但是这些通信方式都比较原始,要属功能最强大的IPC应该是dbus,故查看了一下

    dbus的资料,但是资料相对较少,特别是有关python的部分。

    1.dbus概念

    网上有一篇叫“”的文章,流传较广。

    D-Bus是针对桌面环境优化的IPC(interprocess communication

    )机制,用于进程间的通信或进程与内核的通信。最基本的D-Bus协议是一对一的通信协议。但在很多情况下,通信的一方是消息总线。消息总线是一个特殊的

    应用,它同时与多个应用通信,并在应用之间传递消息。下面我们会在实例中观察消息总线的作用。消息总线的角色有点类似与X系统中的窗口管理器,窗口管理器

    既是X客户,又负责管理窗口。

    支持dbus的系统都有两个标准的消息总线:系统总线和会话总线。系统总线用于系统与应用的通信。会话总线用于应用之间的通信。网上有一个叫d-feet的python程序,我们可以用它来观察系统中的dbus世界。

    uid-29445857-id-4888431.html

    图1、由d-feet观察到的D-Bus世界

    dbus还提供了两个命令行工具用于dbus测试,dbus-send和dbus-monitor,前一个命令用于测试信号的发送,后一个命令用于监控dbus的数据流。

    2.dbus概念

    有关dbus的基础知识不在本文的范围内,具体的参见dbus的文档。下面给出dbus常用的流程。

    2.1建立服务的流程

    dbus_bus_get(),建立一个dbus连接;

    dbus_bus_request_name(),为这个dbus连接(DbusConnection)起名,这个名字将会成为我们在后续进行远程调用的时候的服务名;

    然后我们进入监听循环 -- dbus_connection_read_write();

    从总线上取出消息 -- dbus_connection_pop_message();

    并通过比对消息中的方法接口名和方法名 -- dbus_message_is_method_call();

    如果一致,那么我们跳转到相应的处理中去;

    在相应的处理中,我们会从消息中取出远程调用的参数。并且建立起回传结果的通路 --      reply_to_method_call()。回传动作本身等同于一次不需要等待结果的远程调用。

    2.2建立服务的流程

    建立好dbus连接之后,为这dbus连接命名,申请一个远程调用通道 --

    dbus_message_new_method_call(),注意,在申请远程调用通道的时候,需要填写服务器名,本次调用的接口名,和本次调用名

    (方法名)。压入本次调用的参数 -- dbus_message_iter_init_append();

    dbus_message_iter_append_basic(),实际上是申请了一个首地址,我们就是把我们真正要传的参数,往这个首地址里面送(送

    完之后一般都会判断是否内存越界了)。然后就是启动发送调用并释放发送相关的消息结构 --

    dbus_connection_send_with_reply()。这个启动函数中带有一个句柄。我们马上会阻塞等待这个句柄给我们带回总线上回传的

    消息。当这个句柄回传消息之后,我们从消息结构中分离出参数。用dbus提供的函数提取参数的类型和参数 --

    dbus_message_iter_init(); dbus_message_iter_next();

    dbus_message_iter_get_arg_type();

    dbus_message_iter_get_basic()。也就达成了我们进行本次远程调用的目的了。

    2.3发送信号的流程

    建立一个dbus连接之后,为这个dbus连接起名,建立一个发送信号的通道,注意,在建立通道的函数中,需要我们填写该信号的接口名和信号名 --

    dbus_message_new_signal()。然后我们把信号对应的相关参数压进去 --

    dbus_message_iter_init_append();

    dbus_message_iter_append_basic()。然后就可以启动发送了 -- dbus_connection_send();

    dbus_connection_flush。

    2.4信号接收流程

    建立一个dbus连接之后,为这个dbus连接起名,为我们将要进行的消息循环添加匹配条件(就是通过信号名和信号接口名来进行匹配控制的) --

    dbus_bus_add_match()。我们进入等待循环后,只需要对信号名,信号接口名进行判断就可以分别处理各种信号了。在各个处理分支上。我们

    可以分离出消息中的参数。对参数类型进行判断和其他的处理。

    3. 一个C语言的示例代码

    网上大部分代码都是基于dbus的一个封装库libdbus做的,以及使用glib,gtk的事件循环;为了减少库的依赖,直接使用C语言调用dbus的底层函数编写一个远程调用的示例代码,代码很简单,没使用GObject等一些复杂的库。

    远程调用的服务器代码,用于监控,代码如下:

    代码中很关键的一个地方是一个标准接口的实现,该接口虽说无实际意义,仅仅是反射出该session的接口信息,包含各个接口信息和信号信息,但是该信息在python版的dbus中调用很重要,否则python的调用会失败。

    编译命令如下

    可以用d-feet测试一下:

    uid-29445857-id-4888431.html

    用dbus-send测试命令如下:

    客户端代码(及远程调用的代码):

    执行结果:

    Calling remote method with no param

    Request Sent

    Got Reply: 1, 21614

    4.Pthon调用dbus

    展开全文
  • 展开全部进程间通信的方法主要有以下几种:(1)管道(Pipe):管道可用于具有亲缘关系进程间通信,允许一个进程和另32313133353236313431303231363533e78988e69d8331333332616461一个与它有共同祖先的进程之间进行...

    展开全部

    进程间通信的方法主要有以下几种:

    (1)管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另32313133353236313431303231363533e78988e69d8331333332616461一个与它有共同祖先的进程之间进行通信。

    (2)命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关 系 进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。

    (3)信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送 信号给进程本身;linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数)。

    (4)消息(Message)队列:消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺

    (5)共享内存:使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。

    (6)内存映射(mapped memory):内存映射允许任何多个进程间通信,每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。

    (7)信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。

    (8)套接口(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:Linux和System V的变种都支持套接字。

    而在java中我们实现多线程间通信则主要采用"共享变量"和"管道流"这两种方法

    方法一 通过访问共享变量的方式(注:需要处理同步问题)

    方法二 通过管道流

    其中方法一有两种实现方法,即

    方法一a)通过内部类实现线程的共享变量

    代码如下:public class Innersharethread {

    public static void main(String[] args) {

    Mythread mythread = new Mythread();

    mythread.getThread().start();

    mythread.getThread().start();

    mythread.getThread().start();

    mythread.getThread().start();

    }

    }

    class Mythread {

    int index = 0;

    private class InnerThread extends Thread {

    public synchronized void run() {

    while (true) {

    System.out.println(Thread.currentThread().getName()

    + "is running and index is " + index++);

    }

    }

    }

    public Thread getThread() {

    return new InnerThread();

    }

    }

    /**

    * 通过内部类实现线程的共享变量

    *

    */

    public class Innersharethread {

    public static void main(String[] args) {

    Mythread mythread = new Mythread();

    mythread.getThread().start();

    mythread.getThread().start();

    mythread.getThread().start();

    mythread.getThread().start();

    }

    }

    class Mythread {

    int index = 0;

    private class InnerThread extends Thread {

    public synchronized void run() {

    while (true) {

    System.out.println(Thread.currentThread().getName()

    + "is running and index is " + index++);

    }

    }

    }

    public Thread getThread() {

    return new InnerThread();

    }

    }

    b)通过实现Runnable接口实现线程的共享变量

    代码如下:public class Interfacaesharethread {

    public static void main(String[] args) {

    Mythread mythread = new Mythread();

    new Thread(mythread).start();

    new Thread(mythread).start();

    new Thread(mythread).start();

    new Thread(mythread).start();

    }

    }

    /* 实现Runnable接口 */

    class Mythread implements Runnable {

    int index = 0;

    public synchronized void run() {

    while (true)

    System.out.println(Thread.currentThread().getName() + "is running and

    the index is " + index++);

    }

    }

    /**

    * 通过实现Runnable接口实现线程的共享变量

    */

    public class Interfacaesharethread {

    public static void main(String[] args) {

    Mythread mythread = new Mythread();

    new Thread(mythread).start();

    new Thread(mythread).start();

    new Thread(mythread).start();

    new Thread(mythread).start();

    }

    }

    /* 实现Runnable接口 */

    class Mythread implements Runnable {

    int index = 0;

    public synchronized void run() {

    while (true)

    System.out.println(Thread.currentThread().getName() + "is running and

    the index is " + index++);

    }

    }

    方法二(通过管道流):

    代码如下:public class CommunicateWhitPiping {

    public static void main(String[] args) {

    /**

    * 创建管道输出流

    */

    PipedOutputStream pos = new PipedOutputStream();

    /**

    * 创建管道输入流

    */

    PipedInputStream pis = new PipedInputStream();

    try {

    /**

    * 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现

    */

    pos.connect(pis);

    } catch (IOException e) {

    e.printStackTrace();

    }

    /**

    * 创建生产者线程

    */

    Producer p = new Producer(pos);

    /**

    * 创建消费者线程

    */

    Consumer c = new Consumer(pis);

    /**

    * 启动线程

    */

    p.start();

    c.start();

    }

    }

    /**

    * 生产者线程(与一个管道输入流相关联)

    *

    */

    class Producer extends Thread {

    private PipedOutputStream pos;

    public Producer(PipedOutputStream pos) {

    this.pos = pos;

    }

    public void run() {

    int i = 8;

    try {

    pos.write(i);

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    /**

    * 消费者线程(与一个管道输入流相关联)

    *

    */

    class Consumer extends Thread {

    private PipedInputStream pis;

    public Consumer(PipedInputStream pis) {

    this.pis = pis;

    }

    public void run() {

    try {

    System.out.println(pis.read());

    } catch (IOException e) {

    e.printStackTrace();

    }

    }

    }

    展开全文
  • 进程间通信的方式

    2021-04-22 07:42:33
    1.管道管道,通常指无名管道,是 UNIX 系统IPC最古老的...概念:在内核中申请一块固定大小的缓冲区,程序拥有写入和读取的权利,没有血缘关系的进程也可以进程间通信。3.特点:1.面向字节流,2.生命周期随内核3.自带...
  • 进程间通信就是在不同进程之间传播或交换信息,那么不同进程之间存在着什么双方都可以访问的介质呢?进程的用户空间是互相独立的,一般而言是不能互相访问的,唯一的例外是共享内存区。但是,系统空间却是“公共场所...
  • Android进程间通信机制

    2021-05-10 02:24:26
    Android所拥有的IPCAndroid系统中有大量IPC(进程间通信)的场景,比如我们想要创建一个新的进程,需要通过Socket这种IPC方式去让Zygote Fork新进程;如果我们要杀掉一个进程,需要通过信号这种IPC方式去将SIGNAL_KILL...
  • 1)数据传输:一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几兆字节之间。 2)共享数据:多个进程想要操作共享数据,一个进程对共享数据的修改,别的进程应该立刻看到。 3)通知事件:一个...
  • Linux进程间通信方式

    2021-01-14 16:26:38
    目录 前言 一、进程间通信的目的 二、Linux进程间通信方式简介 ​​​​​​​ ...进程间通信就是在不同进程之间传播或者交换信息。进程的用户空间是相互独显然可以体...在广义上,这也是进程间通信的手段,到...
  • 进程间通信的六种常见方式

    千次阅读 2021-06-01 13:52:45
    进程间通信的方式有很多,这里主要讲到进程间通信的五种方式,分别为:管道、FIFO、消息队列、共享内存、信号量。 一、管道 管道的特点: df
  • 《实验十八--linux进程间通信.ppt》由会员分享,可在线阅读,更多相关《实验十八--linux进程间通信.ppt(15页珍藏版)》请在人人文库网上搜索。1、Linux进程间通信(IPC),实验十九,共享内存(Shared memory) 消息队列...
  • WPF 进程间通信

    2021-04-04 11:28:08
    WPF应用程序使用SendMessage实现进程间通信 1.函数定义 使用WPF框架的C#窗体应用程序可以使用SendMessage方法实现进程间通信,SendMessage属于Windows API宏,可以将指定的消息发送到一个或多个窗口,直到窗口程序...
  • 本地进程间通信

    2021-03-19 11:51:20
    进程间通信-Socket Socket是一种接口技术,可以让不同的进程进行通信,有两种方式:既可以同一计算机上的,也可以是不同计算机上的进程。 同一计算机上socket通信: 注意:底层需要借助socket文件,进行同一台计算机...
  • 实验六:进程间通信实验目的:学会进程间通信方式:无名管道,有名管道,信号,消息队列,实验要求:在父进程中创建一无名管道,并创建子进程来读该管道,父进程来写该管道在进程中为 SIGBUS注册处理函数,并向该...
  • 无名管道(pipe) ...=========================================================================(1) 无名管道(pipe):管道允许一个进程和另一个与它有共同祖先的进程之间进行通信。 (2) 命名管
  • 进程间通信

    2021-03-03 09:29:55
    进程间通信 每个进程的用户地址空间都是独立的,一般而言是不能互相访问的,但内核空间是每个进程都共享的,所以进程之间要通信必须通过内核。 Linux 内核提供了不少进程间通信的机制,我们来一起瞧瞧有哪些? ...
  • //Fah.h子程序2的头文件#ifndef FAH_H#define FAH_H#includeclass QDial;class QVBoxLayout;class Fah : public QWidget{Q_OBJECTpublic:Fah();~Fah() {};private slots:void handleMsg(const QString &...
  • 进程间最基本的通信原理你了解多少? 进程间通信基本原理 进程间通信的原理 Binder 的作用 Binder 的使用场景 Binder 是什么? 什么时候需要用到进程间通信? 为什么要多进程? 进程间通信为什么要用到Binder机制...
  • C#与C++进程间通信

    2021-05-27 11:13:29
    C#与C++进程间通信 PS:也是从网上各个帖子中学习的代码,因此代码的格式以及内容有粘贴网上其他大神的代码,如有侵权请告知删除 方式:管道 C++端代码: HANDLE hPipe; DWORD dwWrite; char Buffer[256]; //创建...
  • 本文实例讲解了python实现两个程序之间通信的方法,具体方法如下:该实例采用socket实现,与socket网络编程不一样的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一个参数是socket.AF_UNIX而不是 socket...
  • 实验五:进程间通信

    2021-05-13 11:54:29
    《实验五:进程间通信》由会员分享,可在线阅读,更多相关《实验五:进程间通信(8页珍藏版)》请在人人文库网上搜索。1、精选文库 实验五:进程间通信 实验目的: 学会进程间通信方式:无名管道,有名管道,信号,...
  • Qt:Qt中的进程间通信

    2021-04-13 22:51:07
    Qt提供了几种在Qt应用程序中实现进程间通信(IPC)的方式。 TCP / IP 跨平台的Qt网络模块提供了使网络编程可移植且容易的类。它提供了使用特定的应用程序级协议进行通信的高层类(例如QNetworkAccessManager),以及...
  • 这次带给你的面试题目是:进程间通信都有哪些方法? 凡是面试官问“什么情况下”的时候,面试官实际想听的是你经过理解,整理得到的认知。回答应该是概括的、简要的。而不是真的去列举每一种 case。另外,面试官...
  • Android进程间通信总结

    2021-09-06 21:26:37
    ​ IPC为 (Inter-Process Communication) 缩写,称为进程间通信或跨进程通信,指两个进程间进行数据交换的过程。安卓中主要采用 Binder 进行进程间通信,当然也支持其他 IPC 方式,如:管道,Socket,文件共享,...
  • 鸿蒙内核源码中文注解 >> 精读内核源码,中文注解分析, 深挖地基工程,大脑永久记忆, 四大源码仓每日同步更新< Gitee | Github | CSDN | Coding > 鸿蒙内核源码分析博客 >...进程间为何要通讯 ? 鸿
  • 进程进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在早期面向进程设计的计算机结构中,进程是程序的基本执行实体;在当代面向线程...
  • 在将这个题目之前大家需要了解几个概念:进程: 我们可以先看进程的定义:进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础;在当总结起来...
  • 它允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式。大多数的共享内存的实现,都把由不同进程之间共享的内存安排为同一段物理内存.首先我们都知道我们...
  • 刚刚测试的延迟从Java在我的Corei5 2.8GHz,只有单字节发送/接收,2 Java进程刚刚生成,没有为任务分配特定的CPU核心:TCP - 25 microsecondsNamed pipes - 15 microseconds现在明确指定核心掩码,如taskset 1 java ...
  • Messenger,即进程间通信的信使.它是基于Message的进程间通信,我们可以像在线程间利用Handler.send(Message)一样. Messenger是一种轻量级的IPC方案,它的底层实现其实就是AIDL.跨进程通信使用Messenger时,Messenger会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 349,205
精华内容 139,682
关键字:

进程间通讯