/*
 * Copyright (c) 2004, 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 sun.jvmstat.perfdata.monitor.protocol.local;

import java.util.*;
import java.lang.reflect.*;
import java.io.*;

import sun.jvmstat.monitor.*;
import sun.jvmstat.monitor.event.*;
import sun.jvmstat.perfdata.monitor.*;

Concrete implementation of the AbstractMonitoredVm class for the local: protocol for the HotSpot PerfData monitoring implementation.

This class provides the ability to attach to the instrumentation buffer of a live target Java Virtual Machine through a HotSpot specific attach mechanism.

Author:Brian Doherty
Since:1.5
/** * Concrete implementation of the AbstractMonitoredVm class for the * <em>local:</em> protocol for the HotSpot PerfData monitoring implementation. * <p> * This class provides the ability to attach to the instrumentation buffer * of a live target Java Virtual Machine through a HotSpot specific attach * mechanism. * * @author Brian Doherty * @since 1.5 */
public class LocalMonitoredVm extends AbstractMonitoredVm {
List of registered listeners.
/** * List of registered listeners. */
private ArrayList<VmListener> listeners;
Task performing listener notification.
/** * Task performing listener notification. */
private NotifierTask task;
Create a LocalMonitoredVm instance.
Params:
  • vmid – the vm identifier specifying the target JVM
  • interval – the sampling interval
/** * Create a LocalMonitoredVm instance. * * @param vmid the vm identifier specifying the target JVM * @param interval the sampling interval */
public LocalMonitoredVm(VmIdentifier vmid, int interval) throws MonitorException { super(vmid, interval); this.pdb = new PerfDataBuffer(vmid); listeners = new ArrayList<VmListener>(); }
{@inheritDoc}.
/** * {@inheritDoc}. */
public void detach() { if (interval > 0) { /* * if the notifier task is running, stop it, otherwise it can * access non-existent memory once we've detached from the * underlying buffer. */ if (task != null) { task.cancel(); task = null; } } super.detach(); }
{@inheritDoc}.
/** * {@inheritDoc}. */
public void addVmListener(VmListener l) { synchronized(listeners) { listeners.add(l); if (task == null) { task = new NotifierTask(); LocalEventTimer timer = LocalEventTimer.getInstance(); timer.schedule(task, interval, interval); } } }
{@inheritDoc}.
/** * {@inheritDoc}. */
public void removeVmListener(VmListener l) { synchronized(listeners) { listeners.remove(l); if (listeners.isEmpty() && task != null) { task.cancel(); task = null; } } }
{@inheritDoc}.
/** * {@inheritDoc}. */
public void setInterval(int newInterval) { synchronized(listeners) { if (newInterval == interval) { return; } int oldInterval = interval; super.setInterval(interval); if (task != null) { task.cancel(); NotifierTask oldTask = task; task = new NotifierTask(); LocalEventTimer timer = LocalEventTimer.getInstance(); CountedTimerTaskUtils.reschedule(timer, oldTask, task, oldInterval, newInterval); } } }
Fire MonitoredVmStructureChanged events.
Params:
  • inserted – List of Monitor objects inserted.
  • removed – List of Monitor objects removed.
/** * Fire MonitoredVmStructureChanged events. * * @param inserted List of Monitor objects inserted. * @param removed List of Monitor objects removed. */
void fireMonitorStatusChangedEvents(List inserted, List removed) { MonitorStatusChangeEvent ev = null; ArrayList registered = null; synchronized (listeners) { registered = (ArrayList)listeners.clone(); } for (Iterator i = registered.iterator(); i.hasNext(); /* empty */) { VmListener l = (VmListener)i.next(); // lazily create the event object; if (ev == null) { ev = new MonitorStatusChangeEvent(this, inserted, removed); } l.monitorStatusChanged(ev); } }
Fire MonitoredUpdated events.
/** * Fire MonitoredUpdated events. */
void fireMonitorsUpdatedEvents() { VmEvent ev = null; ArrayList<VmListener> registered = null; synchronized (listeners) { registered = cast(listeners.clone()); } for (VmListener l : registered) { // lazily create the event object; if (ev == null) { ev = new VmEvent(this); } l.monitorsUpdated(ev); } }
Class to notify listeners of Monitor related events for the target JVM.
/** * Class to notify listeners of Monitor related events for * the target JVM. */
private class NotifierTask extends CountedTimerTask { public void run() { super.run(); try { MonitorStatus status = getMonitorStatus(); List inserted = status.getInserted(); List removed = status.getRemoved(); if (!inserted.isEmpty() || !removed.isEmpty()) { fireMonitorStatusChangedEvents(inserted, removed); } fireMonitorsUpdatedEvents(); } catch (MonitorException e) { // XXX: use logging api System.err.println("Exception updating monitors for " + getVmIdentifier()); e.printStackTrace(); } } } // Suppress unchecked cast warning msg. @SuppressWarnings("unchecked") static <T> T cast(Object x) { return (T) x; } }