Making one or more threads wait for another to produce a value or fail

The scenario:

Penelope is a widow, or at least her husband isn't around any more (she's
not sure which; long story). There are 108 suitors who would like to marry
her. She hasn't decided which one she'll marry. So, the 108 suitors are
sitting about waiting for her to decide. It's possible that instead of
deciding to marry one of them, she'll deliver some other, exceptional,
verdict (eg "turns out my husband is still alive, and will now murder you
all").

Penelope is a thread, as are her suitors. Penelope has plenty to do after
she delivers her verdict, so the verdict is not a return value - it's a
value she'll pass to a method. In code, this looks something like:

class Penelope implements Runnable {
  public void run() {
  try {
  Verdict v = ... ;
  DELIVER(v);
  }
  catch (Exception e) {
  DELIVER_EXCEPTION(e);
  }
  }
}

class Suitor implements Runnable() {
  public void run() {
  try {
  Verdict v = AWAIT();
  }
  catch (Exception e) {
  // alas
  }
  }
}

There has got to be something in java.util.concurrent that she can use to
deliver her verdict. What?

In terms of synchronisation, CountdownLatch with a count of 1 does it -
the suitors await, and Penelope counts down. But it has no way to pass a
value.

A blocking queue does synchronisation and delivers a value, but it only
delivers the value once - if the suitors all queue up on take(), only the
first will get the verdict.

A Future<Verdict> looks ideal - it provides synchronisation, and a value,
and provides the same value to all requesters once it's delivered, and
also handles failure and cancellation. But i don't see an easy way to make
one for a simple value. There is FutureTask, but that seems more geared to
wrapping Callable and Runnable.

Any suggestions?

Thanks,
tom

--
People don't want nice. People want London. -- Al