Java跨进程监控：如何让应用A感知应用B的启动状态

针对你遇到的固定等待时长判断启动状态的问题，以下是几种可靠的实现方案，让应用B能主动向应用A发送启动阶段事件：

方案1：利用进程标准输出流（最简洁） #

直接通过子进程的标准输出传递事件，无需额外端口或依赖，只需用特定前缀区分普通日志和事件消息。

应用B代码 #

void start() {
    doStuff1();
    // 用[EVENT]前缀标记事件，避免和普通日志混淆
    System.out.println("[EVENT] Do stuff done");
    doStuff2();
    // 关键启动完成事件
    System.out.println("[EVENT] B is running");
}

应用A代码 #

ProcessBuilder builder = new ProcessBuilder(commands);
// 合并错误流到标准输出，统一处理（可选）
builder.redirectErrorStream(true);
Process process = builder.start();

// 启动线程读取子进程输出，避免阻塞主线程
new Thread(() -> {
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
        String line;
        while ((line = reader.readLine()) != null) {
            if (line.startsWith("[EVENT]")) {
                String event = line.substring("[EVENT] ".length());
                if ("B is running".equals(event)) {
                    // 通知主线程启动完成
                    synchronized (process) {
                        process.notify();
                    }
                    break;
                } else if ("Do stuff done".equals(event)) {
                    // 可选：处理中间阶段事件
                    System.out.println("B完成初始化阶段：" + event);
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();

// 等待启动完成事件，同时设置超时（30秒，可调整）
try {
    synchronized (process) {
        process.wait(30000);
    }
    // 验证进程是否仍在运行
    try {
        process.exitValue();
        System.out.println("应用B启动失败，已退出");
        // 向客户端返回启动失败响应
    } catch (IllegalThreadStateException e) {
        System.out.println("应用B启动成功");
        // 向客户端返回启动成功响应
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    System.out.println("等待应用B启动超时");
    // 向客户端返回超时响应
}

方案2：Socket通信（适合复杂场景） #

应用A启动时监听临时端口，将端口作为参数传给应用B，B启动后主动连接该端口发送事件，支持双向通信。

应用A代码 #

// 监听临时端口（系统自动分配可用端口）
ServerSocket serverSocket = new ServerSocket(0);
int notifyPort = serverSocket.getLocalPort();

// 将通知端口作为参数传给应用B
List<String> commands = new ArrayList<>();
commands.add("java");
commands.add("-jar");
commands.add("appB.jar");
commands.add("--notify-port=" + notifyPort);

ProcessBuilder builder = new ProcessBuilder(commands);
Process process = builder.start();

// 处理B的连接线程
new Thread(() -> {
    try (Socket clientSocket = serverSocket.accept();
         BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {
        String event;
        while ((event = reader.readLine()) != null) {
            if ("B is running".equals(event)) {
                synchronized (process) {
                    process.notify();
                }
                break;
            }
        }
        serverSocket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}).start();

// 等待逻辑同方案1，设置超时并验证进程状态
try {
    synchronized (process) {
        process.wait(30000);
    }
    // 进程状态检查...
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

应用B代码 #

void start(String[] args) {
    // 解析参数获取通知端口
    int notifyPort = -1;
    for (String arg : args) {
        if (arg.startsWith("--notify-port=")) {
            notifyPort = Integer.parseInt(arg.substring("--notify-port=".length()));
            break;
        }
    }
    if (notifyPort == -1) {
        throw new IllegalArgumentException("缺少通知端口参数");
    }

    doStuff1();
    sendEvent(notifyPort, "Do stuff done");
    doStuff2();
    sendEvent(notifyPort, "B is running");
}

private void sendEvent(int port, String event) {
    try (Socket socket = new Socket("localhost", port);
         PrintWriter writer = new PrintWriter(socket.getOutputStream(), true)) {
        writer.println(event);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

方案3：文件系统标记（适合隔离环境） #

应用B在启动阶段创建特定标记文件，应用A轮询检查文件是否存在，适合无网络或严格隔离的部署环境。

应用B代码 #

void start() {
    doStuff1();
    // 创建阶段完成标记文件
    new File("/tmp/appB_stage1_done").createNewFile();
    doStuff2();
    // 创建启动完成标记文件
    new File("/tmp/appB_running").createNewFile();
}

应用A代码 #

ProcessBuilder builder = new ProcessBuilder(commands);
Process process = builder.start();

long startTime = System.currentTimeMillis();
boolean started = false;
// 轮询30秒超时
while (System.currentTimeMillis() - startTime < 30000) {
    if (new File("/tmp/appB_running").exists()) {
        started = true;
        break;
    }
    TimeUnit.SECONDS.sleep(1);
}

// 验证启动状态
if (started) {
    try {
        process.exitValue();
        System.out.println("应用B启动后异常退出");
        // 返回失败响应
    } catch (IllegalThreadStateException e) {
        System.out.println("应用B启动成功");
        // 返回成功响应
    }
} else {
    try {
        int exitCode = process.exitValue();
        System.out.println("应用B启动失败，退出码：" + exitCode);
    } catch (IllegalThreadStateException e) {
        System.out.println("应用B启动超时");
    }
    // 返回失败/超时响应
}

// 清理标记文件（可选）
new File("/tmp/appB_stage1_done").delete();
new File("/tmp/appB_running").delete();

方案选择建议 #

• 标准输出流：优先选择，实现最简单，无需额外配置，适合轻量级事件通知。
• Socket通信：适合需要双向交互或复杂消息格式的场景。
• 文件标记：适合无网络、严格隔离的部署环境，注意处理文件权限和清理逻辑。

内容的提问来源于stack exchange，提问作者Shadow4571