Worker API 并行化

源：Gradle 官方文档 - Worker API

Worker API 允许任务将工作分解为多个独立单元并行执行，充分利用多核CPU，显著提升构建性能。

Worker API 概念

为什么需要 Worker API

传统任务：

@TaskAction
fun process() {
    files.forEach { file ->
        // 串行处理每个文件
        processFile(file)
    }
}

问题：

• 串行执行
• 无法利用多核
• 处理大量文件慢

Worker API：

@TaskAction
fun process() {
    files.forEach { file ->
        // 并行处理
        workerExecutor.noIsolation().submit(ProcessWorkAction::class) {
            inputFile.set(file)
        }
    }
}

优势：

• 并行执行
• 充分利用CPU
• 提升性能

---

基本用法

定义 WorkAction

abstract class ProcessWorkAction : WorkAction<ProcessWorkAction.Parameters> {
    interface Parameters : WorkParameters {
        val inputFile: RegularFileProperty
        val outputFile: RegularFileProperty
    }
    
    override fun execute() {
        val input = parameters.inputFile.get().asFile
        val output = parameters.outputFile.get().asFile
        
        // 处理文件
        val content = input.readText()
        output.writeText(content.uppercase())
    }
}

提交工作

abstract class ParallelProcessTask : DefaultTask() {
    @get:Inject
    abstract val workerExecutor: WorkerExecutor
    
    @get:InputFiles
    abstract val inputFiles: ConfigurableFileCollection
    
    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty
    
    @TaskAction
    fun process() {
        inputFiles.forEach { file ->
            workerExecutor.noIsolation().submit(ProcessWorkAction::class) {
                inputFile.set(file)
                outputFile.set(outputDir.file(file.name))
            }
        }
    }
}

---

工作单元隔离

noIsolation 无隔离

workerExecutor.noIsolation().submit(MyWorkAction::class) {
    // 参数配置
}

特点：

• 共享类加载器
• 性能最好
• 适合大多数场景

classLoaderIsolation 类加载器隔离

workerExecutor.classLoaderIsolation {
    classpath.from(configurations.named("myClasspath"))
}.submit(MyWorkAction::class) {
    // 参数配置
}

特点：

• 独立类加载器
• 避免类冲突
• 性能适中

processIsolation 进程隔离

workerExecutor.processIsolation {
    forkOptions {
        maxHeapSize = "512m"
        systemProperty("file.encoding", "UTF-8")
    }
}.submit(MyWorkAction::class) {
    // 参数配置
}

特点：

• 独立进程
• 完全隔离
• 性能最慢
• 适合不稳定的代码

---

参数传递

WorkParameters

interface MyParameters : WorkParameters {
    val message: Property<String>
    val count: Property<Int>
    val inputFile: RegularFileProperty
}

abstract class MyWorkAction : WorkAction<MyParameters> {
    override fun execute() {
        println(parameters.message.get())
        println(parameters.count.get())
        println(parameters.inputFile.get().asFile.name)
    }
}

传递参数

workerExecutor.noIsolation().submit(MyWorkAction::class) {
    message.set("Hello")
    count.set(42)
    inputFile.set(file("input.txt"))
}

---

等待完成

await

@TaskAction
fun process() {
    inputFiles.forEach { file ->
        workerExecutor.noIsolation().submit(ProcessWorkAction::class) {
            inputFile.set(file)
        }
    }
    
    // 等待所有工作完成
    workerExecutor.await()
    
    println("All work completed")
}

---

实战案例

案例1：图片压缩

interface ImageParameters : WorkParameters {
    val inputImage: RegularFileProperty
    val outputImage: RegularFileProperty
    val quality: Property<Int>
}

abstract class CompressImageAction : WorkAction<ImageParameters> {
    override fun execute() {
        val input = parameters.inputImage.get().asFile
        val output = parameters.outputImage.get().asFile
        val quality = parameters.quality.get()
        
        // 压缩图片
        ImageIO.read(input).let { image ->
            val writer = ImageIO.getImageWritersByFormatName("jpg").next()
            val param = writer.defaultWriteParam
            param.compressionMode = ImageWriteParam.MODE_EXPLICIT
            param.compressionQuality = quality / 100f
            
            output.outputStream().use { stream ->
                writer.output = ImageIO.createImageOutputStream(stream)
                writer.write(null, IIOImage(image, null, null), param)
            }
        }
    }
}

abstract class CompressImagesTask : DefaultTask() {
    @get:Inject
    abstract val workerExecutor: WorkerExecutor
    
    @get:InputFiles
    abstract val images: ConfigurableFileCollection
    
    @get:OutputDirectory
    abstract val outputDir: DirectoryProperty
    
    @get:Input
    abstract val quality: Property<Int>
    
    @TaskAction
    fun compress() {
        images.forEach { image ->
            workerExecutor.noIsolation().submit(CompressImageAction::class) {
                inputImage.set(image)
                outputImage.set(outputDir.file(image.name))
                quality.set(this@CompressImagesTask.quality)
            }
        }
    }
}

tasks.register<CompressImagesTask>("compressImages") {
    images.from("src/main/res/drawable-xxhdpi")
    outputDir.set(layout.buildDirectory.dir("compressed"))
    quality.set(85)
}

案例2：代码格式化

interface FormatParameters : WorkParameters {
    val sourceFile: RegularFileProperty
}

abstract class FormatCodeAction : WorkAction<FormatParameters> {
    override fun execute() {
        val file = parameters.sourceFile.get().asFile
        val code = file.readText()
        
        // 格式化代码（示例）
        val formatted = code
            .replace("  ", "    ")  // 2空格转4空格
            .replace("\r\n", "\n")  // 统一换行符
        
        file.writeText(formatted)
    }
}

abstract class FormatCodeTask : DefaultTask() {
    @get:Inject
    abstract val workerExecutor: WorkerExecutor
    
    @get:InputFiles
    abstract val sources: ConfigurableFileCollection
    
    @TaskAction
    fun format() {
        sources.forEach { source ->
            workerExecutor.noIsolation().submit(FormatCodeAction::class) {
                sourceFile.set(source)
            }
        }
        
        workerExecutor.await()
        println("Formatted ${sources.files.size} files")
    }
}

案例3：并行测试

interface TestParameters : WorkParameters {
    val testClass: Property<String>
    val reportFile: RegularFileProperty
}

abstract class RunTestAction : WorkAction<TestParameters> {
    override fun execute() {
        val className = parameters.testClass.get()
        val report = parameters.reportFile.get().asFile
        
        // 运行测试
        val result = runTest(className)
        
        // 写入报告
        report.writeText("Test: $className, Result: $result")
    }
    
    private fun runTest(className: String): String {
        // 实际测试逻辑
        return "PASSED"
    }
}

abstract class ParallelTestTask : DefaultTask() {
    @get:Inject
    abstract val workerExecutor: WorkerExecutor
    
    @get:Input
    abstract val testClasses: ListProperty<String>
    
    @get:OutputDirectory
    abstract val reportsDir: DirectoryProperty
    
    @TaskAction
    fun runTests() {
        testClasses.get().forEach { testClass ->
            workerExecutor.processIsolation().submit(RunTestAction::class) {
                this.testClass.set(testClass)
                reportFile.set(reportsDir.file("$testClass.txt"))
            }
        }
    }
}

---

性能优化

控制并发数

@TaskAction
fun process() {
    val semaphore = Semaphore(Runtime.getRuntime().availableProcessors())
    
    files.forEach { file ->
        semaphore.acquire()
        workerExecutor.noIsolation().submit(ProcessWorkAction::class) {
            inputFile.set(file)
        }
    }
}

批处理

@TaskAction
fun process() {
    val batches = files.chunked(10)  // 每批10个文件
    
    batches.forEach { batch ->
        workerExecutor.noIsolation().submit(BatchProcessAction::class) {
            inputFiles.set(batch)
        }
    }
}

---

最佳实践

选择适当的隔离级别：

• 默认使用 noIsolation
• 类冲突时使用 classLoaderIsolation
• 不稳定代码使用 processIsolation

合理分解工作：

• 每个工作单元独立
• 避免共享可变状态
• 工作量适中

使用 WorkParameters：

• 不要使用构造函数传参
• 使用 Property API
• 支持序列化

等待完成：

workerExecutor.await()  // 确保所有工作完成

异常处理：

override fun execute() {
    try {
        // 工作逻辑
    } catch (e: Exception) {
        logger.error("Work failed", e)
        throw e
    }
}

性能监控：

val start = System.currentTimeMillis()
workerExecutor.await()
val duration = System.currentTimeMillis() - start
println("Completed in ${duration}ms")