Jenkins基础教程（164）在Jenkins 中并行构建：Jenkins并行构建全攻略：让你的流水线速度起飞

每次看着Jenkins任务串行执行时那缓慢的进度条，是不是总觉得它在考验你的耐心？别急，并行构建能让你的效率翻倍。

1 Jenkins并行构建基础概念

1.1 为什么需要并行构建？

想象一下，如果你有一个需要30分钟执行的测试套件，每次代码提交都要等待半小时才能得到反馈，这将会严重拖慢开发进度。使用并行构建，你可以将这个测试套件拆分成多个部分同时运行，可能将时间减少到仅仅10分钟。

并行构建的优势显而易见：

减少整体构建时间：并行执行能显著提升任务完成速度，尤其适用于CPU或I/O密集型任务。提高资源利用率：充分利用Jenkins的Executor，避免资源闲置。支持可扩展性：随着项目规模扩大，任务数量增加，仍能保持较高的执行效率。

1.2 Jenkins并行的核心机制

Jenkins默认情况下一个Job是串行执行的，即一次只能运行一个实例。但Jenkins支持并发构建，也就是说，同一个Job可以同时运行多个实例。

每个并发执行的构建都发生在它自己的构建工作区中，独立于任何其他构建。默认情况下，Jenkins将"@"附加到工作区目录名称，例如"@2"。这就是为什么多个构建不会冲突的秘诀——它们实际上在不同的目录中运行。

2 Jenkins并行构建的四种实现方式

2.1 单机多Executors并行

这是最简单的并行方式，通过在Manage Jenkins → Configure System调整Executors数量（建议不超过CPU物理核心数），同一节点上可同时运行多个构建任务。

配置步骤：

登录Jenkins控制台，进入"Manage Jenkins" → "Configure System"。找到"# of executors"选项，设置适合你机器性能的数量。保存设置。

这种方式适合轻量任务与快速构建，是入门并行构建的最简单方法。

2.2 Pipeline并行阶段

Jenkins Pipeline允许你定义复杂的构建流程，并且可以通过parallel步骤来实现多任务并行。这是目前最常用且灵活的并行构建方法。

基础并行示例：

pipeline {
  agent any
  stages {
    stage('并行构建') {
      parallel {
        stage('构建前端') {
          steps { 
            echo 'Building frontend...'
            // 这里是前端构建命令
          }
        }
        stage('构建后端') {
          steps { 
            echo 'Building backend...'
            // 这里是后端构建命令
          }
        }
      }
    }
  }
}

带超时与错误处理的并行：

在实际生产环境中，我们还需要为并行任务添加超时控制和错误处理机制：

pipeline {
  agent any
  stages {
    stage('并行构建与超时防护') {
      parallel {
        stage('构建前端') {
          options { timeout(time: 30, unit: 'SECONDS') }
          steps {
            echo 'Building frontend...'
            // 如果执行时间超过30秒，将会自动超时
          }
        }
        stage('构建后端') {
          options { timeout(time: 45, unit: 'SECONDS') }
          steps { 
            echo 'Building backend...'
            // 后端构建命令
          }
        }
      }
    }
  }
}

parallel块内各分支同时启动，整体耗时≈最慢分支；任一分支失败会终止整个并行块。

2.3 多节点分布式并行

当你的项目越来越大，单台机器无法满足需求时，可以使用多节点分布式并行。通过在Manage Jenkins → Manage Nodes and Clouds添加Agent/节点，通过标签调度把任务分发到不同机器，横向扩展构建能力。

配置多节点步骤：

进入Manage Jenkins → Manage Nodes and Clouds → New Node。配置Labels（如：linux、docker、gpu），并确保节点安装了Java与所需构建工具。在Job配置中使用Restrict where this project can be run指定标签，或在Pipeline中使用agent { label 'linux' }。

多节点并行Pipeline示例：

pipeline {
  agent none
  stages {
    stage('构建与测试') {
      parallel {
        stage('在Linux上构建') {
          agent { label 'linux' }
          steps {
            echo 'Building on Linux...'
            // Linux特定构建命令
          }
        }
        stage('在Windows上测试') {
          agent { label 'windows' }
          steps {
            echo 'Testing on Windows...'
            // Windows特定测试命令
          }
        }
      }
    }
  }
}

这种方式特别适用于CPU/内存密集型任务、隔离环境测试、跨机房/跨地域构建，能显著提升并发与稳定性。

2.4 动态并行构建

有时候我们不知道需要并行执行多少个任务，比如当项目数量会随时间变化时。这时候静态定义的并行阶段就不够用了，我们需要动态并行构建。

动态检测项目并构建的示例：

def parallelStages = [:]
def projectsToBuild = []
 
pipeline {
  agent any
  stages {
    stage("发现项目") {
      steps {
        script {
          // 查找所有包含Makefile的目录
          def files = findFiles(glob: '**/Makefile')
          files.each { f ->
            def projectDir = f.path.substring(0, f.path.lastIndexOf('/'))
            projectsToBuild.add(projectDir)
          }
        }
      }
    }
    stage("并行构建所有项目") {
      steps {
        script {
          projectsToBuild.each { project ->
            parallelStages[project] = {
              node {
                stage(project) {
                  dir(project) {
                    sh 'make && make test'
                  }
                }
              }
            }
          }
          parallel parallelStages
        }
      }
    }
  }
}

这种方法特别适合monorepo（单体仓库）项目，当添加新项目时，无需修改Jenkinsfile，它会自动检测并构建所有项目。

3 高级并行构建技巧

3.1 使用Parameterized Trigger Plugin实现并行触发

Parameterized Trigger插件允许你从一个主Job中触发多个子Job，并传递参数。

安装步骤：

打开Jenkins控制台，进入Manage Jenkins > Manage Plugins。在Available标签下搜索Parameterized Trigger Plugin。勾选插件，点击Install without restart。

使用示例：

pipeline {
  agent any
  stages {
    stage('触发并行任务') {
      steps {
        script {
          def configs = ['config1', 'config2', 'config3']
          def parallelSteps = [:]
 
          configs.each { config ->
            parallelSteps[config] = {
              build job: 'TargetJob', 
                parameters: [string(name: 'CONFIG', value: config)],
                wait: false
            }
          }
 
          parallel parallelSteps
        }
      }
    }
  }
}

上述代码中，我们通过parallel方法并行触发了多个TargetJob，每个Job都带有不同的CONFIG参数。 wait: false表示主Job不等待子Job完成。

3.2 使用Groovy脚本实现复杂并行逻辑

对于需要更复杂逻辑的并行构建，我们可以直接使用Groovy脚本：

pipeline {
  agent none
  stages {
    stage('运行并行任务') {
      steps {
        script {
          def parallelJobs = [:]
          def configurations = ['config1', 'config2', 'config3']
 
          configurations.each { config ->
            parallelJobs["Job for ${config}"] = {
              node {
                stage("Running ${config}") {
                  echo "Executing job for ${config}"
                  sh "echo 'Performing task for ${config}'"
                  // 这里执行实际构建任务
                }
              }
            }
          }
 
          parallel parallelJobs
        }
      }
    }
  }
}

这种方法更加灵活，可以动态调整并行数量，所有逻辑集中在一个文件中，便于版本控制。

3.3 并行测试执行

对于大型测试套件，使用并行测试可以显著减少反馈时间。Parallel Test Executor插件专为并行执行测试任务设计。

配置示例：

pipeline {
  agent any
  stages {
    stage('运行并行测试') {
      steps {
        parallelTestExecutor(
          parallelism: 3,
          testJob: 'TestJob',
          testReportParallelism: 3,
          testReportFiles: '**/target/surefire-reports/*.xml'
        )
      }
    }
  }
}

该插件会自动将不同的测试用例分配给多个Job实例并行执行，最后汇总结果。

4 Jenkins并行构建的最佳实践

4.1 资源管理与优化

合理配置Jenkins资源是确保并行构建顺利运行的关键：

Executors数量：在Manage Jenkins → Configure System设置Executors，通常不超过CPU物理核心数。内存优化：确保Jenkins master和agent有足够内存，大型项目可能需要调整JVM参数。存储优化：为Maven/Gradle启用依赖缓存，减少重复下载。

4.2 错误处理与重试机制

在并行构建中，合理的错误处理至关重要：

stage('带重试的并行构建') {
  parallel {
    stage('前端构建') {
      options { retry(3) }
      steps {
        sh 'npm install && npm run build'
      }
    }
    stage('后端构建') {
      options { timeout(time: 15, unit: 'MINUTES') }
      steps {
        sh 'mvn clean compile'
      }
    }
  }
}

4.3 性能监控与优化

要确保并行构建真正提高了效率，需要监控以下指标：

构建时间趋势资源利用率（CPU、内存、磁盘I/O）队列中的构建等待时间构建成功率

可以使用Jenkins的Built-in metrics或安装额外监控插件来跟踪这些指标。

5 常见问题与解决方案

5.1 工作区冲突问题

问题：当启用并发构建时，如果未正确配置工作区，可能会导致构建间冲突。

解决方案：Jenkins默认情况下会为每个并发构建创建独立的工作区，通过在工作区目录名称后附加"@"和数字来实现。例如，对于名为"my-project"的工作区，第一个构建使用"my-project"，第二个并发构建使用"my-project@2"，以此类推。

5.2 资源竞争与死锁

问题：当多个并行任务竞争相同资源（如数据库、端口等）时，可能会发生资源竞争或死锁。

解决方案：

为每个并行任务使用独立的资源（如测试数据库）使用资源锁定机制确保任务之间充分隔离

5.3 并行度平衡

问题：如何确定最优的并行任务数量？

解决方案：并行度不是越多越好。理想的并行度取决于：

可用执行器数量任务特性（CPU密集型、I/O密集型）外部依赖和资源限制

通常从适度的并行度开始（如CPU核心数），根据实际情况调整。

结论

Jenkins并行构建是现代软件开发中提升CI/CD效率的利器。通过合理使用Pipeline并行阶段、多节点分布式构建和动态并行等技术，可以显著缩短构建时间，提高开发团队的生产力。

需要注意的是，并行化各种构建有助于加快CI，但不会使每个单独的构建更快。如果一个项目的构建时间为45分钟，那么当它与另一个项目并行运行时，其构建时间仍是45分钟。

从简单的单机多Executors并行到复杂的多节点动态并行，Jenkins提供了多种方案满足不同场景的需求。掌握这些技术，能让你的开发流程如虎添翼，真正实现持续集成和持续交付的价值。

开始尝试在你的项目中使用并行构建吧，你会发现等待构建完成的时间大大减少，从而有更多时间专注于编写高质量的代码！