如何实现Jenkins并行阶段的异步执行与跨并行流阶段依赖？

要实现你描述的跨并行流水线的阶段依赖逻辑（Stage B在Stage A完成后启动，Stage C在Stage B完成后运行），可以通过共享状态标记结合when条件判断来实现。核心思路是用变量记录阶段完成状态，让后续阶段通过检查状态来决定是否启动。

以下是符合需求的Declarative Pipeline示例：

pipeline {
    agent any
    environment {
        // 初始化状态标记，用于跟踪阶段完成情况
        A_COMPLETED = false
        B_COMPLETED = false
    }
    stages {
        stage('Parallel Flow') {
            parallel {
                // 分支1：包含Stage A和Stage C
                stage('Branch 1') {
                    stages {
                        stage('Stage A') {
                            steps {
                                echo "Starting Stage A"
                                sleep 5 // 模拟任务执行耗时
                                echo "Completed Stage A"
                            }
                            post {
                                success {
                                    // Stage A成功完成后更新状态标记
                                    script {
                                        env.A_COMPLETED = true
                                    }
                                }
                            }
                        }
                        stage('Stage C') {
                            // 仅当Stage B完成后才执行
                            when {
                                expression { env.B_COMPLETED.toBoolean() }
                            }
                            steps {
                                echo "Starting Stage C (after Stage B completed)"
                                sleep 3 // 模拟任务执行耗时
                                echo "Completed Stage C"
                            }
                        }
                    }
                }
                // 分支2：包含Stage B
                stage('Branch 2') {
                    stages {
                        stage('Stage B') {
                            // 仅当Stage A完成后才执行
                            when {
                                expression { env.A_COMPLETED.toBoolean() }
                            }
                            steps {
                                echo "Starting Stage B (after Stage A completed)"
                                sleep 7 // 模拟任务执行耗时
                                echo "Completed Stage B"
                            }
                            post {
                                success {
                                    // Stage B成功完成后更新状态标记
                                    script {
                                        env.B_COMPLETED = true
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

代码说明： #

• 环境变量：用A_COMPLETED和B_COMPLETED作为状态标记，初始值设为false，用于跨分支传递阶段完成状态。
• Stage A：执行完成后，通过post块的success步骤将A_COMPLETED设为true，触发后续依赖Stage的启动条件。
• Stage B：通过when条件判断A_COMPLETED是否为true，确保只有Stage A完成后才会启动；完成后更新B_COMPLETED为true。
• Stage C：通过when条件判断B_COMPLETED是否为true，保证只有Stage B完成后才会执行。
• 并行块：两个分支同时启动，但内部Stage会根据状态标记按依赖顺序执行，完全匹配你给出的时间线要求。

内容的提问来源于stack exchange，提问作者Di Wang