在后台运行 JavaExec 任务，然后在构建完成时终止

Question

我试图找出如何启动一个 JavaExec 任务来生成 Jetty 服务器而不阻塞后续任务。另外，我需要在构建完成后终止该服务器。知道我该怎么做吗？

Answer 1

我知道该线程是 2011 年的，但我仍然偶然发现了这个问题。这是使用 Gradle 2.14 的解决方案：

import java.util.concurrent.Callable
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors    

class RunAsyncTask extends DefaultTask {
    String taskToExecute = '<YourTask>'
    @TaskAction
    def startAsync() {
        ExecutorService es = Executors.newSingleThreadExecutor()
        es.submit({taskToExecute.execute()} as Callable)
    }
}


task runRegistry(type: RunAsyncTask, dependsOn: build){
    taskToExecute = '<NameOfYourTaskHere>'
}

Answer 2

我更新了 @chrishuen 的解决方案，因为您无法再对任务调用执行。这是我的工作 build.gradle

import java.time.LocalDateTime
import java.util.concurrent.Callable
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

group 'sk.bsmk'
version '1.0-SNAPSHOT'

apply plugin: 'java'

task wrapper(type: Wrapper) {
  gradleVersion = '3.4'
}

class RunAsyncTask extends DefaultTask {
  @TaskAction
  def startAsync() {
    ExecutorService es = Executors.newSingleThreadExecutor()
    es.submit({
      project.javaexec {
        classpath = project.sourceSets.main.runtimeClasspath
        main = "Main"
      }
    } as Callable)

  }
}

task helloAsync(type: RunAsyncTask, dependsOn: compileJava) {
  doLast {
    println LocalDateTime.now().toString() + 'sleeping'
    sleep(2 * 1000)
  }
}

Answer 3

希望这段代码能让您了解如何完成它。

您可以使用构建侦听器闭包在构建开始/结束时运行代码。然而，由于某种原因， gradle.buildStarted 闭包在 Milestone-3 中不起作用，因此我将其替换为 gradle.taskGraph.whenReady ，这可以解决问题。

然后，您可以使用 Task#execute() 调用 runJetty 任务（请注意，此 API 不是官方的，可能会消失），此外，还可以从 运行它ExecutorService 来获取一些异步行为。

import java.util.concurrent.*

task myTask << {
  println "Do usual tasks here"
}

task runJetty << {
  print "Pretend we are running Jetty ..."
  while(!stopJetty){
    Thread.sleep(100)
  }
  println "Jetty Stopped."
}

stopJetty = false
es = Executors.newSingleThreadExecutor()
jettyFuture = null

//gradle.buildStarted { ... }
gradle.taskGraph.whenReady { g ->
  jettyFuture = es.submit({ runJetty.execute() } as Callable)
}

gradle.buildFinished {
  println "Stopping Jetty ... "
  stopJetty = true

  //This is optional. Could be useful when debugging.
  try{
    jettyFuture?.get()
  }catch(ExecutionException e){
    println "Error during Jetty execution: "
    e.printStackTrace()
  }
}

Answer 4

你不能用 JavaExec 来做到这一点；你必须编写自己的任务。

Answer 5

根据之前的回答，我的看法是：

abstract class RunAsyncTask extends DefaultTask {

    @Input
    abstract Property<FileCollection> getClasspath()
    @Input
    abstract Property<String> getMain()
    @Input
    abstract ListProperty<String> getArgs()

    @TaskAction
    def startAsync() {
        // do get all the parameters before going asynch, otherwise it sometimes blocks
        def cp = classpath.get().asPath
        def m = main.get()
        def a = args.get()

        ExecutorService es = Executors.newSingleThreadExecutor()
        es.submit({
            def command = ["java", "-cp", cp, m] + a
            ProcessBuilder builder = new ProcessBuilder(command.toList())
            builder.redirectErrorStream(true)
            builder.directory(project.projectDir)
            Process process = builder.start()
            InputStream stdout = process.getInputStream()
            BufferedReader reader = new BufferedReader(new InputStreamReader(stdout))

            def line
            while ((line = reader.readLine()) != null) {
                println line
            }
        } as Callable)
    }
}


task startServer(type: RunAsyncTask) {
    classpath = ...
    main = '...'
    args = [...]
    doLast {
        // sleep 3 seconds to give the server time to startup
        Thread.sleep(3000)
    }
}