Java 父子进程通信

由父进程创建子进程,收发消息

package org.tango.process.parent;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.tango.process.signal.Signal;

import java.io.*;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.Scanner;

/**
 * Created by tango on 14-7-3.
 */
public class Main {
    private static final Log LOG = LogFactory.getLog(Main.class);
    private static final Signal SIGNAL = new Signal();

    public static void main(String[] args) throws IOException {
        try {
            startProcess("java", "org.tango.process.child.SubMain", "/Users/tango/Java/Application/restruct/tango-process/tango-process-child/target/classes/", null);
            Scanner scanner = new Scanner(System.in);

            while (true) {
                //
                LOG.debug("please input message,[quit | exit]: exit program");
                String next = scanner.next();
                if ("quit".equals(next) || "exit".equals(next)) {
                    break;
                }
                boolean send = SIGNAL.send(next);
                LOG.debug("send message : " + next + " /".concat(String.valueOf(send)));
                String receive = SIGNAL.receive();
                LOG.debug("receive message : " + receive);
            }
            LOG.debug("finish,will shutdown program");
        } catch (Exception err) {
            err.printStackTrace();
        }
    }

    private static Process startProcess(String command, String args, String directory, String classPath) throws IOException, NoSuchFieldException, IllegalAccessException, InterruptedException {
        ProcessBuilder builder = new ProcessBuilder();
        builder.command(command, args);
        //
        LOG.debug("create sub process of ".concat(command).concat(" ").concat(args));
        builder.directory(new File(directory));
        LOG.debug("setting work directory successful : ".concat(directory));
        if (classPath != null) {
            Map<String, String> environment = builder.environment();
            environment.put("CLASSPATH", environment.get("CLASSPATH").concat(":").concat(classPath));
            LOG.debug("process environment : ".concat(environment.toString()));
        }
        //
        final Process process = builder.start();
        Field pidField = process.getClass().getDeclaredField("pid");
        pidField.setAccessible(true);
        Object pid = pidField.get(process);
        LOG.debug("start process successful : pid/".concat(pid.toString()));
        //
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                process.destroy();
            }
        });
        LOG.debug("setting shutdown hook successful");
        //
        SIGNAL.setOut(new BufferedWriter(new OutputStreamWriter(process.getOutputStream())));
        LOG.debug("converter out successful");
        SIGNAL.setIn(new BufferedReader(new InputStreamReader(process.getInputStream())));
        LOG.debug("converter in successful");
        SIGNAL.setErr(new BufferedReader(new InputStreamReader(process.getErrorStream())));
        LOG.debug("converter err successful");
      /*  BufferedReader err = SIGNAL.getErr();
        System.out.println("err = " + err.readLine());*/
        return process;
    }
}
package org.tango.process.child;

import org.tango.process.signal.Signal;

import java.io.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by tango on 14-7-5.
 */
public class SubMain {
    private static final Signal SIGNAL = new Signal();

    public static void main(String[] args) throws Exception {
        SIGNAL.setIn(new BufferedReader(new InputStreamReader(System.in)));
        SIGNAL.setOut(new BufferedWriter(new OutputStreamWriter(System.out)));
        //
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        String receive = SIGNAL.receive();
                        if (receive != null) {
                            SIGNAL.send(receive.concat(" ").concat("too"));
                        }
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}
package org.tango.process.signal;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;

/**
 * Created by tango on 14-7-3.
 */
public class Signal {
    private BufferedReader in;
    private BufferedWriter out;
    private BufferedReader err;

    public boolean send(String message) throws IOException {
        try {
            out.write(message);
            out.write("\r\n");
            out.flush();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    public String receive() throws IOException {
        String message = in.readLine();
        return message;
    }

    public String valid() throws IOException {
        String message = err.readLine();
        return message;
    }

    public BufferedReader getIn() {
        return in;
    }

    public void setIn(BufferedReader in) {
        this.in = in;
    }

    public BufferedWriter getOut() {
        return out;
    }

    public void setOut(BufferedWriter out) {
        this.out = out;
    }

    public BufferedReader getErr() {
        return err;
    }

    public void setErr(BufferedReader err) {
        this.err = err;
    }
}

代码清单如下:

|____tango-process

| |____pom.xml

| |____tango-process-child

| | |____pom.xml

| | |____src

| | | |____main

| | | | |____java

| | | | | |____org

| | | | | | |____tango

| | | | | | | |____process

| | | | | | | | |____child

| | | | | | | | | |____SubMain.java

| | | | | | | | |____signal

| | | | | | | | | |____Signal.java

| | | | |____resources

| | | |____test

| | | | |____java

| |____tango-process-parent

| | |____pom.xml

| | |____src

| | | |____main

| | | | |____java

| | | | | |____org

| | | | | | |____tango

| | | | | | | |____process

| | | | | | | | |____parent

| | | | | | | | | |____Main.java

| | | | | | | | |____signal

| | | | | | | | | |____Signal.java

| | | | |____resources

| | | | | |____log4j.properties

Java 父子进程通信

时间: 2024-12-14 18:04:52

Java 父子进程通信的相关文章

c++ pipe实现父子进程通信

1.父子进程通信pipe编程流程 -创建管道 -设置进程的输出到管道 -创建进程 -关闭管道写句柄 -读管道读句柄,把数据读到一个buffer里 2.注意事项 -读管道数据的时候,一定要关闭写句柄: -父子进程通信时,句柄的传递多通过继承来完成,父进程允许这些句柄为子进程继承:创建子进程,是否继承的属性要设置为true: // pdfprintconsole.cpp : 此文件包含 "main" 函数.程序执行将在此处开始并结束. // #include "pch.h&quo

linux进程通信之管道

1.介绍: 1)同一主机: unix进程通信方式:无名管道,有名管道,信号 system v方式:信号量,消息队列,共享内存 2)网络通信:Socket,RPC 2.管道: 无名管道(PIPE):使用一个进程的标准输出作为另一个进程的标准输入建立的一个单向管道,执行完成后消失.主要用于父进程与子进程之间,或者两个兄弟进程之间.采用的是单向 1)创建无名管道:(#include(unistd.h)) extern int pipe(int pipes[2]),pipes[0]完成读操作,pipes

父子进程通过mmap进行通信

本来打算使用pipe进行父子进程之间的数据交互(应用场景是父进程向多个子进程分发数据,子进程进行处理):但是担心pipe的性能,转而使用mmap实现. 废话少叙,上代码. #include <stdio.h> #include <sys/types.h> #include <signal.h> #include <string.h> #include <errno.h> #include <unistd.h> #include <

父子进程共享内存通信的三种方法

1.  mmap MAP_ANONYMOUS 在支持MAP_ANONYMOUS的系统上,直接用匿名共享内存即可, 2. mmap  /dev/zero 有些系统不支持匿名内存映射,则可以使用fopen打开/dev/zero文件,然后对该文件进行映射,可以同样达到匿名内存映射的效果. 3. shmget shmat shmctl shmget 是老式的system V 共享内存模式,很多系统都支持这种方法. 父子进程共享内存通信的三种方法

Java进程通信之映像文件共享内存

Java进程通信之映像文件共享内存 1. 共享内存 vs 进程通信 对UNIX系统来说,共享内存分为一般共享内存和映像文件共享内存两种.但windows实际上只有影像文件共享内存一种. 而说到进程通信,First当然是Socket通信,但缺点太明显.其一,浪费网络资源,其二,多余的code成本也绝非所愿. 综上,映像文件共享内存方式,成为了实际应用中推荐使用的进程通信手段. 2.优点 数据共享/动态配置/减少资源浪费 3.特点 可被多个进程打开访问 读写操作的进程在执行读写操作时,其他进程不能进

Linux之进程通信20160720

好久没更新了,今天主要说一下Linux的进程通信,后续Linux方面的更新应该会变缓,因为最近在看Java和安卓方面的知识,后续会根据学习成果不断分享更新Java和安卓的方面的知识~ Linux进程通信的知识,建议参照<UNIX环境高级编程>这本书,这里也只是做一个总结: 1.线程:进程中的子线程之间的通信,线程之间的内存(变量)是共享的,通过共享内存也就是全局变量即可,注意互斥即可 2.进程:进程之间的通信必须要借助内核实现: 1)pipe: (无名)管道,只能用于父子进程间通信:单向的(一

第七课 进程通信

unix_c_07.txt================第七课 进程通信================一.基本概念------------1. 何为进程间通信~~~~~~~~~~~~~~~~~进程间通信(Interprocess Communication, IPC)是指两个,或多个进程之间进行数据交换的过程.2. 进程间通信分类~~~~~~~~~~~~~~~~~1) 简单进程间通信:命令行参数.环境变量.信号.文件.2) 传统进程间通信:管道(fifo/pipe).3) XSI进程间通信:

android 远程Service以及AIDL的跨进程通信

在Android中,Service是运行在主线程中的,如果在Service中处理一些耗时的操作,就会导致程序出现ANR. 但如果将本地的Service转换成一个远程的Service,就不会出现这样的问题了. 转换成远程Service非常简单,只需要在注册Service的时候将他的android:process的属性制定成 :remote就可以了. 重新运行项目,你会发现,不会出现ANR了. 为什么将MyService转换成远程Service后就不会导致程序ANR了呢?这是由于,使用了远程Serv

撸代码--linux进程通信(基于共享内存)

1.实现亲缘关系进程的通信,父写子读 思路分析:1)首先我们须要创建一个共享内存. 2)父子进程的创建要用到fork函数.fork函数创建后,两个进程分别独立的执行. 3)父进程完毕写的内容.同一时候要保证子进程退出后,在删除共享内存. 4)子进程完毕读的内容. 效果展示:                 代码展示:           #include <string.h> #include <unistd.h> #include <sys/types.h> #inc