1 /*
   2  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.awt;
  27 
  28 import java.util.Timer;
  29 import java.util.TimerTask;
  30 import java.util.concurrent.atomic.AtomicBoolean;
  31 
  32 import java.security.PrivilegedAction;
  33 import java.security.AccessController;
  34 
  35 import sun.awt.PeerEvent;
  36 
  37 import sun.util.logging.PlatformLogger;
  38 
  39 /**
  40  * This utility class is used to suspend execution on a thread
  41  * while still allowing {@code EventDispatchThread} to dispatch events.
  42  * The API methods of the class are thread-safe.
  43  *
  44  * @author Anton Tarasov, Artem Ananiev
  45  *
  46  * @since 1.7
  47  */
  48 class WaitDispatchSupport implements SecondaryLoop {
  49 
  50     private final static PlatformLogger log =
  51         PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport");
  52 
  53     private EventDispatchThread dispatchThread;
  54     private EventFilter filter;
  55 
  56     private volatile Conditional extCondition;
  57     private volatile Conditional condition;
  58 
  59     private long interval;
  60     // Use a shared daemon timer to serve all the WaitDispatchSupports
  61     private static Timer timer;
  62     // When this WDS expires, we cancel the timer task leaving the
  63     // shared timer up and running
  64     private TimerTask timerTask;
  65 
  66     private AtomicBoolean keepBlockingEDT = new AtomicBoolean(false);
  67     private AtomicBoolean keepBlockingCT = new AtomicBoolean(false);
  68 
  69     private static synchronized void initializeTimer() {
  70         if (timer == null) {
  71             timer = new Timer("AWT-WaitDispatchSupport-Timer", true);
  72         }
  73     }
  74 
  75     /**
  76      * Creates a {@code WaitDispatchSupport} instance to
  77      * serve the given event dispatch thread.
  78      *
  79      * @param dispatchThread An event dispatch thread that
  80      *        should not stop dispatching events while waiting
  81      *
  82      * @since 1.7
  83      */
  84     public WaitDispatchSupport(EventDispatchThread dispatchThread) {
  85         this(dispatchThread, null);
  86     }
  87 
  88     /**
  89      * Creates a {@code WaitDispatchSupport} instance to
  90      * serve the given event dispatch thread.
  91      *
  92      * @param dispatchThread An event dispatch thread that
  93      *        should not stop dispatching events while waiting
  94      * @param extCondition A conditional object used to determine
  95      *        if the loop should be terminated
  96      *
  97      * @since 1.7
  98      */
  99     public WaitDispatchSupport(EventDispatchThread dispatchThread,
 100                                Conditional extCond)
 101     {
 102         if (dispatchThread == null) {
 103             throw new IllegalArgumentException("The dispatchThread can not be null");
 104         }
 105 
 106         this.dispatchThread = dispatchThread;
 107         this.extCondition = extCond;
 108         this.condition = new Conditional() {
 109             @Override
 110             public boolean evaluate() {
 111                 if (log.isLoggable(PlatformLogger.Level.FINEST)) {
 112                     log.finest("evaluate(): blockingEDT=" + keepBlockingEDT.get() +
 113                                ", blockingCT=" + keepBlockingCT.get());
 114                 }
 115                 boolean extEvaluate =
 116                     (extCondition != null) ? extCondition.evaluate() : true;
 117                 if (!keepBlockingEDT.get() || !extEvaluate) {
 118                     if (timerTask != null) {
 119                         timerTask.cancel();
 120                         timerTask = null;
 121                     }
 122                     return false;
 123                 }
 124                 return true;
 125             }
 126         };
 127     }
 128 
 129     /**
 130      * Creates a {@code WaitDispatchSupport} instance to
 131      * serve the given event dispatch thread.
 132      * <p>
 133      * The {@link EventFilter} is set on the {@code dispatchThread}
 134      * while waiting. The filter is removed on completion of the
 135      * waiting process.
 136      * <p>
 137      *
 138      *
 139      * @param dispatchThread An event dispatch thread that
 140      *        should not stop dispatching events while waiting
 141      * @param filter {@code EventFilter} to be set
 142      * @param interval A time interval to wait for. Note that
 143      *        when the waiting process takes place on EDT
 144      *        there is no guarantee to stop it in the given time
 145      *
 146      * @since 1.7
 147      */
 148     public WaitDispatchSupport(EventDispatchThread dispatchThread,
 149                                Conditional extCondition,
 150                                EventFilter filter, long interval)
 151     {
 152         this(dispatchThread, extCondition);
 153         this.filter = filter;
 154         if (interval < 0) {
 155             throw new IllegalArgumentException("The interval value must be >= 0");
 156         }
 157         this.interval = interval;
 158         if (interval != 0) {
 159             initializeTimer();
 160         }
 161     }
 162 
 163     /**
 164      * @inheritDoc
 165      */
 166     @Override
 167     public boolean enter() {
 168         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 169             log.fine("enter(): blockingEDT=" + keepBlockingEDT.get() +
 170                      ", blockingCT=" + keepBlockingCT.get());
 171         }
 172 
 173         if (!keepBlockingEDT.compareAndSet(false, true)) {
 174             log.fine("The secondary loop is already running, aborting");
 175             return false;
 176         }
 177 
 178         final Runnable run = new Runnable() {
 179             public void run() {
 180                 log.fine("Starting a new event pump");
 181                 if (filter == null) {
 182                     dispatchThread.pumpEvents(condition);
 183                 } else {
 184                     dispatchThread.pumpEventsForFilter(condition, filter);
 185                 }
 186             }
 187         };
 188 
 189         // We have two mechanisms for blocking: if we're on the
 190         // dispatch thread, start a new event pump; if we're
 191         // on any other thread, call wait() on the treelock
 192 
 193         Thread currentThread = Thread.currentThread();
 194         if (currentThread == dispatchThread) {
 195             if (log.isLoggable(PlatformLogger.Level.FINEST)) {
 196                 log.finest("On dispatch thread: " + dispatchThread);
 197             }
 198             if (interval != 0) {
 199                 if (log.isLoggable(PlatformLogger.Level.FINEST)) {
 200                     log.finest("scheduling the timer for " + interval + " ms");
 201                 }
 202                 timer.schedule(timerTask = new TimerTask() {
 203                     @Override
 204                     public void run() {
 205                         if (keepBlockingEDT.compareAndSet(true, false)) {
 206                             wakeupEDT();
 207                         }
 208                     }
 209                 }, interval);
 210             }
 211             // Dispose SequencedEvent we are dispatching on the the current
 212             // AppContext, to prevent us from hang - see 4531693 for details
 213             SequencedEvent currentSE = KeyboardFocusManager.
 214                 getCurrentKeyboardFocusManager().getCurrentSequencedEvent();
 215             if (currentSE != null) {
 216                 if (log.isLoggable(PlatformLogger.Level.FINE)) {
 217                     log.fine("Dispose current SequencedEvent: " + currentSE);
 218                 }
 219                 currentSE.dispose();
 220             }
 221             // In case the exit() method is called before starting
 222             // new event pump it will post the waking event to EDT.
 223             // The event will be handled after the the new event pump
 224             // starts. Thus, the enter() method will not hang.
 225             //
 226             // Event pump should be privileged. See 6300270.
 227             AccessController.doPrivileged(new PrivilegedAction<Object>() {
 228                 public Object run() {
 229                     run.run();
 230                     return null;
 231                 }
 232             });
 233         } else {
 234             if (log.isLoggable(PlatformLogger.Level.FINEST)) {
 235                 log.finest("On non-dispatch thread: " + currentThread);
 236             }
 237             synchronized (getTreeLock()) {
 238                 if (filter != null) {
 239                     dispatchThread.addEventFilter(filter);
 240                 }
 241                 try {
 242                     EventQueue eq = dispatchThread.getEventQueue();
 243                     eq.postEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT));
 244                     keepBlockingCT.set(true);
 245                     if (interval > 0) {
 246                         long currTime = System.currentTimeMillis();
 247                         while (keepBlockingCT.get() &&
 248                                ((extCondition != null) ? extCondition.evaluate() : true) &&
 249                                (currTime + interval > System.currentTimeMillis()))
 250                         {
 251                             getTreeLock().wait(interval);
 252                         }
 253                     } else {
 254                         while (keepBlockingCT.get() &&
 255                                ((extCondition != null) ? extCondition.evaluate() : true))
 256                         {
 257                             getTreeLock().wait();
 258                         }
 259                     }
 260                     if (log.isLoggable(PlatformLogger.Level.FINE)) {
 261                         log.fine("waitDone " + keepBlockingEDT.get() + " " + keepBlockingCT.get());
 262                     }
 263                 } catch (InterruptedException e) {
 264                     if (log.isLoggable(PlatformLogger.Level.FINE)) {
 265                         log.fine("Exception caught while waiting: " + e);
 266                     }
 267                 } finally {
 268                     if (filter != null) {
 269                         dispatchThread.removeEventFilter(filter);
 270                     }
 271                 }
 272                 // If the waiting process has been stopped because of the
 273                 // time interval passed or an exception occurred, the state
 274                 // should be changed
 275                 keepBlockingEDT.set(false);
 276                 keepBlockingCT.set(false);
 277             }
 278         }
 279 
 280         return true;
 281     }
 282 
 283     /**
 284      * @inheritDoc
 285      */
 286     public boolean exit() {
 287         if (log.isLoggable(PlatformLogger.Level.FINE)) {
 288             log.fine("exit(): blockingEDT=" + keepBlockingEDT.get() +
 289                      ", blockingCT=" + keepBlockingCT.get());
 290         }
 291         if (keepBlockingEDT.compareAndSet(true, false)) {
 292             wakeupEDT();
 293             return true;
 294         }
 295         return false;
 296     }
 297 
 298     private final static Object getTreeLock() {
 299         return Component.LOCK;
 300     }
 301 
 302     private final Runnable wakingRunnable = new Runnable() {
 303         public void run() {
 304             log.fine("Wake up EDT");
 305             synchronized (getTreeLock()) {
 306                 keepBlockingCT.set(false);
 307                 getTreeLock().notifyAll();
 308             }
 309             log.fine("Wake up EDT done");
 310         }
 311     };
 312 
 313     private void wakeupEDT() {
 314         if (log.isLoggable(PlatformLogger.Level.FINEST)) {
 315             log.finest("wakeupEDT(): EDT == " + dispatchThread);
 316         }
 317         EventQueue eq = dispatchThread.getEventQueue();
 318         eq.postEvent(new PeerEvent(this, wakingRunnable, PeerEvent.PRIORITY_EVENT));
 319     }
 320 }