如何创建Gradle任务并行运行多参数的Vert.x Verticle部署任务？

我想创建一个Gradle任务，用来并行运行另一个带多个参数的任务，具体是部署和运行Vert.x Verticle。目前我能单独部署这些Verticle，但希望通过Gradle同时运行所有Verticle。我尝试了下面的代码但无法正常工作，也搞不懂Worker API的用法，想知道有没有人遇到过类似场景并能提供解决方案。

尝试的代码 #

task runVerticlesThroughLauncher(type: JavaExec) {
//this task is the main task that uses the VerticleLauncher to initialize a verticle and deploy it.

    if (project.hasProperty("launcherNames")) {
        ext.cmdargs = project.getProperty("launcherNames")
    } else {
        ext.cmdargs = ""
    }

    def verticleRunCommands=[
      verticle1:"com.verticles.Verticle1", 
      verticle2:"com.verticles.Verticle2", 
      verticle3:"com.verticles.Verticle3"
    ]

    File runningDir = new File('..')
    runningDir.mkdirs()
    tasks.runVerticlesThroughLauncher.workingDir(runningDir)

    classpath = sourceSets.main.runtimeClasspath
    mainClass = "com.main.VerticleLauncher"
    args "run", verticleRunCommands.getOrDefault(cmdargs, "")
}

task runVerticleLauncherAllVerticles(type: JavaExec){
    // this task was my attempt at running all the verticles in parallel, but the task is not runnable, giving ClassNotFound error

    def verticles=[
            "verticle1", "verticle2", "verticle3"
    ].parallelStream().forEach(verticle -> {
        runContentProviderLauncher.args(verticle).exec()
    })
}

代码问题分析 #

• 第二个任务runVerticleLauncherAllVerticles定义为JavaExec类型，但内部直接调用其他任务的exec()方法，违背了Gradle任务生命周期管理逻辑，导致类路径未正确初始化，引发ClassNotFound错误。
• parallelStream()在此处无效，Gradle配置阶段为单线程执行，这种方式无法实现真正的并行运行。
• 代码中引用的runContentProviderLauncher应为runVerticlesThroughLauncher的笔误，导致任务无法找到正确的执行目标。

解决方案 #

方法1：为每个Verticle创建独立任务，并行执行 #

Gradle原生支持任务并行，你可以为每个Verticle单独创建JavaExec任务，再通过聚合任务触发它们并行运行。

// 定义所有Verticle的映射关系
def verticleMap = [
    verticle1: "com.verticles.Verticle1",
    verticle2: "com.verticles.Verticle2",
    verticle3: "com.verticles.Verticle3"
]

// 批量生成单个Verticle的运行任务
verticleMap.each { name, className ->
    task "run${name.capitalize()}"(type: JavaExec) {
        group = "verticles"
        description = "启动${name}"

        File runningDir = new File('..')
        runningDir.mkdirs()
        workingDir runningDir

        classpath = sourceSets.main.runtimeClasspath
        mainClass = "com.main.VerticleLauncher"
        args "run", className
    }
}

// 创建聚合任务，并行执行所有Verticle任务
task runAllVerticles {
    group = "verticles"
    description = "并行启动所有Verticle"
    dependsOn verticleMap.keySet().collect { "run${it.capitalize()}" }
    // 配置并行线程数为Verticle数量
    doFirst {
        gradle.startParameter.maxParallelForks = verticleMap.size()
    }
}

方法2：使用Gradle Worker API并行执行（适合复杂场景） #

如果需要更精细的执行控制，可以用Worker API在单个任务内并行启动多个Verticle，确保每个Worker进程的类路径和环境都正确配置。

import org.gradle.workers.WorkerExecutor
import javax.inject.Inject

task runAllVerticlesWithWorker(type: WorkerTask) {
    group = "verticles"
    description = "通过Gradle Worker API并行启动所有Verticle"

    def verticleList = [
        "com.verticles.Verticle1",
        "com.verticles.Verticle2",
        "com.verticles.Verticle3"
    ]

    verticleList.each { className ->
        workQueue.submit(VerticleRunner.class) { parameters ->
            parameters.className.set(className)
            parameters.classpath.set(sourceSets.main.runtimeClasspath)
            parameters.workingDir.set(new File('..').absolutePath)
        }
    }
}

// 定义Worker执行类
abstract class VerticleRunner implements Runnable {
    @Inject
    abstract WorkerExecutor getWorkerExecutor()

    abstract Property<String> getClassName()
    abstract ConfigurableFileCollection getClasspath()
    abstract Property<String> getWorkingDir()

    @Override
    void run() {
        // 启动Java进程运行Verticle
        project.javaexec {
            it.workingDir = new File(workingDir.get())
            it.classpath = classpath.get()
            it.mainClass = "com.main.VerticleLauncher"
            it.args "run", className.get()
        }.execute()
    }
}

注意事项 #

• 确保sourceSets.main.runtimeClasspath包含所有Vert.x依赖和你的编译类文件，避免ClassNotFound错误。
• 若不同Verticle需要独立配置（如JVM参数、环境变量），可在对应任务中单独设置。
• 并行任务需保证彼此无依赖冲突，所有Verticle任务需完全独立。

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