Pass parameter to Runnable invoked by SwingUtil.invokeLater()

Question

Hi there,
I just got trapped by a Threading problem in my SwingApplet:
The Applet parses XML Documents it receives from a Servlet and dynamically creates a GUI from that description, using Swing Components. (actually Applet and Servlet exchange a Queue of JAVA Objects, each representing a fraction of the complete GUI Description or causing the Applet to show a certain URL, for example)
Getting the XML Documents is done in an extra Thread (not the EventDispatchThread), since that might take a while. For doing the actual update of the Swing Components I use SwingUtilities.invokeLater(Runnable doc).
doc is my internal Representation of the GUI, doc.run() does the actual Parsing and GUI Updating.
My Question is: How can I pass doc the Message it has to parse in a way that subsequent calls to invokeLater(doc) (which - as I mentioned - are done in another Thread) cannot disturb the processing of the previous call?
My actual (pseudo-)code tries it this way:
Executed in Calling Thread:
private void callSwing(PWDocumentGui doc)
try
Iterator it = fromserver.getInqueue().iterator();
while (it.hasNext())
PWMessage msg = (PWMessage) it.next();
doc.setContent(msg);
Thread.sleep(2000); // makes it work for the moment - but thats extremely unsafe!!
it.remove();
catch (Exception e)
System.err.println(e);
Internal Document representing the GUI:
class PWDocumentGui extends Observable implements Runnable
private InternalModel internalmodel; // holds internal Model of GUI (Arrays of Swing Components
private String onemessage; // holds one message to be parsed: VALUE IS THE PROBLEM !
public void synchronized setContent(String themessage)
onemessage = themessage; // remeber the Message to be parsed
SwingUtilities.invokeLater(this) // call this.run() in EventThtead
// Called in Event Thread
// value of onemessage in the meantime might be overwritten by subsequent call to setContent().
public void run()
// do the parsing into the local and thus update internalmodel
parse(onemessage);
// Notify Observers (the Renderers registered as Observers of this) that they should update themselves
// accordicg to internalmodel
setChanged()
notifyObservers();
public InternalModel getModel() {    return internalmodel;   }
I suspect that the solution might be easy - for someone more relaxed...
This might be a question concerning design, not Swing, I think.
Thanks for any answer!
Uwe

Answer 1

Try creating an inner class which implements runnable.
Give the inner class members to hold the parameters you want to pass.
Implement the inner class's run() to check the variables and use them.
When calling invoke later create a new instance of the inner class, initialise the members for the parameter values and pass the inner class instance to invokeLater rather than the object of the main class.
In this way you get one copy of the parameters for every call to invoke later.