jdk-sandbox: comparison jdk/src/share/classes/java/awt/EventQueue.java

equal deleted inserted replaced

-:4b4427db3536
+:4ac67034e98b
 import sun.awt.AWTAutoShutdown;
 import sun.awt.PeerEvent;
 import sun.awt.SunToolkit;
 import sun.awt.EventQueueItem;
 import sun.awt.AWTAccessor;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
 /**
 * <code>EventQueue</code> is a platform-independent class
 * that queues events, both from the underlying peer classes
 * and from trusted application classes.
 * The previous EventQueue on the stack, or null if this is the
 * "base" EventQueue.
 */
 private EventQueue previousQueue;
+/*
+* A single lock to synchronize the push()/pop() and related operations with
+* all the EventQueues from the AppContext. Synchronization on any particular
+* event queue(s) is not enough: we should lock the whole stack.
+*/
+private final Lock pushPopLock;
+private final Condition pushPopCond;
 private EventDispatchThread dispatchThread;
 private final ThreadGroup threadGroup =
 Thread.currentThread().getThreadGroup();
 private final ClassLoader classLoader =
 private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
 static {
 AWTAccessor.setEventQueueAccessor(
 new AWTAccessor.EventQueueAccessor() {
-public EventQueue getNextQueue(EventQueue eventQueue) {
-return eventQueue.nextQueue;
-}
 public Thread getDispatchThread(EventQueue eventQueue) {
-return eventQueue.dispatchThread;
+return eventQueue.getDispatchThread();
+}
+public boolean isDispatchThreadImpl(EventQueue eventQueue) {
+return eventQueue.isDispatchThreadImpl();
 }
 });
 }
 public EventQueue() {
 * If this EventQueue instance is created in
 * SunToolkit.createNewAppContext() the started dispatch thread
 * may call AppContext.getAppContext() before createNewAppContext()
 * completes thus causing mess in thread group to appcontext mapping.
 */
+pushPopLock = (Lock)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_LOCK_KEY);
+pushPopCond = (Condition)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_COND_KEY);
 }
 /**
 * Posts a 1.1-style event to the <code>EventQueue</code>.
 * If there is an existing event on the queue with the same ID
 * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 *          or a subclass of it
 */
 final void postEventPrivate(AWTEvent theEvent) {
 theEvent.isPosted = true;
-synchronized(this) {
+pushPopLock.lock();
+try {
 if (dispatchThread == null && nextQueue == null) {
 if (theEvent.getSource() == AWTAutoShutdown.getInstance()) {
 return;
 } else {
 initDispatchThread();
 // Forward event to top of EventQueue stack.
 nextQueue.postEventPrivate(theEvent);
 return;
 }
 postEvent(theEvent, getPriority(theEvent));
+} finally {
+pushPopLock.unlock();
 }
 }
 private static int getPriority(AWTEvent theEvent) {
 if (theEvent instanceof PeerEvent &&
 if (shouldNotify) {
 if (theEvent.getSource() != AWTAutoShutdown.getInstance()) {
 AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
 }
-notifyAll();
+pushPopCond.signalAll();
 } else if (notifyID) {
-notifyAll();
+pushPopCond.signalAll();
 }
 } else {
 // The event was not coalesced or has non-Component source.
 // Insert it at the end of the appropriate Queue.
 queues[priority].tail.next = newItem;
 queues[priority].tail = newItem;
 if (notifyID) {
-notifyAll();
+pushPopCond.signalAll();
 }
 }
 }
 private boolean coalescePaintEvent(PaintEvent e) {
 * SunToolkit.flushPendingEvents must be called outside
 * of the synchronized block to avoid deadlock when
 * event queues are nested with push()/pop().
 */
 SunToolkit.flushPendingEvents();
-synchronized (this) {
+pushPopLock.lock();
+try {
 for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 if (queues[i].head != null) {
 EventQueueItem entry = queues[i].head;
 queues[i].head = entry.next;
 if (entry.next == null) {
 uncacheEQItem(entry);
 return entry.event;
 }
 }
 AWTAutoShutdown.getInstance().notifyThreadFree(dispatchThread);
-wait();
+pushPopCond.await();
+} finally {
+pushPopLock.unlock();
 }
 } while(true);
 }
 AWTEvent getNextEvent(int id) throws InterruptedException {
 * SunToolkit.flushPendingEvents must be called outside
 * of the synchronized block to avoid deadlock when
 * event queues are nested with push()/pop().
 */
 SunToolkit.flushPendingEvents();
-synchronized (this) {
+pushPopLock.lock();
+try {
 for (int i = 0; i < NUM_PRIORITIES; i++) {
 for (EventQueueItem entry = queues[i].head, prev = null;
 entry != null; prev = entry, entry = entry.next)
 {
 if (entry.event.getID() == id) {
 uncacheEQItem(entry);
 return entry.event;
 }
 }
 }
-this.waitForID = id;
+waitForID = id;
-wait();
+pushPopCond.await();
-this.waitForID = 0;
+waitForID = 0;
+} finally {
+pushPopLock.unlock();
 }
 } while(true);
 }
 /**
 * Returns the first event on the <code>EventQueue</code>
 * without removing it.
 * @return the first event
 */
-public synchronized AWTEvent peekEvent() {
+public AWTEvent peekEvent() {
-for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
+pushPopLock.lock();
-if (queues[i].head != null) {
+try {
-return queues[i].head.event;
+for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
-}
+if (queues[i].head != null) {
+return queues[i].head.event;
+}
+}
+} finally {
+pushPopLock.unlock();
 }
 return null;
 }
 * Returns the first event with the specified id, if any.
 * @param id the id of the type of event desired
 * @return the first event of the specified id or <code>null</code>
 *    if there is no such event
 */
-public synchronized AWTEvent peekEvent(int id) {
+public AWTEvent peekEvent(int id) {
-for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
+pushPopLock.lock();
-EventQueueItem q = queues[i].head;
+try {
-for (; q != null; q = q.next) {
+for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
-if (q.event.getID() == id) {
+EventQueueItem q = queues[i].head;
-return q.event;
+for (; q != null; q = q.next) {
-}
+if (q.event.getID() == id) {
-}
+return q.event;
+}
+}
+}
+} finally {
+pushPopLock.unlock();
 }
 return null;
 }
 * @since 1.4
 */
 public static long getMostRecentEventTime() {
 return Toolkit.getEventQueue().getMostRecentEventTimeImpl();
 }
-private synchronized long getMostRecentEventTimeImpl() {
+private long getMostRecentEventTimeImpl() {
-return (Thread.currentThread() == dispatchThread)
+pushPopLock.lock();
-? mostRecentEventTime
+try {
-: System.currentTimeMillis();
+return (Thread.currentThread() == dispatchThread)
+? mostRecentEventTime
+: System.currentTimeMillis();
+} finally {
+pushPopLock.unlock();
+}
 }
 /**
 * @return most recent event time on all threads.
 */
-synchronized long getMostRecentEventTimeEx() {
+long getMostRecentEventTimeEx() {
-return mostRecentEventTime;
+pushPopLock.lock();
+try {
+return mostRecentEventTime;
+} finally {
+pushPopLock.unlock();
+}
 }
 /**
 * Returns the the event currently being dispatched by the
 * <code>EventQueue</code> associated with the calling thread. This is
 * @since 1.4
 */
 public static AWTEvent getCurrentEvent() {
 return Toolkit.getEventQueue().getCurrentEventImpl();
 }
-private synchronized AWTEvent getCurrentEventImpl() {
+private AWTEvent getCurrentEventImpl() {
-return (Thread.currentThread() == dispatchThread)
+pushPopLock.lock();
-? ((AWTEvent)currentEvent.get())
+try {
-: null;
+return (Thread.currentThread() == dispatchThread)
+? ((AWTEvent)currentEvent.get())
+: null;
+} finally {
+pushPopLock.unlock();
+}
 }
 /**
 * Replaces the existing <code>EventQueue</code> with the specified one.
 * Any pending events are transferred to the new <code>EventQueue</code>
 *          (or subclass thereof) instance to be use
 * @see      java.awt.EventQueue#pop
 * @throws NullPointerException if <code>newEventQueue</code> is <code>null</code>
 * @since           1.2
 */
-public synchronized void push(EventQueue newEventQueue) {
+public void push(EventQueue newEventQueue) {
 if (eventLog.isLoggable(PlatformLogger.FINE)) {
 eventLog.fine("EventQueue.push(" + newEventQueue + ")");
 }
-if (nextQueue != null) {
+pushPopLock.lock();
-nextQueue.push(newEventQueue);
+try {
-return;
+EventQueue toPush = this;
-}
+while (toPush.nextQueue != null) {
+toPush = toPush.nextQueue;
-synchronized (newEventQueue) {
+}
 // Transfer all events forward to new EventQueue.
-while (peekEvent() != null) {
+while (toPush.peekEvent() != null) {
 try {
-newEventQueue.postEventPrivate(getNextEvent());
+newEventQueue.postEventPrivate(toPush.getNextEvent());
 } catch (InterruptedException ie) {
 if (eventLog.isLoggable(PlatformLogger.FINE)) {
 eventLog.fine("Interrupted push", ie);
 }
 }
 }
-newEventQueue.previousQueue = this;
+newEventQueue.previousQueue = toPush;
-}
 /*
 * Stop the event dispatch thread associated with the currently
 * active event queue, so that after the new queue is pushed
 * on the top this event dispatch thread won't prevent AWT from
 * being automatically shut down.
 * Use stopDispatchingLater() to avoid deadlock: stopDispatching()
-* waits for the dispatch thread to exit, so if the dispatch
+* waits for the dispatch thread to exit, which in turn waits
-* thread attempts to synchronize on this EventQueue object
+* for the lock in EQ.detachDispatchThread(), which is hold by
-* it will never exit since we already hold this lock.
+* this method.
 */
-if (dispatchThread != null) {
+if (toPush.dispatchThread != null) {
-dispatchThread.stopDispatchingLater();
+toPush.dispatchThread.stopDispatchingLater();
 }
-nextQueue = newEventQueue;
+toPush.nextQueue = newEventQueue;
 AppContext appContext = AppContext.getAppContext();
-if (appContext.get(AppContext.EVENT_QUEUE_KEY) == this) {
+if (appContext.get(AppContext.EVENT_QUEUE_KEY) == toPush) {
 appContext.put(AppContext.EVENT_QUEUE_KEY, newEventQueue);
+}
+} finally {
+pushPopLock.unlock();
 }
 }
 /**
 * Stops dispatching events using this <code>EventQueue</code>.
 protected void pop() throws EmptyStackException {
 if (eventLog.isLoggable(PlatformLogger.FINE)) {
 eventLog.fine("EventQueue.pop(" + this + ")");
 }
-// To prevent deadlock, we lock on the previous EventQueue before
+EventDispatchThread dt = null;
-// this one.  This uses the same locking order as everything else
+pushPopLock.lock();
-// in EventQueue.java, so deadlock isn't possible.
+try {
-EventQueue prev = previousQueue;
+EventQueue toPop = this;
-synchronized ((prev != null) ? prev : this) {
+while (toPop.nextQueue != null) {
-synchronized(this) {
+toPop = toPop.nextQueue;
-if (nextQueue != null) {
+}
-nextQueue.pop();
+EventQueue prev = toPop.previousQueue;
-return;
+if (prev == null) {
-}
-if (previousQueue == null) {
 throw new EmptyStackException();
 }
+toPop.previousQueue = null;
 // Transfer all events back to previous EventQueue.
-previousQueue.nextQueue = null;
+prev.nextQueue = null;
-while (peekEvent() != null) {
+while (toPop.peekEvent() != null) {
 try {
-previousQueue.postEventPrivate(getNextEvent());
+prev.postEventPrivate(toPop.getNextEvent());
 } catch (InterruptedException ie) {
 if (eventLog.isLoggable(PlatformLogger.FINE)) {
 eventLog.fine("Interrupted pop", ie);
 }
 }
 }
 AppContext appContext = AppContext.getAppContext();
 if (appContext.get(AppContext.EVENT_QUEUE_KEY) == this) {
-appContext.put(AppContext.EVENT_QUEUE_KEY, previousQueue);
+appContext.put(AppContext.EVENT_QUEUE_KEY, prev);
 }
-previousQueue = null;
+dt = toPop.dispatchThread;
-}
+} finally {
-}
+pushPopLock.unlock();
+}
-EventDispatchThread dt = this.dispatchThread;
 if (dt != null) {
 dt.stopDispatching(); // Must be done outside synchronized
 // block to avoid possible deadlock
 }
 }
 * @see             Toolkit#getSystemEventQueue
 * @since           1.2
 */
 public static boolean isDispatchThread() {
 EventQueue eq = Toolkit.getEventQueue();
-EventQueue next = eq.nextQueue;
+return eq.isDispatchThreadImpl();
-while (next != null) {
+}
-eq = next;
-next = eq.nextQueue;
+final boolean isDispatchThreadImpl() {
-}
+EventQueue eq = this;
-return (Thread.currentThread() == eq.dispatchThread);
+pushPopLock.lock();
+try {
+EventQueue next = eq.nextQueue;
+while (next != null) {
+eq = next;
+next = eq.nextQueue;
+}
+return (Thread.currentThread() == eq.dispatchThread);
+} finally {
+pushPopLock.unlock();
+}
 }
 final void initDispatchThread() {
-synchronized (this) {
+pushPopLock.lock();
+try {
 AppContext appContext = AppContext.getAppContext();
 if (dispatchThread == null && !threadGroup.isDestroyed() && !appContext.isDisposed()) {
 dispatchThread = (EventDispatchThread)
 AccessController.doPrivileged(new PrivilegedAction() {
 public Object run() {
 }
 });
 AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
 dispatchThread.start();
 }
-}
+} finally {
-}
+pushPopLock.unlock();
+}
-final void detachDispatchThread() {
+}
-dispatchThread = null;
+final void detachDispatchThread(EventDispatchThread edt, boolean restart) {
+/*
+* This synchronized block is to secure that the event dispatch
+* thread won't die in the middle of posting a new event to the
+* associated event queue. It is important because we notify
+* that the event dispatch thread is busy after posting a new event
+* to its queue, so the EventQueue.dispatchThread reference must
+* be valid at that point.
+*/
+pushPopLock.lock();
+try {
+EventDispatchThread oldDispatchThread = dispatchThread;
+if (dispatchThread == edt) {
+dispatchThread = null;
+}
+if (restart) {
+/*
+* Event dispatch thread dies in case of an uncaught exception.
+* A new event dispatch thread for this queue will be started
+* only if a new event is posted to it. In case if no more
+* events are posted after this thread died all events that
+* currently are in the queue will never be dispatched.
+*
+* Fix for 4648733. Check both the associated java event
+* queue and the PostEventQueue.
+*/
+if ((peekEvent() != null) || !SunToolkit.isPostEventQueueEmpty()) {
+initDispatchThread();
+}
+AWTAutoShutdown.getInstance().notifyThreadFree(oldDispatchThread);
+}
+} finally {
+pushPopLock.unlock();
+}
 }
 /*
 * Gets the <code>EventDispatchThread</code> for this
 * <code>EventQueue</code>.
 *         working thread associated with it
 * @see    java.awt.EventQueue#initDispatchThread
 * @see    java.awt.EventQueue#detachDispatchThread
 */
 final EventDispatchThread getDispatchThread() {
-return dispatchThread;
+pushPopLock.lock();
+try {
+return dispatchThread;
+} finally {
+pushPopLock.unlock();
+}
 }
 /*
 * Removes any pending events for the specified source object.
 * If removeAllEvents parameter is <code>true</code> then all
 * This method is normally called by the source's
 * <code>removeNotify</code> method.
 */
 final void removeSourceEvents(Object source, boolean removeAllEvents) {
 SunToolkit.flushPendingEvents();
-synchronized (this) {
+pushPopLock.lock();
+try {
 for (int i = 0; i < NUM_PRIORITIES; i++) {
 EventQueueItem entry = queues[i].head;
 EventQueueItem prev = null;
 while (entry != null) {
 if ((entry.event.getSource() == source)
 }
 entry = entry.next;
 }
 queues[i].tail = prev;
 }
+} finally {
+pushPopLock.unlock();
 }
 }
 static void setCurrentEventAndMostRecentTime(AWTEvent e) {
 Toolkit.getEventQueue().setCurrentEventAndMostRecentTimeImpl(e);
 }
-private synchronized void setCurrentEventAndMostRecentTimeImpl(AWTEvent e)
+private void setCurrentEventAndMostRecentTimeImpl(AWTEvent e) {
-{
+pushPopLock.lock();
-if (Thread.currentThread() != dispatchThread) {
+try {
-return;
+if (Thread.currentThread() != dispatchThread) {
-}
+return;
+}
-currentEvent = new WeakReference(e);
+currentEvent = new WeakReference(e);
-// This series of 'instanceof' checks should be replaced with a
-// polymorphic type (for example, an interface which declares a
+// This series of 'instanceof' checks should be replaced with a
-// getWhen() method). However, this would require us to make such
+// polymorphic type (for example, an interface which declares a
-// a type public, or to place it in sun.awt. Both of these approaches
+// getWhen() method). However, this would require us to make such
-// have been frowned upon. So for now, we hack.
+// a type public, or to place it in sun.awt. Both of these approaches
-//
+// have been frowned upon. So for now, we hack.
-// In tiger, we will probably give timestamps to all events, so this
+//
-// will no longer be an issue.
+// In tiger, we will probably give timestamps to all events, so this
-long mostRecentEventTime2 = Long.MIN_VALUE;
+// will no longer be an issue.
-if (e instanceof InputEvent) {
+long mostRecentEventTime2 = Long.MIN_VALUE;
-InputEvent ie = (InputEvent)e;
+if (e instanceof InputEvent) {
-mostRecentEventTime2 = ie.getWhen();
+InputEvent ie = (InputEvent)e;
-} else if (e instanceof InputMethodEvent) {
+mostRecentEventTime2 = ie.getWhen();
-InputMethodEvent ime = (InputMethodEvent)e;
+} else if (e instanceof InputMethodEvent) {
-mostRecentEventTime2 = ime.getWhen();
+InputMethodEvent ime = (InputMethodEvent)e;
-} else if (e instanceof ActionEvent) {
+mostRecentEventTime2 = ime.getWhen();
-ActionEvent ae = (ActionEvent)e;
+} else if (e instanceof ActionEvent) {
-mostRecentEventTime2 = ae.getWhen();
+ActionEvent ae = (ActionEvent)e;
-} else if (e instanceof InvocationEvent) {
+mostRecentEventTime2 = ae.getWhen();
-InvocationEvent ie = (InvocationEvent)e;
+} else if (e instanceof InvocationEvent) {
-mostRecentEventTime2 = ie.getWhen();
+InvocationEvent ie = (InvocationEvent)e;
-}
+mostRecentEventTime2 = ie.getWhen();
-mostRecentEventTime = Math.max(mostRecentEventTime, mostRecentEventTime2);
+}
+mostRecentEventTime = Math.max(mostRecentEventTime, mostRecentEventTime2);
+} finally {
+pushPopLock.unlock();
+}
 }
 /**
 * Causes <code>runnable</code> to have its <code>run</code>
 * method called in the {@link #isDispatchThread dispatch thread} of
 * appeared. First it proceeds to the EventQueue on the top of the
 * stack, then notifies the associated dispatch thread if it exists
 * or starts a new one otherwise.
 */
 private void wakeup(boolean isShutdown) {
-synchronized(this) {
+pushPopLock.lock();
+try {
 if (nextQueue != null) {
 // Forward call to the top of EventQueue stack.
 nextQueue.wakeup(isShutdown);
 } else if (dispatchThread != null) {
-notifyAll();
+pushPopCond.signalAll();
 } else if (!isShutdown) {
 initDispatchThread();
 }
+} finally {
+pushPopLock.unlock();
 }
 }
 }
 /**

changeset 4365	4ac67034e98b
parent 4264	40c232605c68
child 5506	202f599c92aa