--- old/src/java.desktop/share/classes/java/awt/WaitDispatchSupport.java 2015-03-26 15:03:44.533075600 +0300 +++ new/src/java.desktop/share/classes/java/awt/WaitDispatchSupport.java 2015-03-26 15:03:43.709998700 +0300 @@ -46,9 +46,8 @@ * @since 1.7 */ class WaitDispatchSupport implements SecondaryLoop { - private final static PlatformLogger log = - PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport"); + PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport"); private EventDispatchThread dispatchThread; private EventFilter filter; @@ -65,6 +64,7 @@ private AtomicBoolean keepBlockingEDT = new AtomicBoolean(false); private AtomicBoolean keepBlockingCT = new AtomicBoolean(false); + private AtomicBoolean prematureExit = new AtomicBoolean(false); private static synchronized void initializeTimer() { if (timer == null) { @@ -77,7 +77,7 @@ * serve the given event dispatch thread. * * @param dispatchThread An event dispatch thread that - * should not stop dispatching events while waiting + * should not stop dispatching events while waiting * * @since 1.7 */ @@ -234,50 +234,55 @@ if (log.isLoggable(PlatformLogger.Level.FINEST)) { log.finest("On non-dispatch thread: " + currentThread); } + keepBlockingCT.set(true); synchronized (getTreeLock()) { - if (filter != null) { - dispatchThread.addEventFilter(filter); - } - try { - EventQueue eq = dispatchThread.getEventQueue(); - eq.postEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT)); - keepBlockingCT.set(true); - if (interval > 0) { - long currTime = System.currentTimeMillis(); - while (keepBlockingCT.get() && - ((extCondition != null) ? extCondition.evaluate() : true) && - (currTime + interval > System.currentTimeMillis())) - { - getTreeLock().wait(interval); + if (keepBlockingEDT.get() && !prematureExit.get()) { + if (filter != null) { + dispatchThread.addEventFilter(filter); + } + try { + EventQueue eq = dispatchThread.getEventQueue(); + eq.postEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT)); + if (interval > 0) { + long currTime = System.currentTimeMillis(); + while (keepBlockingCT.get() && + ((extCondition != null) ? extCondition.evaluate() : true) && + (currTime + interval > System.currentTimeMillis())) + { + getTreeLock().wait(interval); + } + } else { + while (keepBlockingCT.get() && + ((extCondition != null) ? extCondition.evaluate() : true)) + { + getTreeLock().wait(); + } } - } else { - while (keepBlockingCT.get() && - ((extCondition != null) ? extCondition.evaluate() : true)) - { - getTreeLock().wait(); + if (log.isLoggable(PlatformLogger.Level.FINE)) { + log.fine("waitDone " + keepBlockingEDT.get() + " " + keepBlockingCT.get()); + } + } catch (InterruptedException e) { + if (log.isLoggable(PlatformLogger.Level.FINE)) { + log.fine("Exception caught while waiting: " + e); + } + } finally { + if (filter != null) { + dispatchThread.removeEventFilter(filter); } } - if (log.isLoggable(PlatformLogger.Level.FINE)) { - log.fine("waitDone " + keepBlockingEDT.get() + " " + keepBlockingCT.get()); - } - } catch (InterruptedException e) { - if (log.isLoggable(PlatformLogger.Level.FINE)) { - log.fine("Exception caught while waiting: " + e); - } - } finally { - if (filter != null) { - dispatchThread.removeEventFilter(filter); - } + // If the waiting process has been stopped because of the + // time interval passed or an exception occurred, the state + // should be changed + keepBlockingEDT.set(false); + keepBlockingCT.set(false); + } else { + // We get here when exit called after but happened concurrently + keepBlockingCT.set(false); + prematureExit.set(true); } - // If the waiting process has been stopped because of the - // time interval passed or an exception occurred, the state - // should be changed - keepBlockingEDT.set(false); - keepBlockingCT.set(false); } } - - return true; + return !prematureExit.getAndSet(false); } /** @@ -288,11 +293,26 @@ log.fine("exit(): blockingEDT=" + keepBlockingEDT.get() + ", blockingCT=" + keepBlockingCT.get()); } - if (keepBlockingEDT.compareAndSet(true, false)) { + if(keepBlockingCT.get()) { + // enter() is waiting in non-dispatch thread + synchronized (getTreeLock()) { + keepBlockingEDT.set(false); + prematureExit.set(false); + wakeupEDT(); + return true; + } + } else { + if (keepBlockingEDT.getAndSet(false)) { + prematureExit.set(false); + wakeupEDT(); + return true; + } + // exit() call before enter() + prematureExit.set(true); + // Still need to wake up it can be a concurrent exit() wakeupEDT(); - return true; + return false; } - return false; } private final static Object getTreeLock() { @@ -302,9 +322,13 @@ private final Runnable wakingRunnable = new Runnable() { public void run() { log.fine("Wake up EDT"); - synchronized (getTreeLock()) { - keepBlockingCT.set(false); - getTreeLock().notifyAll(); + keepBlockingEDT.set(false); + if (keepBlockingCT.get()) { + // Notify only if enter() waiting in non-dispatch thread + synchronized (getTreeLock()) { + keepBlockingCT.set(false); + getTreeLock().notifyAll(); + } } log.fine("Wake up EDT done"); } --- /dev/null 2015-03-26 15:03:49.000000000 +0300 +++ new/test/java/awt/EventQueue/6980209/bug6980209.java 2015-03-26 15:03:48.541465600 +0300 @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* @test + @bug 6980209 + @summary Make tracking SecondaryLoop.enter/exit methods easier + @author Semyon Sadetsky + */ + +import sun.util.logging.PlatformLogger; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; + +public class bug6980209 implements ActionListener { + + private final static PlatformLogger log = + PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport"); + public static final int ATTEMPTS = 100; + public static final int EVENTS = 5; + + private static boolean runInEDT; + private static JFrame frame; + private static int disorderCounter = 0; + private static Boolean enterReturn; + private static Boolean exitReturn; + private static int dispatchedEvents; + + public static void main(String[] args) throws Exception { + System.out.println( + "PLEASE DO NOT TOUCH KEYBOARD AND MOUSE DURING THE TEST RUN!"); + // log.setLevel(PlatformLogger.Level.FINE); + // log.setLevel(PlatformLogger.Level.FINEST); + try { + SwingUtilities.invokeAndWait(new Runnable() { + public void run() { + frame = new JFrame(); + frame.setUndecorated(true); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + setup(frame); + } + }); + System.out.println("Run test in EDT"); + runInEDT = true; + test(); + System.out.println("Run test in another thread"); + runInEDT = false; + test(); + System.out.println("ok"); + + } finally { + SwingUtilities.invokeAndWait(new Runnable() { + @Override + public void run() { + frame.dispose(); + } + }); + } + } + + private static void test() throws AWTException { + disorderCounter = 0; + final Robot robot = new Robot(); + for (int i = 0; i < ATTEMPTS; i++) { + enterReturn = null; + exitReturn = null; + dispatchedEvents = 0; + synchronized (bug6980209.class) { + try { + for (int j = 0; j < EVENTS; j++) { + robot.keyPress(KeyEvent.VK_1); + robot.keyRelease(KeyEvent.VK_1); + } + + //trigger the button action that starts secondary loop + robot.keyPress(KeyEvent.VK_SPACE); + robot.keyRelease(KeyEvent.VK_SPACE); + + for (int j = 0; j < EVENTS; j++) { + robot.keyPress(KeyEvent.VK_1); + robot.keyRelease(KeyEvent.VK_1); + } + long time = System.nanoTime(); + bug6980209.class.wait(1000); //wait for enter() returns + if (enterReturn == null) { + System.out.println("wait time=" + + ((System.nanoTime() - time) / 1E9) + + " seconds"); + throw new RuntimeException( + "It seems the secondary loop will never end"); + } + if (!enterReturn) disorderCounter++; + + robot.waitForIdle(); + if (dispatchedEvents < + 2 * EVENTS) { //check that all events are dispatched + throw new RuntimeException( + "KeyEvent.VK_1 has been lost!"); + } + + } catch (InterruptedException e) { + throw new RuntimeException("Interrupted!"); + } + } + } + if (disorderCounter == 0) { + System.out.println( + "Zero disordered enter/exit caught. It is recommended to run scenario again"); + } else { + System.out.println( + "Disordered calls is " + disorderCounter + " from " + + ATTEMPTS); + } + } + + private static void setup(final JFrame frame) { + JButton jButton = new JButton("Button"); + frame.getContentPane().add(jButton); + jButton.addActionListener(new bug6980209()); + frame.pack(); + frame.setVisible(true); + jButton.setFocusable(true); + jButton.requestFocus(); + jButton.addKeyListener(new KeyListener() { + @Override + public void keyTyped(KeyEvent e) { + } + + @Override + public void keyPressed(KeyEvent e) { + if (e.getKeyChar() == '1') dispatchedEvents++; + } + + @Override + public void keyReleased(KeyEvent e) { + if (e.getKeyChar() == '1') dispatchedEvents++; + } + }); + } + + + @Override + public void actionPerformed(ActionEvent e) { + if (runInEDT) { + runSecondaryLoop(); + return; + } + new Thread("Secondary loop run thread") { + @Override + public void run() { + runSecondaryLoop(); + } + }.start(); + } + + private static void runSecondaryLoop() { + log.fine("\n---TEST START---"); + + final SecondaryLoop loop = + Toolkit.getDefaultToolkit().getSystemEventQueue() + .createSecondaryLoop(); + + final Object LOCK = new Object(); //lock to start simultaneously + Thread exitThread = new Thread("Exit thread") { + @Override + public void run() { + synchronized (LOCK) { + LOCK.notify(); + } + Thread.yield(); + exitReturn = loop.exit(); + log.fine("exit() returns " + exitReturn); + } + }; + + synchronized (LOCK) { + try { + exitThread.start(); + LOCK.wait(); + } catch (InterruptedException e1) { + throw new RuntimeException("What?"); + } + } + + enterReturn = loop.enter(); + log.fine("enter() returns " + enterReturn); + + try { + exitThread.join(); + } catch (InterruptedException e) { + throw new RuntimeException("What?"); + } + synchronized (bug6980209.class) { + bug6980209.class.notifyAll(); + } + log.fine("\n---TEST END---"); + } + +}