Question

我需要创建一个调用应用程序（c ++二进制文件）4000次的脚本。应用程序需要一些参数，并且每次调用都会将zip文件写入磁盘。因此，当脚本执行时，4000个zip文件将被写入磁盘。该应用程序支持多个线程。

我首先创建了一个bash脚本来完成这项工作，但它运行正常。但现在我需要脚本独立于平台。因此我试图将脚本移植到groovy，如下所示：

for (int i = 1; i <= 4000; i++) {
  def command = """myExecutable
                 a=$argA
                 b=$outDir"""

  def proc = command.execute()                 // Call *execute* on the string
  proc.waitFor()                               // Wait for the command to finish
  // Obtain status and output
  println "return code: ${ proc.exitValue()}"
  println "stderr: ${proc.err.text}"
  println "stdout: ${proc.in.text}" // *out* from the external program is *in* for groovy

  println "iteration : " + i

}

但是在将381个zipfiles写入磁盘之后，脚本就会挂起。我是否需要在每次通话或类似的事情后关闭该过程？

下面： http://groovy.codehaus.org/Process+Management

它表示已知java.lang.Process可能会挂起或死锁。在groovy中不做这样的事情吗？

我也会在python中试一试，看它是否会出现同样的问题

Answer 1

可能是输出流阻塞：

(1..<4000).each { i ->
    println "iteration : $i"

    def command = """myExecutable
                 a=$argA
                 b=$outDir"""

    def proc = command.execute()
    // Consume the outputs from the process and pipe them to our output streams
    proc.consumeProcessOutput( System.out, System.err )

    // Wait for the command to finish
    proc.waitFor()

    // Obtain status
    println "return code: ${proc.exitValue()}"
}

Answer 2

是的，你应该关闭属于进程的流。

或者，正如@tim_yates所说，你应该使用consumeProcessOutput，或者在concurent解决方案中使用waitForProcessOutput，它会为你关闭它们。

对于并行计算，您可以使用smth。像这样：

import groovyx.gpars.GParsPool

GParsPool.withPool(8){ // Start in pool with 8 threads.
  (1..4000).toList().eachParallel {
    def p = "myExecutable a=$argA b=$outDir".execute()
    def sout = new StringBuffer();
    def serr = new StringBuffer();
    p.waitForProcessOutput(sout, serr)
    synchronized (System.out) {
      println "return code: ${ p.exitValue()}"
      println "stderr: $serr"
      println "stdout: $sout"
      println "iteration $it"
    }
  }
}

在groovy中执行许多子进程失败

2 个答案: