Java threads question

Ph4g3 · 7 months

Here is one solution. Basically tell each thread to wait on the next before completing.

Thread[] threads = makeMyThreads();

for(Thread t : threads)
{
    t.start();
}

try
{
    for(Thread t : threads)
    {
        t.join();
    }
}
catch(Exception e){ /*Do your own cleanup*/}
finally
{
    //Update JTextfield
}

That whole article I linked is a good resource for threads. It's a relatively easy read and goes through the basics of threads.

ModernRonin · 7 months

My professor gave extra credit to figure out how to report that all ten threads are done

There's about twenty ways.

It's tempting to create all the threads in a single ThreadGroup and then use ThreadGroup.activeCount(). But the javadocs say that activeCount() isn't always accurate. Shit like this drives me completely insane - I don't understand why you could give someone an API call and then say, "Dur! Hur! This API call doesn't do what I said it would. Ha, sucker!" Maybe this is why Sun went out of business.

If you can change the code in the threads' run() method, you could make run() call a threadHasFinished() synchronized method on some public object as the last thing they do. The threadHasFinished() method can keep a internal counter, and when the counter gets to 10, all the threads are done, and it changes the text field. Seems to me there is a small possibility of a race condition here - the thread could get suspended just after it returns from the threadHasFinished() call, but just before run() actually exits.

You could spawn ten more threads, each one calling join() on one of the original ten threads. When join() returns, the original thread is dead. Just watch out for an InterruptedException that may kick you out of the join() early. Catch this and call join() again.

You could set up a timer, and every time the timer goes off, call isAlive() on all ten threads. (You'll have to keep all ten threads in an array somewhere so you can call their .isAlive() method.) When all ten threads are dead, kill your timer, and then change the text field.

blargle · 7 months

take a look at http://download.oracle.com/javase/1,5,0/docs/api/java/util/concurrent/CountDownLatch.html

Zomgondo · 7 months

Spawn a new thread. You'll use this to launch the 10 threads you need.
Inside that thread, spawn your worker threads and store them in a List:

List<Thread> myThreads = new ArrayList<Thread>();

// create threads and toss them in your list
Have the spawning thread call join() on all 10 threads.

for (Thread thread: myThreads) try { thread.join(); } catch (InterruptedException ie) {}
As soon as step #3 is complete, all 10 threads have died, update your JTextField.

There are other ways to do it, but this one is straightforward and doesn't require any knowledge of anything other than the Thread class... I'm not a fan of most of Java's more advanced threading management stuff.

SBoots · 7 months

I've done something like this before.... not sure how correct it is but it seems to work (this isn't tested)

public abstract class CallbackRunnable implements Runnable {    
    public interface ICallbackRunnable {
        void onWorkComplete();
    }

    private ICallbackRunnable _callback = null;

    public CallbackRunnable(ICallbackRunnable callback) {
        _callback = callback;
    }

    @Override
    public void run() {
        work();
        if (_callback != null)
            _callback.onWorkComplete();
    }

    public abstract void work();

}

public class test {

    public static void main(String[] args) {
        ICallbackRunnable callback = new ICallbackRunnable() {          
            @Override
            public void onWorkComplete() {
                // thread just finished!
            }
        };

        CallbackRunnable newThreadRunnable = new CallbackRunnable(callback) {           
            @Override
            public void work() {
                // do whatever
            }
        };

        Thread newThread = new Thread(newThreadRunnable);
        newThread.start();

        // thread will start, do work() and then execute the callback when it's done

    }

}

Basically just creating a class that implements Runnable and in run() calling the user defined work() method and then a callback to let the user know it's done.

merz1254 · 7 months

Call "join()" for each thread. "join()" causes the main thread to wait until that thread is complete, then it will return letting the main thread to continue.

Win32 API has a WaitForMultipleObjects function which you can pass a multitude of handles to do this process for you. Java may have a thread container that does something similar.

KayRice · 7 months

A queue with synchronize will work for the extra credit.

you'll need to login or register to do that

create a new account

login