Java EventQueue类代码示例

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
/**
 * Run the event handling thread.
 * 
 * As long as the thread remains connected to the VM, events are removed
 * from the queue and dispatched.
 */
@Override
public void run() {
    EventQueue queue = vm.eventQueue();

    while (connected) {
        try {
            EventSet eventSet = queue.remove();

            EventIterator eventIterator = eventSet.eventIterator();
            while (eventIterator.hasNext()) {
                handleEvent(eventIterator.nextEvent());
            }
            eventSet.resume();
        } catch (InterruptedException ie) {
            vm.dispose();
            break;
        } catch (VMDisconnectedException vmde) {
            handleDisconnectedException();
            break;
        }
    }
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
private void eventLoop() throws InterruptedException {
	System.out.println("eventLoop started");
	EventQueue eventQueue = vm.eventQueue();
	boolean isRunning = true;
	while (isRunning) {
		EventSet eventSet = eventQueue.remove();
		boolean mayResume = true;
		for (Event event : eventSet) {
			System.out.println(event);
			if (event instanceof VMDeathEvent
					|| event instanceof VMDisconnectEvent) {
				isRunning = false;
			} else if (event instanceof ExceptionEvent) {
				mayResume = false;
			}
		}
		if (mayResume) eventSet.resume();
	}
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
/***
* A VMDisconnectedException has happened while dealing with
* another event. We need to flush the event queue, dealing only
* with exit events (VMDeath, VMDisconnect) so that we terminate
* correctly.
*/
   synchronized void handleDisconnectedException() {
       EventQueue queue = vm.eventQueue();
       while (connected) {
           try {
               EventSet eventSet = queue.remove();
               EventIterator iter = eventSet.eventIterator();
               while (iter.hasNext()) {
                   Event event = iter.nextEvent();
                   if (event instanceof VMDeathEvent) {
                       vmDeathManager.vmDeathEvent((VMDeathEvent)event,enableProfiling);
                   } else if (event instanceof VMDisconnectEvent) {
                       connected=disconnect.vmDisconnectEvent((VMDisconnectEvent)event);
                   }
               }
               eventSet.resume(); // Resume the VM
               
           } catch (InterruptedException exc) {
               exc.printStackTrace();
           }
       }
   }
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
public EventQueue eventQueue() {
    /*
     * No VM validation here. We allow access to the event queue
     * after disconnection, so that there is access to the terminating
     * events.
     */
    return eventQueue;
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
void notifyDequeueEventSet() {
    int maxQueueSize = 0;
    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }
    controlEventFlow(maxQueueSize);
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
private void queueEventSet(EventSet eventSet) {
    int maxQueueSize = 0;

    synchronized(eventQueues) {
        Iterator<EventQueue> iter = eventQueues.iterator();
        while (iter.hasNext()) {
            EventQueueImpl queue = (EventQueueImpl)iter.next();
            queue.enqueue(eventSet);
            maxQueueSize = Math.max(maxQueueSize, queue.size());
        }
    }

    controlEventFlow(maxQueueSize);
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
private void loop(BreakpointRequest br, Field contextField) throws Exception {
  int lineNumber = br.location().lineNumber();

  br.setSuspendPolicy(BreakpointRequest.SUSPEND_EVENT_THREAD);
  br.enable();
  EventQueue evtQueue = vm.eventQueue();
  boolean run = true;
  while (run) {
    EventSet evtSet = evtQueue.remove();
    EventIterator evtIter = evtSet.eventIterator();
    while (evtIter.hasNext()) {
      try {
        Event evt = evtIter.next();
        EventRequest evtReq = evt.request();
        if (evtReq instanceof BreakpointRequest
            && ((BreakpointRequest) evtReq).location().lineNumber() == lineNumber) {
          new BreakpointProcessor(missingPerms)
              .processBreakpoint(contextField, (BreakpointEvent) evt);

          // TODO: 12/20/17 Remove when full loop processing is restored
          // run = false;
          System.out.println(missingPerms);
          missingPerms.clear();
        }
      } finally {
        evtSet.resume();
      }
    }
  }

  //    System.out.println(missingPerms);
  //    printPerms(missingPerms);
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
public EventQueue eventQueue() {
  return myVirtualMachine.eventQueue();
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
EventsCollector(EventQueue queue, EventsHandler handler) {
  this.queue = queue;
  this.handler = handler;

  thread = new Thread(this);
  running = true;
  thread.start();
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
public F3EventQueue(F3VirtualMachine f3vm, EventQueue underlying) {
    super(f3vm, underlying);
    
    eventsToBePassed.add(F3ClassPrepareEvent.class);
    eventsToBePassed.add(F3VMDeathEvent.class);
    eventsToBePassed.add(F3VMDisconnectEvent.class);
    eventsToBePassed.add(F3VMStartEvent.class);
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
@Test
public void testEventQueueNotNull() {
    EventQueue evtQ = getVM().eventQueue();
    if (evtQ == null) {
        Assert.fail("EventQueue is null!");
    }
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
/**
 * A {@link VMDisconnectedException} has happened while dealing with another
 * event. We need to flush the event queue, dealing only with exit events (
 * {@link VMDeatEvent} and {@link VMDisconnectEvent}) so that we terminate
 * correctly.
 */
private void handleDisconnectedException() {
    EventQueue queue = vm.eventQueue();

    while (connected) {
        try {
            EventSet eventSet = queue.remove();

            EventIterator eventIterator = eventSet.eventIterator();
            while (eventIterator.hasNext()) {
                Event event = eventIterator.nextEvent();

                if (event instanceof VMDeathEvent) {
                    handleEvent(event);
                } else if (event instanceof VMDisconnectEvent) {
                    handleEvent(event);
                    connected = false;
                }
            }
            eventSet.resume();
        } catch (InterruptedException ie) {
            vm.dispose();
            break;
        } catch (VMDisconnectedException vmde) {
            break;
        }
    }
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
/**
* Run the event handling thread.
* As long as we are connected, get event sets off
* the queue and dispatch the events within them.
*/

   public void run() {
       EventQueue queue = vm.eventQueue();
               
       while (connected && !forceExit) {
           try {
           	
                EventSet eventSet = queue.remove();
                EventIterator it = eventSet.eventIterator();
                while (it.hasNext())
               	 handleEvent(it.nextEvent());
                eventSet.resume();
                
           } catch (InterruptedException exc) {
              exc.printStackTrace();
           } catch (VMDisconnectedException discExc) {
           	discExc.printStackTrace();
               handleDisconnectedException();
               break;
           }
       }
       
       if (forceExit){
       	vm.exit(-1);
       	if (!enableProfiling)
       		writer.close();
       	tracer.finishedTrace();
       }
   }
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
public EventQueue eventQueue() {
    throwNotReadOnlyException("VirtualMachine.eventQueue()");
    return null;
}
 

import com.sun.jdi.event.EventQueue; //导入依赖的package包/类
/**
 * Starts retrieving events from the event queue of the specified virtual machine.
 *
 * @param vm
 *            the target virtual machine.
 */
@Override
public void start(VirtualMachine vm) {
    if (isClosed) {
        throw new IllegalStateException("This event hub is already closed.");
    }

    workingThread = new Thread(() -> {
        EventQueue queue = vm.eventQueue();
        while (true) {
            try {
                if (Thread.interrupted()) {
                    subject.onComplete();
                    return;
                }

                EventSet set = queue.remove();

                boolean shouldResume = true;
                for (Event event : set) {
                    try {
                        logger.fine("\nJDI Event: " + event + "\n");
                    } catch (VMDisconnectedException e) {
                        // do nothing
                    }
                    DebugEvent dbgEvent = new DebugEvent();
                    dbgEvent.event = event;
                    dbgEvent.eventSet = set;
                    subject.onNext(dbgEvent);
                    shouldResume &= dbgEvent.shouldResume;
                }

                if (shouldResume) {
                    set.resume();
                }
            } catch (InterruptedException e) {
                isClosed = true;
                subject.onComplete();
                return;
            } catch (VMDisconnectedException e) {
                isClosed = true;
                subject.onError(e);
                return;
            }
        }
    }, "Event Hub");

    workingThread.start();
}