It's generally a good idea not to extend Thread (or any other class that
you do not need to inherit from). Instead pass a Runnable.

If you use anonymous inner classes, you can avoid having to explicitly
pass in values.

If you have just started the thread, it probably hasn't finished (or
started) populating the list yet

So:

final List<String> strs = new ArrayList<String>();
Thread thread = new Thread(new Runnable() { public void run() {
            strs.add("a string");
}});
thread.start();
// Perhaps do something else here,
//   otherwise there is little point in starting another thread.
thread.join();
System.err.println(strs);

Tom Hawtin

If you can use Java 1.5 (and I suggest that you should)
Look into the java.util.concurrent package.
Specifically, Instead of starting threads directly with Runnable
instances, use Callable and Executors
<http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/Callable.html>

Baring that, you could do it this way:
class MyRunnable implements Runnable {
 private int value;

 private final List<MyResultClass> list = new
ArrayList<MyResultClass>();
 boolean ready = false;
 public MyRunnable(int value) {
   this.value = value;
 }

 public void run() {

    synchronize(list) {
      try {
      for (int i = 0; i < value; ++i) {
        list.add(new MyResultClass(i));
      }
      } finally {
        ready = true;
        list.notifyAll();
      }
   }
 }

 public List<MyResultClass> getList() throws InterruptedException {
    synchronize(list) {
       while (!ready) {
          list.wait();
       }
    }
 }
}

Then you could do this:
MyRunnable myRunnable = new MyRunnable(value);
Thread t = new Thread(myRunnable);
t.start();
myRunnable.getList();

The only problem with this approach is that getList() waits (and it has
to wait anyway) for the thread to complete.  This gives you nearly the
same effect as running this program without any threads.

In reality, you'd be better to have your worker (MyRunnable in my case)
fire some sort of event.

Hope this helps,
Daniel.