Drawing Thread and join()

Question

Hi, I need some hints about Threads.
I have a Thread that does some computations and then draws on a Graphics object.
I need the main program to wait until the Thread finish its computation.
If i call:
myThread.join()
from the main control flow, it correctly waits but I can't see anything drawn on the screen.
If I instead don't call join the draw is correct but obviously I don't have a correct execution
of the program.
Where am I doing a mistake?

Answer 1

Ok having read the other thread, I'll try to take a stab at helping you:
My understanding of the problem: You require a GUI with a button that will start an algorithm (locate) and will paint back progress to the GUI as it goes.
How to go about doing this:
You have one thread, the thread that is started when you start your program. We call this the EDT (the Event dispatching thread). The EDT should not be blocked by heavy, lengthy calls, as it is responsible for "refreshing" or repainting the GUI.
So, when someone clicks your Button, you must:
-Start a new thread like this (this is from my head, so the code may be wrong) :
  new Thread( new Runnable() {
     public void run() {
       locate();
  }).start();Call this new thread the WORKER thread
Now, each time you want to update the GUI from your WORKER thread (your algorithm), you need to do two things:
-change some state of your main running class, to tell the GUI what it should draw next time it's asked. What was suggested in that other post was that you should maintain a list of "steps" in a Collection of some sort.
-prompt the main container that your drawing to to redraw, using repaint() or something (sorry, it's been years since I've used Swing or AWT).
So, your WORKER thread updates the abstract model of what your GUI SHOULD show, but when your WORKER calls repaint(), the EDT prompts your class to redraw.
As for general concepts with threads, I'll give you one example of how to handle things asynchronously. Say you had this simple Java snippet:
public void someMethod()
  doSomethingBefore();
  doSomethingLengthy();
  doSomethingAfter();
}And you wanted to doSomethingLengthy in a separate thread. You would use something that we call "callbacks". This implements a callback using the Runnable interface:
public void someMethod()
  doSomethingBefore();
  final Runnable callback = new Runnable() {
     public void run() {
        doSomethingAfter();
  new Thread( new Runnable() {
     public void run() {
       doSomethingLengthy();
       callback.run();
  }.start();
}So what's the execution look like?
Thread1 executes someMethod()
Thread1 executes doSomethingBefore()
Thread1 starts Thread2 and then immediatly exits someMethod()
Thread2 executes doSomethingLengthy()
Thread2 executes callback.run()
Thread2 executes doSomethingAfter()