如何在Scala中实现进程的交互式操作？

嘿，我完全懂你在做这款交互式游戏机器人时遇到的头疼问题——Scala自带的ProcessIO把输入、输出、错误流的处理拆成了三个独立的函数，这对于需要先读进程输出、再发下一轮输入的交互式场景来说，简直是个天生的阻碍！

别担心，我们可以通过线程协调的方式，让单个函数同时握牢输入输出流的控制权，完美实现你要的交互逻辑。下面是具体的解决方案：

核心思路 #

ProcessIO的三个处理函数各自运行在独立线程里，我们可以用Promise来“等待”输入流和输出流都就绪，然后启动一个单独的交互线程，在这个线程里统一处理读进程输出→生成响应→发输入给进程的循环逻辑。

完整代码示例 #

import scala.sys.process._
import scala.concurrent.{Promise, Await}
import scala.concurrent.duration.Duration
import java.io.{BufferedReader, InputStreamReader, OutputStream, PrintWriter, InputStream}
import scala.util.control.Breaks._

object GameBot {
  def main(args: Array[String]): Unit = {
    // 替换成你要交互的目标进程，比如自定义的游戏脚本
    val targetProcess = "./my-text-game.sh".run(createInteractiveIO())
    targetProcess.waitFor()
  }

  private def createInteractiveIO(): ProcessIO = {
    // 用Promise来同步输入输出流的就绪状态
    val processOutputStreamPromise = Promise[OutputStream]()
    val processInputStreamPromise = Promise[InputStream]()

    // 启动核心交互线程，等两个流都准备好再开始工作
    new Thread(() => {
      val outToProcess = Await.result(processOutputStreamPromise.future, Duration.Inf)
      val inFromProcess = Await.result(processInputStreamPromise.future, Duration.Inf)
      runGameLoop(inFromProcess, outToProcess)
    }, "GameBot-InteractionLoop").start()

    new ProcessIO(
      // 处理"给进程发输入"的流：把流存入Promise，交给交互线程处理
      (out: OutputStream) => {
        processOutputStreamPromise.success(out)
      },
      // 处理"读进程输出"的流：同样存入Promise
      (in: InputStream) => {
        processInputStreamPromise.success(in)
      },
      // 处理错误流：简单打印到控制台，你可以按需修改
      (err: InputStream) => {
        val errReader = new BufferedReader(new InputStreamReader(err))
        var line: String = null
        while ({ line = errReader.readLine(); line != null }) {
          println(s"[Process Error] $line")
        }
        errReader.close()
      }
    )
  }

  // 你的核心游戏交互逻辑：在这里同时操作输入输出流
  private def runGameLoop(inFromProcess: InputStream, outToProcess: OutputStream): Unit = {
    val reader = new BufferedReader(new InputStreamReader(inFromProcess))
    val writer = new PrintWriter(outToProcess, true) // 自动flush，确保进程能及时收到输入

    try {
      var processOutput: String = null
      println("=== Game Bot Started ===")
      while ({ processOutput = reader.readLine(); processOutput != null }) {
        println(s"[Game] $processOutput")

        // 替换成你的游戏逻辑：根据进程输出生成下一次输入
        val botInput = generateGameResponse(processOutput)
        println(s"[Bot] $botInput")
        writer.println(botInput)

        // 示例：如果收到游戏结束信号，终止循环
        if (processOutput.contains("Game Over")) {
          break
        }
      }
    } catch {
      case e: Exception => println(s"[Bot Error] ${e.getMessage}")
    } finally {
      reader.close()
      writer.close()
      println("=== Game Bot Stopped ===")
    }
  }

  // 示例响应生成函数，完全替换成你的游戏逻辑即可
  private def generateGameResponse(gameOutput: String): String = {
    gameOutput match {
      case "Choose your class: Warrior/Mage/Rogue" => "Mage"
      case "Enter your name:" => "ScalaBot"
      case "Attack or Defend?" => "Attack"
      case _ => ""
    }
  }
}

关键细节说明 #

1. Promise同步流状态：确保交互线程只有在输入输出流都可用时才启动，避免空指针或未就绪的问题。
2. 独立交互线程：把读写逻辑放在同一个线程里，完美实现“读→处理→写”的循环，符合你要的交互式协作需求。
3. 自动flush的PrintWriter：避免输入被缓存导致进程收不到你的指令，这是交互式场景里很容易踩的坑。
4. 资源释放：用finally块确保流被正确关闭，避免资源泄漏。

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