Back to index...

	/*
	* Copyright (c) 1998, 2006, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package com.sun.tools.jdi;

	import com.sun.jdi.*;
	import com.sun.jdi.event.EventQueue;
	import com.sun.jdi.event.EventSet;

	import java.util.*;

	public class EventQueueImpl extends MirrorImpl implements EventQueue {

	/*
	* Note this is not a synchronized list. Iteration/update should be
	* protected through the 'this' monitor.
	*/
	LinkedList<EventSet> eventSets = new LinkedList<EventSet>();

	TargetVM target;
	boolean closed = false;

	EventQueueImpl(VirtualMachine vm, TargetVM target) {
	super(vm);
	this.target = target;
	target.addEventQueue(this);
	}

	/*
	* Override superclass back to default equality
	*/
	public boolean equals(Object obj) {
	return this == obj;
	}

	public int hashCode() {
	return System.identityHashCode(this);
	}

	synchronized void enqueue(EventSet eventSet) {
	eventSets.add(eventSet);
	notifyAll();
	}

	synchronized int size() {
	return eventSets.size();
	}

	synchronized void close() {
	if (!closed) {
	closed = true; // OK for this the be first since synchronized

	// place VMDisconnectEvent into queue
	enqueue(new EventSetImpl(vm,
	(byte)JDWP.EventKind.VM_DISCONNECTED));
	}
	}

	public EventSet remove() throws InterruptedException {
	return remove(0);
	}

	/**
	* Filter out events not for user's eyes.
	* Then filter out empty sets.
	*/
	public EventSet remove(long timeout) throws InterruptedException {
	if (timeout < 0) {
	throw new IllegalArgumentException("Timeout cannot be negative");
	}

	EventSet eventSet;
	while (true) {
	EventSetImpl fullEventSet = removeUnfiltered(timeout);
	if (fullEventSet == null) {
	eventSet = null; // timeout
	break;
	}
	/*
	* Remove events from the event set for which
	* there is no corresponding enabled request (
	* this includes our internally requested events.)
	* This never returns null
	*/
	eventSet = fullEventSet.userFilter();
	if (!eventSet.isEmpty()) {
	break;
	}
	}

	if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {
	vm.notifySuspend();
	}

	return eventSet;
	}

	EventSet removeInternal() throws InterruptedException {
	EventSet eventSet;
	do {
	// Waiting forever, so removeUnfiltered() is never null
	eventSet = removeUnfiltered(0).internalFilter();
	} while (eventSet == null \|\| eventSet.isEmpty());

	/*
	* Currently, no internal events are requested with a suspend
	* policy other than none, so we don't check for notifySuspend()
	* here. If this changes in the future, there is much
	* infrastructure that needs to be updated.
	*/

	return eventSet;
	}

	private TimerThread startTimerThread(long timeout) {
	TimerThread thread = new TimerThread(timeout);
	thread.setDaemon(true);
	thread.start();
	return thread;
	}

	private boolean shouldWait(TimerThread timerThread) {
	return !closed && eventSets.isEmpty() &&
	((timerThread == null) ? true : !timerThread.timedOut());
	}

	private EventSetImpl removeUnfiltered(long timeout)
	throws InterruptedException {
	EventSetImpl eventSet = null;

	/*
	* Make sure the VM has completed initialization before
	* trying to build events.
	*/
	vm.waitInitCompletion();

	synchronized(this) {
	if (!eventSets.isEmpty()) {
	/*
	* If there's already something there, no need
	* for anything elaborate.
	*/
	eventSet = (EventSetImpl)eventSets.removeFirst();
	} else {
	/*
	* If a timeout was specified, create a thread to
	* notify this one when a timeout
	* occurs. We can't use the timed version of wait()
	* because it is possible for multiple enqueue() calls
	* before we see something in the eventSet queue
	* (this is possible when multiple threads call
	* remove() concurrently -- not a great idea, but
	* it should be supported). Even if enqueue() did a
	* notify() instead of notifyAll() we are not able to
	* use a timed wait because there's no way to distinguish
	* a timeout from a notify. That limitation implies a
	* possible race condition between a timed out thread
	* and a notified thread.
	*/
	TimerThread timerThread = null;
	try {
	if (timeout > 0) {
	timerThread = startTimerThread(timeout);
	}

	while (shouldWait(timerThread)) {
	this.wait();
	}
	} finally {
	if ((timerThread != null) && !timerThread.timedOut()) {
	timerThread.interrupt();
	}
	}

	if (eventSets.isEmpty()) {
	if (closed) {
	throw new VMDisconnectedException();
	}
	} else {
	eventSet = (EventSetImpl)eventSets.removeFirst();
	}
	}
	}

	// The build is synchronized on the event set, don't hold
	// the queue lock.
	if (eventSet != null) {
	target.notifyDequeueEventSet();
	eventSet.build();
	}
	return eventSet;
	}

	private class TimerThread extends Thread {
	private boolean timedOut = false;
	private long timeout;

	TimerThread(long timeout) {
	super(vm.threadGroupForJDI(), "JDI Event Queue Timer");
	this.timeout = timeout;
	}

	boolean timedOut() {
	return timedOut;
	}

	public void run() {
	try {
	Thread.sleep(timeout);
	EventQueueImpl queue = EventQueueImpl.this;
	synchronized(queue) {
	timedOut = true;
	queue.notifyAll();
	}
	} catch (InterruptedException e) {
	// Exit without notifying
	}
	}
	}
	}

Back to index...