从可运行线程返回值

Question

There are N thread and each thread sets status to 0 or 1 in its own member variable "status". In caller, if any one thread has 1 as status, overall status has to become 1.

These threads run in batch mode. So if any fails all need to be run again. I need to come up with some Handling for handling failure such that remaining threads also halt immediately.

The Threads are Runnable however, not Callable.

We can communicate between threads using a volatile boolean variable to signal failure. However, I needed to know how to read individual status from runnable threads in caller.

Answer 1

Theres several ways to accomplish this, I'm sure. One way is to use a completion service. Here's some (roughly tested) code:

public void allSucceed(final List<MyRunnable> tasks) {
    if (tasks == null || tasks.size() == 0)
        return;

    int status = 0;

    boolean success = true;
    do {
        final ExecutorService executorService = Executors
                .newFixedThreadPool(tasks.size());
        final CompletionService<MyRunnable> completionService = new ExecutorCompletionService<MyRunnable>(
                executorService);
        for (final MyRunnable task : tasks) {
            completionService.submit(task, task);
        }

        for (int i = 0; i < tasks.size(); i++) {
            try {
                status = completionService.take().get().getStatus();
            } catch (final Exception e) {
                success = false;
                break;
            }

            if (status == 0) {
                System.out.println("A task failed. All will be rerun");
                executorService.shutdownNow();
                success = false;
                break;
            }
        }
    } while (!success);
}

It's critical that you design your tasks (Runnables) to be interruptible, or else any attempt to halt them will be futile.

Answer 2

You can simply ask the threads set a value in the caller's thread:

Field in caller:

int[] status = new int[NUM_THREADS];

Then give an index to each Runnable so it can set its status in the array, for example:

for (int i = 0; i < NUM_THREADS; i++) {
    final index = i;

    Runnable r = new Runnable() {
        void run() {
            // have your code stop occasionally to check for any failures
            if (>I failed>)
                status[index] = 1;
        }
    }
    // start thread using Runnable
}

To detect halting, have your Runnables occasionally check for any failures in the arraym or you could have add separate boolean flag to your caller class:

volatile boolean failed = false;
Object lock = new Object();

then in your runnables:

if (<I failed>) {
    synchronised (lock) {
        failed = true;
    }
}

and your check for failure during the work would be:

synchronised (lock) {
    if (failed) {
        // clean up resources
        status[index] = -1; // consider using a separate value for "halted"
        return;
    }
}