JMeter：测试计划所有线程全部通过时如何设置变量

Hey there! Let's figure out how to set up a global flag to track when all your threads have completed successfully. Since you didn't specify which programming language you're working with, I'll cover common approaches for a few popular ones—pick what fits your stack!

Python Approach #

For Python, the threading module gives you a couple solid options. A combination of a thread-safe counter and an Event works really well here. The Event acts as your global "all passed" flag, and we use a lock to safely update a counter as threads finish successfully.

import threading

# Global state: thread-safe counter, lock, and completion flag
completed_successfully = 0
counter_lock = threading.Lock()
all_threads_passed = threading.Event()

def thread_task(thread_id, total_threads):
    global completed_successfully
    # Replace this with your actual task logic
    task_passed = True  # Set to False if your task fails

    with counter_lock:
        if task_passed:
            completed_successfully += 1
            # Check if all threads have passed
            if completed_successfully == total_threads:
                all_threads_passed.set()

# Example usage: start 3 threads
total_threads = 3
threads = []
for i in range(total_threads):
    t = threading.Thread(target=thread_task, args=(i, total_threads))
    threads.append(t)
    t.start()

# Wait until the "all passed" flag is triggered
all_threads_passed.wait()
print("✅ All threads have passed successfully!")

Java Approach #

In Java, CountDownLatch is a go-to tool for this scenario. Pair it with an AtomicBoolean to track if any thread failed, and you'll have a robust solution.

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;

public class ThreadCompletionTracker {
    private static CountDownLatch completionLatch;
    private static AtomicBoolean anyThreadFailed = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
        int totalThreads = 3;
        completionLatch = new CountDownLatch(totalThreads);

        for (int i = 0; i < totalThreads; i++) {
            new Thread(() -> {
                try {
                    // Replace with your task logic
                    boolean taskPassed = true;
                    if (!taskPassed) {
                        anyThreadFailed.set(true);
                    }
                } finally {
                    // Decrement the latch regardless of success/failure
                    completionLatch.countDown();
                }
            }).start();
        }

        // Wait for all threads to finish
        completionLatch.await();

        if (!anyThreadFailed.get()) {
            System.out.println("✅ All threads have passed successfully!");
        } else {
            System.out.println("❌ Some threads failed.");
        }
    }
}

C# Approach #

For C#, you can use CountdownEvent for older thread-based code, or leverage Task.WhenAll for modern async/await patterns. Here's both options:

Thread-Based with CountdownEvent #

using System;
using System.Threading;

class Program {
    static CountdownEvent completionEvent;
    static bool anyThreadFailed = false;
    static object failureLock = new object();

    static void Main() {
        int totalThreads = 3;
        completionEvent = new CountdownEvent(totalThreads);

        for (int i = 0; i < totalThreads; i++) {
            ThreadPool.QueueUserWorkItem(ThreadTask);
        }

        completionEvent.Wait();

        lock (failureLock) {
            if (!anyThreadFailed) {
                Console.WriteLine("✅ All threads have passed successfully!");
            } else {
                Console.WriteLine("❌ Some threads failed.");
            }
        }
    }

    static void ThreadTask(object state) {
        try {
            // Replace with your task logic
            bool taskPassed = true;
            if (!taskPassed) {
                lock (failureLock) {
                    anyThreadFailed = true;
                }
            }
        } finally {
            completionEvent.Signal();
        }
    }
}

Modern Async/Await with Tasks #

using System;
using System.Threading.Tasks;

class Program {
    static async Task Main() {
        int totalTasks = 3;
        Task[] tasks = new Task[totalTasks];

        for (int i = 0; i < totalTasks; i++) {
            tasks[i] = Task.Run(() => {
                // Replace with your task logic
                bool taskPassed = true;
                if (!taskPassed) {
                    throw new Exception("Task failed");
                }
            });
        }

        try {
            await Task.WhenAll(tasks);
            Console.WriteLine("✅ All tasks have passed successfully!");
        } catch (AggregateException) {
            Console.WriteLine("❌ Some tasks failed.");
        }
    }
}

Key Things to Remember #

• Thread Safety: Always protect shared state (like counters or failure flags) with locks or atomic classes—otherwise, you'll get race conditions that break your flag logic.
• Failure Handling: Don't just track completion—make sure you account for threads that fail their tasks, so your "all passed" flag only triggers when every thread succeeds.
• Cleanup: For synchronization objects like CountDownLatch or CountdownEvent, remember to dispose of them when you're done (where applicable) to avoid resource leaks.

内容的提问来源于stack exchange，提问作者Taz 3497