public void run() { updateRunnableQueue.invokeLater(new Runnable() { public void run() { try { r.run(); } catch (Exception e) { if (userAgent != null) { userAgent.displayError(e); } } } }); } }
/** * Interrupts the manager tasks. */ public void interrupt() { Runnable r = new Runnable() { public void run() { synchronized (UpdateManager.this) { if (started) { dispatchSVGUnLoadEvent(); } else { running = false; scriptingEnvironment.interrupt(); updateRunnableQueue.getThread().halt(); } } } }; try { // Preempt to cancel the pending tasks updateRunnableQueue.preemptLater(r); updateRunnableQueue.resumeExecution(); // ensure runnable runs... } catch (IllegalStateException ise) { // Not running, which is probably ok since that's what we // wanted. Might be an issue if SVGUnload wasn't issued... } }
public void run() { synchronized (eir) { if (eir.count > 1) return; eir.count++; } synchronized (updateRunnableQueue.getIteratorLock()) { if (updateRunnableQueue.getThread() == null) { cancel(); return; } updateRunnableQueue.invokeLater(eir); } synchronized (eir) { if (eir.error) cancel(); } } }
/** * Suspends the update manager. */ public synchronized void suspend() { // System.err.println("Suspend: " + suspendCalled + " : " + running); if (updateRunnableQueue.getQueueState() == RunnableQueue.RUNNING) { updateRunnableQueue.suspendExecution(false); } suspendCalled = true; }
/** * Resumes the update manager. */ public synchronized void resume() { // System.err.println("Resume: " + suspendCalled + " : " + running); // if (suspendCalled) { // UpdateManagerEvent ev = new UpdateManagerEvent // (this, null, null); // // FIXX: Must happen in a different thread! // fireEvent(suspendedDispatcher, ev); // fireEvent(resumedDispatcher, ev); // } if (updateRunnableQueue.getQueueState() != RunnableQueue.RUNNING) { updateRunnableQueue.resumeExecution(); } }
synchronized (rq.getIteratorLock()) { Iterator it = rq.iterator(); while (it.hasNext()) { Object next = it.next(); rq.invokeLater(new MouseMovedRunnable(e));
synchronized (rqRable) { System.out.println(" InvL #" + idx); rq.invokeLater(rqRable); System.out.println("Done InvL #" + idx); rqRable.wait(); case INVOKE_AND_WAIT: System.out.println(" InvW #" + idx); rq.invokeAndWait(rqRable); System.out.println("Done InvW #" + idx); break; synchronized (rqRable) { System.out.println(" PreL #" + idx); rq.preemptLater(rqRable); System.out.println("Done PreL #" + idx); rqRable.wait(); case PREEMPT_AND_WAIT: System.out.println(" PreW #" + idx); rq.preemptAndWait(rqRable); System.out.println("Done PreW #" + idx); break;
/** * Creates a new RunnableQueue started in a new thread. * @return a RunnableQueue which is guaranteed to have entered its * <code>run()</code> method. */ public static RunnableQueue createRunnableQueue() { RunnableQueue result = new RunnableQueue(); synchronized (result) { // Sync on the new object, so we can wait until the new // thread is ready to go. HaltingThread ht = new HaltingThread (result, "RunnableQueue-" + threadCount++); ht.setDaemon(true); ht.start(); while (result.getThread() == null) { try { result.wait(); } catch (InterruptedException ie) { } } } return result; }
/** * Finishes the UpdateManager initialization. */ public void manageUpdates(final ImageRenderer r) { updateRunnableQueue.preemptLater(new Runnable() { public void run() { synchronized (UpdateManager.this) { running = true; updateTracker = new UpdateTracker(); RootGraphicsNode root = graphicsNode.getRoot(); if (root != null){ root.addTreeGraphicsNodeChangeListener (updateTracker); } repaintManager = new RepaintManager(r); // Send the UpdateManagerStarted event. UpdateManagerEvent ev = new UpdateManagerEvent (UpdateManager.this, null, null); fireEvent(startedDispatcher, ev); started = true; } } }); resume(); }
synchronized (updateRunnableQueue.getIteratorLock()) { Iterator i = updateRunnableQueue.iterator(); while (i.hasNext()) if (!(i.next() instanceof NoRepaintRunnable))
public void run() { synchronized (UpdateManager.this) { if (started) { dispatchSVGUnLoadEvent(); } else { running = false; scriptingEnvironment.interrupt(); updateRunnableQueue.getThread().halt(); } } } };
/** * Forces an animation update, if the {@link RunnableQueue} is * currently waiting. */ public void resume() { waitTime = 0; Object lock = q.getIteratorLock(); synchronized (lock) { lock.notify(); } }
public void run() { boolean suspendp, waitp; int time; while (true) { try { synchronized (rand) { suspendp = rand.nextBoolean(); waitp = rand.nextBoolean(); time = rand.nextInt(500); } if (suspendp) { // 1/2 of the time suspend, 1/2 time wait, 1/2 the // time don't rq.suspendExecution(waitp); System.out.println("Suspended - " + (waitp?"Wait":"Later")); Thread.sleep(time/10); } else { // 1/2 the time resume rq.resumeExecution(); System.out.println("Resumed"); Thread.sleep(time); } } catch(InterruptedException ie) { } } } }
/** * Ticks the animation over as fast as possible. */ public void run() { if (true) { for (;;) { time.setTime(new Date()); ticker.t = timedDocumentRoot.convertWallclockTime(time); try { runnableQueue.invokeAndWait(ticker); } catch (InterruptedException e) { return; } } } else { ticker.t = 1; while (ticker.t < 10) { try { Thread.sleep(1000); } catch (InterruptedException ie) { } try { runnableQueue.invokeAndWait(ticker); } catch (InterruptedException e) { return; } ticker.t++; } } }
updateRunnableQueue = RunnableQueue.createRunnableQueue(); runHandler = createRunHandler(); updateRunnableQueue.setRunHandler(runHandler);
/** * This method will only throw exceptions if some aspect * of the test's internal operation fails. */ public TestReport runImpl() throws Exception { rq = RunnableQueue.createRunnableQueue(); List l = new ArrayList(nThreads); rand = new Random(2345); // Two switch flickers to make things interesting... l.add(new SwitchFlicker()); l.add(new SwitchFlicker()); for (int i=0; i<nThreads; i++) { Runnable rqRable = new RQRable(i, rand.nextInt(50)+1); l.add(new TPRable(rq, i, rand.nextInt(4)+1, rand.nextInt(500)+1, 20, rqRable)); } synchronized (this) { ThreadPounder tp = new ThreadPounder(l); tp.start(); activeThreads = nThreads; while (activeThreads != 0) { wait(); } } System.exit(0); return null; }
synchronized (rq.getIteratorLock()) { Iterator it = rq.iterator(); while (it.hasNext()) { Object next = it.next(); rq.invokeLater(new MouseDraggedRunnable(e));
/** * Creates a new RunnableQueue started in a new thread. * @return a RunnableQueue which is guaranteed to have entered its * <code>run()</code> method. */ public static RunnableQueue createRunnableQueue() { RunnableQueue result = new RunnableQueue(); synchronized (result) { // Sync on the new object, so we can wait until the new // thread is ready to go. HaltingThread ht = new HaltingThread (result, "RunnableQueue-" + threadCount++); ht.setDaemon(true); ht.start(); while (result.getThread() == null) { try { result.wait(); } catch (InterruptedException ie) { } } } return result; }
/** * Finishes the UpdateManager initialization. */ public void manageUpdates(final ImageRenderer r) { updateRunnableQueue.preemptLater(new Runnable() { public void run() { synchronized (UpdateManager.this) { running = true; updateTracker = new UpdateTracker(); RootGraphicsNode root = graphicsNode.getRoot(); if (root != null){ root.addTreeGraphicsNodeChangeListener (updateTracker); } repaintManager = new RepaintManager(r); // Send the UpdateManagerStarted event. UpdateManagerEvent ev = new UpdateManagerEvent (UpdateManager.this, null, null); fireEvent(startedDispatcher, ev); started = true; } } }); resume(); }
synchronized (updateRunnableQueue.getIteratorLock()) { Iterator i = updateRunnableQueue.iterator(); while (i.hasNext()) if (!(i.next() instanceof NoRepaintRunnable))