On 06/06/2011 08:03 PM, John B. Matthews wrote:
In article<TjZGp.40183$Vp.29218@newsfe14.iad>,
Knute Johnson<nospam@knutejohnson.com> wrote:
On 06/05/2011 08:47 PM, John B. Matthews wrote:
[...]
Focusing on invokeAndWait() [1], I understood it to be the standard
way to wait for data to arrive on the EDT. In particular, it
promises to block until the supplied Runnable's run method has been
called on the EDT. I don't understand why the Runnable needs a
synchronized block.
The problem with using invokeAndWait() is that it won't block if the
thread is interrupted and it won't start the Runnable() either.
The InvocationEvent is posted to the event queue and the calling thread
immediately enters wait(). It's up to the AWT event thread to dispatch
the enclosed Runnable.
The synchronized block is to make sure that the data retrieved from the
GUI elements on the EDT were visible to the current thread.
Both invokeAndWait() (on the calling thread) and dispatch() (on the EDT)
synchronize on the (private) AWTInvocationLock.
I've come up with what I think is a better way for the project I'm
working on and that is to use a Semaphore.
Semaphore sem = new Semaphore(1); [...]
This looks appealing; it reminds me of DF's suggestion of Exchanger.
[...]
So John, back to your question about the synchronized block, how
would you get data from the EDT to your current thread without some
sort of synchronization?
Here's my (contrived) sscce. A javax.swing.Timer increments an int at
100 Hz, while a java.util.TimerTask samples the value at 1 Hz. I'd like
the API to be a little more explicit, but it does say that the calling
thread blocks and the Runnable's dispatch "will happen after all pending
events are processed."
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedList;
import java.util.TimerTask;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.Timer;
/** @author John B. Matthews */
public class TwoTimer extends JPanel {
private Timer timer = new Timer(10, null);
private int value;
public TwoTimer() {
final JLabel label = new JLabel("0");
timer.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
label.setText(String.valueOf(value++));
}
});
this.add(label);
}
public int getValue() {
return value;
}
public void startSwingTimer() {
timer.start();
}
public void startUtilTimer() {
final LinkedList<Integer> samples = new LinkedList<Integer>();
java.util.Timer sampler = new java.util.Timer();
sampler.scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
try {
EventQueue.invokeAndWait(new Runnable() {
@Override
public void run() {
samples.add(getValue());
}
});
} catch (InterruptedException ex) {
ex.printStackTrace(System.err);
} catch (InvocationTargetException ex) {
ex.printStackTrace(System.err);
}
System.out.println(samples.getLast());
}
}, 1000, 1000);
}
private void display() {
JFrame f = new JFrame("TwoTimer");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(this);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
}
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
TwoTimer tt = new TwoTimer();
tt.display();
tt.startSwingTimer();
tt.startUtilTimer();
}
});
}
}
your access to the the LinkedList is adequately synchronized. A problem
LinkedList is some incomplete or unstable state in the timer thread. I
think the risk is probably fairly small though. And in this case the
The example I had with the Semaphores could have a similar issue. If