|
|
Java example source code file (MemoryTab.java)
This example Java source code file (MemoryTab.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The MemoryTab.java Java example source code
/*
* Copyright (c) 2004, 2013, 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.tools.jconsole;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.lang.management.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import javax.accessibility.*;
import javax.management.*;
import javax.management.openmbean.CompositeData;
import javax.swing.*;
import javax.swing.border.*;
import static sun.tools.jconsole.Formatter.*;
import static sun.tools.jconsole.Utilities.*;
@SuppressWarnings("serial")
class MemoryTab extends Tab implements ActionListener, ItemListener {
JComboBox<Plotter> plotterChoice;
TimeComboBox timeComboBox;
JButton gcButton;
PlotterPanel plotterPanel;
JPanel bottomPanel;
HTMLPane details;
PoolChart poolChart;
ArrayList<Plotter> plotterList;
Plotter heapPlotter, nonHeapPlotter;
private MemoryOverviewPanel overviewPanel;
private static final String usedKey = "used";
private static final String committedKey = "committed";
private static final String maxKey = "max";
private static final String thresholdKey = "threshold";
private static final Color usedColor = Plotter.defaultColor;
private static final Color committedColor = null;
private static final Color maxColor = null;
private static final Color thresholdColor = Color.red;
/*
Hierarchy of panels and layouts for this tab:
MemoryTab (BorderLayout)
North: topPanel (BorderLayout)
Center: controlPanel (FlowLayout)
plotterChoice, timeComboBox
East: topRightPanel (FlowLayout)
gcButton
Center: plotterPanel
Center: plotter
South: bottomPanel (BorderLayout)
Center: details
East: poolChart
*/
public static String getTabName() {
return Messages.MEMORY;
}
public MemoryTab(VMPanel vmPanel) {
super(vmPanel, getTabName());
setLayout(new BorderLayout(0, 0));
setBorder(new EmptyBorder(4, 4, 3, 4));
JPanel topPanel = new JPanel(new BorderLayout());
plotterPanel = new PlotterPanel(null);
bottomPanel = new JPanel(new BorderLayout());
add(topPanel, BorderLayout.NORTH);
add(plotterPanel, BorderLayout.CENTER);
JPanel controlPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 20, 5));
topPanel.add(controlPanel, BorderLayout.CENTER);
// Plotter choice
plotterChoice = new JComboBox<Plotter>();
plotterChoice.addItemListener(this);
controlPanel.add(new LabeledComponent(Messages.CHART_COLON,
Resources.getMnemonicInt(Messages.CHART_COLON),
plotterChoice));
// Range control
timeComboBox = new TimeComboBox();
controlPanel.add(new LabeledComponent(Messages.TIME_RANGE_COLON,
Resources.getMnemonicInt(Messages.TIME_RANGE_COLON),
timeComboBox));
gcButton = new JButton(Messages.PERFORM_GC);
gcButton.setMnemonic(Resources.getMnemonicInt(Messages.PERFORM_GC));
gcButton.addActionListener(this);
gcButton.setToolTipText(Messages.PERFORM_GC_TOOLTIP);
JPanel topRightPanel = new JPanel();
topRightPanel.setBorder(new EmptyBorder(0, 65-8, 0, 70));
topRightPanel.add(gcButton);
topPanel.add(topRightPanel, BorderLayout.AFTER_LINE_ENDS);
bottomPanel.setBorder(new CompoundBorder(new TitledBorder(Messages.DETAILS),
new EmptyBorder(10, 10, 10, 10)));
details = new HTMLPane();
setAccessibleName(details, Messages.DETAILS);
bottomPanel.add(new JScrollPane(details), BorderLayout.CENTER);
poolChart = new PoolChart();
bottomPanel.add(poolChart, BorderLayout.AFTER_LINE_ENDS);
}
private void createPlotters() throws IOException {
plotterList = new ArrayList<Plotter>();
ProxyClient proxyClient = vmPanel.getProxyClient();
heapPlotter = new Plotter(Plotter.Unit.BYTES) {
public String toString() {
return Messages.HEAP_MEMORY_USAGE;
}
};
proxyClient.addWeakPropertyChangeListener(heapPlotter);
nonHeapPlotter = new Plotter(Plotter.Unit.BYTES) {
public String toString() {
return Messages.NON_HEAP_MEMORY_USAGE;
}
};
setAccessibleName(heapPlotter,
Messages.MEMORY_TAB_HEAP_PLOTTER_ACCESSIBLE_NAME);
setAccessibleName(nonHeapPlotter,
Messages.MEMORY_TAB_NON_HEAP_PLOTTER_ACCESSIBLE_NAME);
proxyClient.addWeakPropertyChangeListener(nonHeapPlotter);
heapPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
heapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
heapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
nonHeapPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
nonHeapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
nonHeapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
plotterList.add(heapPlotter);
plotterList.add(nonHeapPlotter);
// Now add memory pools
Map<ObjectName, MBeanInfo> mBeanMap = proxyClient.getMBeans("java.lang");
Set<ObjectName> keys = mBeanMap.keySet();
ObjectName[] objectNames = keys.toArray(new ObjectName[keys.size()]);
ArrayList<PoolPlotter> nonHeapPlotters = new ArrayList(2);
for (ObjectName objectName : objectNames) {
String type = objectName.getKeyProperty("type");
if (type.equals("MemoryPool")) {
String name = Resources.format(Messages.MEMORY_POOL_LABEL,
objectName.getKeyProperty("name"));
// Heap or non-heap?
boolean isHeap = false;
AttributeList al =
proxyClient.getAttributes(objectName,
new String[] { "Type" });
if (al.size() > 0) {
isHeap = MemoryType.HEAP.name().equals(((Attribute)al.get(0)).getValue());
}
PoolPlotter poolPlotter = new PoolPlotter(objectName, name, isHeap);
proxyClient.addWeakPropertyChangeListener(poolPlotter);
poolPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
poolPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
poolPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
poolPlotter.createSequence(thresholdKey, Messages.THRESHOLD, thresholdColor, false);
poolPlotter.setUseDashedTransitions(thresholdKey, true);
if (isHeap) {
plotterList.add(poolPlotter);
} else {
// Will be added to plotterList below
nonHeapPlotters.add(poolPlotter);
}
}
}
// Add non-heap plotters last
for (PoolPlotter poolPlotter : nonHeapPlotters) {
plotterList.add(poolPlotter);
}
}
public void itemStateChanged(ItemEvent ev) {
if (ev.getStateChange() == ItemEvent.SELECTED) {
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
plotterPanel.setPlotter(plotter);
plotterPanel.repaint();
}
}
public void gc() {
new Thread("MemoryPanel.gc") {
public void run() {
ProxyClient proxyClient = vmPanel.getProxyClient();
try {
proxyClient.getMemoryMXBean().gc();
} catch (UndeclaredThrowableException e) {
proxyClient.markAsDead();
} catch (IOException e) {
// Ignore
}
}
}.start();
}
public SwingWorker<?, ?> newSwingWorker() {
return new SwingWorker<Boolean, Object>() {
private long[] used, committed, max, threshold;
private long timeStamp;
private String detailsStr;
private boolean initialRun = false;
public Boolean doInBackground() {
ProxyClient proxyClient = vmPanel.getProxyClient();
if (plotterList == null) {
try {
createPlotters();
} catch (UndeclaredThrowableException e) {
proxyClient.markAsDead();
return false;
} catch (final IOException ex) {
return false;
}
initialRun = true;
}
int n = plotterList.size();
used = new long[n];
committed = new long[n];
max = new long[n];
threshold = new long[n];
timeStamp = System.currentTimeMillis();
for (int i = 0; i < n; i++) {
Plotter plotter = plotterList.get(i);
MemoryUsage mu = null;
used[i] = -1L;
threshold[i] = -1L;
try {
if (plotter instanceof PoolPlotter) {
PoolPlotter poolPlotter = (PoolPlotter)plotter;
ObjectName objectName = poolPlotter.objectName;
AttributeList al =
proxyClient.getAttributes(objectName,
new String[] { "Usage", "UsageThreshold" });
if (al.size() > 0) {
CompositeData cd = (CompositeData)((Attribute)al.get(0)).getValue();
mu = MemoryUsage.from(cd);
if (al.size() > 1) {
threshold[i] = (Long)((Attribute)al.get(1)).getValue();
}
}
} else if (plotter == heapPlotter) {
mu = proxyClient.getMemoryMXBean().getHeapMemoryUsage();
} else if (plotter == nonHeapPlotter) {
mu = proxyClient.getMemoryMXBean().getNonHeapMemoryUsage();
}
} catch (UndeclaredThrowableException e) {
proxyClient.markAsDead();
return false;
} catch (IOException ex) {
// Skip this plotter
}
if (mu != null) {
used[i] = mu.getUsed();
committed[i] = mu.getCommitted();
max[i] = mu.getMax();
}
}
detailsStr = formatDetails();
return true;
}
protected void done() {
try {
if (!get()) {
return;
}
} catch (InterruptedException ex) {
return;
} catch (ExecutionException ex) {
if (JConsole.isDebug()) {
ex.printStackTrace();
}
return;
}
if (initialRun) {
// Add Memory Pools
for (Plotter p : plotterList) {
plotterChoice.addItem(p);
timeComboBox.addPlotter(p);
}
add(bottomPanel, BorderLayout.SOUTH);
}
int n = plotterList.size();
int poolCount = 0;
for (int i = 0; i < n; i++) {
Plotter plotter = plotterList.get(i);
if (used[i] >= 0L) {
if (plotter instanceof PoolPlotter) {
plotter.addValues(timeStamp, used[i], committed[i], max[i], threshold[i]);
if (threshold[i] > 0L) {
plotter.setIsPlotted(thresholdKey, true);
}
poolChart.setValue(poolCount++, (PoolPlotter)plotter,
used[i], threshold[i], max[i]);
} else {
plotter.addValues(timeStamp, used[i], committed[i], max[i]);
}
if (plotter == heapPlotter && overviewPanel != null) {
overviewPanel.getPlotter().addValues(timeStamp, used[i]);
overviewPanel.updateMemoryInfo(used[i], committed[i], max[i]);
}
}
}
details.setText(detailsStr);
}
};
}
private String formatDetails() {
ProxyClient proxyClient = vmPanel.getProxyClient();
if (proxyClient.isDead()) {
return "";
}
String text = "<table cellspacing=0 cellpadding=0>";
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
if (plotter == null) {
return "";
}
//long time = plotter.getLastTimeStamp();
long time = System.currentTimeMillis();
String timeStamp = formatDateTime(time);
text += newRow(Messages.TIME, timeStamp);
long used = plotter.getLastValue(usedKey);
long committed = plotter.getLastValue(committedKey);
long max = plotter.getLastValue(maxKey);
long threshold = plotter.getLastValue(thresholdKey);
text += newRow(Messages.USED, formatKBytes(used));
if (committed > 0L) {
text += newRow(Messages.COMMITTED, formatKBytes(committed));
}
if (max > 0L) {
text += newRow(Messages.MAX, formatKBytes(max));
}
if (threshold > 0L) {
text += newRow(Messages.USAGE_THRESHOLD, formatKBytes(threshold));
}
try {
Collection<GarbageCollectorMXBean> garbageCollectors =
proxyClient.getGarbageCollectorMXBeans();
boolean descPrinted = false;
for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) {
String gcName = garbageCollectorMBean.getName();
long gcCount = garbageCollectorMBean.getCollectionCount();
long gcTime = garbageCollectorMBean.getCollectionTime();
String str = Resources.format(Messages.GC_TIME_DETAILS, justify(formatTime(gcTime), 14),
gcName,
String.format("%,d",gcCount));
if (!descPrinted) {
text += newRow(Messages.GC_TIME, str);
descPrinted = true;
} else {
text += newRow(null, str);
}
}
} catch (IOException e) {
}
return text;
}
public void actionPerformed(ActionEvent ev) {
Object src = ev.getSource();
if (src == gcButton) {
gc();
}
}
private class PoolPlotter extends Plotter {
ObjectName objectName;
String name;
boolean isHeap;
long value, threshold, max;
int barX;
public PoolPlotter(ObjectName objectName, String name, boolean isHeap) {
super(Plotter.Unit.BYTES);
this.objectName = objectName;
this.name = name;
this.isHeap = isHeap;
setAccessibleName(this,
Resources.format(Messages.MEMORY_TAB_POOL_PLOTTER_ACCESSIBLE_NAME,
name));
}
public String toString() {
return name;
}
}
private class PoolChart extends BorderedComponent
implements Accessible, MouseListener {
final int height = 150;
final int leftMargin = 50;
final int rightMargin = 23;
final int bottomMargin = 35;
final int barWidth = 22;
final int barGap = 3;
final int groupGap = 8;
final int barHeight = height * 2 / 3;
final Color greenBar = new Color(100, 255, 100);
final Color greenBarBackground = new Color(210, 255, 210);
final Color redBarBackground = new Color(255, 210, 210);
Font smallFont = null;
ArrayList<PoolPlotter> poolPlotters = new ArrayList(5);
int nHeapPools = 0;
int nNonHeapPools = 0;
Rectangle heapRect = new Rectangle(leftMargin, height - bottomMargin + 6, barWidth, 20);
Rectangle nonHeapRect = new Rectangle(leftMargin + groupGap, height - bottomMargin + 6, barWidth, 20);
public PoolChart() {
super(null, null);
setFocusable(true);
addMouseListener(this);
ToolTipManager.sharedInstance().registerComponent(this);
}
public void setValue(int poolIndex, PoolPlotter poolPlotter,
long value, long threshold, long max) {
poolPlotter.value = value;
poolPlotter.threshold = threshold;
poolPlotter.max = max;
if (poolIndex == poolPlotters.size()) {
poolPlotters.add(poolPlotter);
if (poolPlotter.isHeap) {
poolPlotter.barX = nHeapPools * (barWidth + barGap);
nHeapPools++;
heapRect.width = nHeapPools * barWidth + (nHeapPools - 1) * barGap;
nonHeapRect.x = leftMargin + heapRect.width + groupGap;
} else {
poolPlotter.barX = nonHeapRect.x - leftMargin + nNonHeapPools * (barWidth + barGap);
nNonHeapPools++;
nonHeapRect.width = nNonHeapPools * barWidth + (nNonHeapPools - 1) * barGap;
}
} else {
poolPlotters.set(poolIndex, poolPlotter);
}
repaint();
}
private void paintPoolBar(Graphics g, PoolPlotter poolPlotter) {
Rectangle barRect = getBarRect(poolPlotter);
g.setColor(Color.gray);
g.drawRect(barRect.x, barRect.y, barRect.width, barRect.height);
long value = poolPlotter.value;
long max = poolPlotter.max;
if (max > 0L) {
g.translate(barRect.x, barRect.y);
// Paint green background
g.setColor(greenBarBackground);
g.fillRect(1, 1, barRect.width - 1, barRect.height - 1);
int greenHeight = (int)(value * barRect.height / max);
long threshold = poolPlotter.threshold;
if (threshold > 0L) {
int redHeight = (int)(threshold * barRect.height / max);
// Paint red background
g.setColor(redBarBackground);
g.fillRect(1, 1, barRect.width - 1, barRect.height - redHeight);
if (value > threshold) {
// Over threshold, paint red bar
g.setColor(thresholdColor);
g.fillRect(1, barRect.height - greenHeight,
barRect.width - 1, greenHeight - redHeight);
greenHeight = redHeight;
}
}
// Paint green bar
g.setColor(greenBar);
g.fillRect(1, barRect.height - greenHeight,
barRect.width - 1, greenHeight);
g.translate(-barRect.x, -barRect.y);
}
}
public void paintComponent(Graphics g) {
super.paintComponent(g);
if (poolPlotters.size() == 0) {
return;
}
if (smallFont == null) {
smallFont = g.getFont().deriveFont(9.0F);
}
// Paint background for chart area
g.setColor(getBackground());
Rectangle r = g.getClipBounds();
g.fillRect(r.x, r.y, r.width, r.height);
g.setFont(smallFont);
FontMetrics fm = g.getFontMetrics();
int fontDescent = fm.getDescent();
// Paint percentage axis
g.setColor(getForeground());
for (int pc : new int[] { 0, 25, 50, 75, 100 }) {
String str = pc + "% --";
g.drawString(str,
leftMargin - fm.stringWidth(str) - 4,
height - bottomMargin - (pc * barHeight / 100) + fontDescent + 1);
}
for (PoolPlotter poolPlotter : poolPlotters) {
paintPoolBar(g, poolPlotter);
}
g.setColor(Color.gray);
g.drawRect(heapRect.x, heapRect.y, heapRect.width, heapRect.height);
g.drawRect(nonHeapRect.x, nonHeapRect.y, nonHeapRect.width, nonHeapRect.height);
Color heapColor = greenBar;
Color nonHeapColor = greenBar;
for (PoolPlotter poolPlotter : poolPlotters) {
if (poolPlotter.threshold > 0L && poolPlotter.value > poolPlotter.threshold) {
if (poolPlotter.isHeap) {
heapColor = thresholdColor;
} else {
nonHeapColor = thresholdColor;
}
}
}
g.setColor(heapColor);
g.fillRect(heapRect.x + 1, heapRect.y + 1, heapRect.width - 1, heapRect.height - 1);
g.setColor(nonHeapColor);
g.fillRect(nonHeapRect.x + 1, nonHeapRect.y + 1, nonHeapRect.width - 1, nonHeapRect.height - 1);
String str = Messages.HEAP;
int stringWidth = fm.stringWidth(str);
int x = heapRect.x + (heapRect.width - stringWidth) / 2;
int y = heapRect.y + heapRect.height - 6;
g.setColor(Color.white);
g.drawString(str, x-1, y-1);
g.drawString(str, x+1, y-1);
g.drawString(str, x-1, y+1);
g.drawString(str, x+1, y+1);
g.setColor(Color.black);
g.drawString(str, x, y);
str = Messages.NON_HEAP;
stringWidth = fm.stringWidth(str);
x = nonHeapRect.x + (nonHeapRect.width - stringWidth) / 2;
y = nonHeapRect.y + nonHeapRect.height - 6;
g.setColor(Color.white);
g.drawString(str, x-1, y-1);
g.drawString(str, x+1, y-1);
g.drawString(str, x-1, y+1);
g.drawString(str, x+1, y+1);
g.setColor(Color.black);
g.drawString(str, x, y);
// Highlight current plotter
g.setColor(Color.blue);
r = null;
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
if (plotter == heapPlotter) {
r = heapRect;
} else if (plotter == nonHeapPlotter) {
r = nonHeapRect;
} else if (plotter instanceof PoolPlotter) {
r = getBarRect((PoolPlotter)plotter);
}
if (r != null) {
g.drawRect(r.x - 1, r.y - 1, r.width + 2, r.height + 2);
}
}
private Rectangle getBarRect(PoolPlotter poolPlotter) {
return new Rectangle(leftMargin + poolPlotter.barX,
height - bottomMargin - barHeight,
barWidth, barHeight);
}
public Dimension getPreferredSize() {
return new Dimension(nonHeapRect.x + nonHeapRect.width + rightMargin,
height);
}
public void mouseClicked(MouseEvent e) {
requestFocusInWindow();
Plotter plotter = getPlotter(e);
if (plotter != null && plotter != plotterChoice.getSelectedItem()) {
plotterChoice.setSelectedItem(plotter);
repaint();
}
}
public String getToolTipText(MouseEvent e) {
Plotter plotter = getPlotter(e);
return (plotter != null) ? plotter.toString() : null;
}
private Plotter getPlotter(MouseEvent e) {
Point p = e.getPoint();
Plotter plotter = null;
if (heapRect.contains(p)) {
plotter = heapPlotter;
} else if (nonHeapRect.contains(p)) {
plotter = nonHeapPlotter;
} else {
for (PoolPlotter poolPlotter : poolPlotters) {
if (getBarRect(poolPlotter).contains(p)) {
plotter = poolPlotter;
break;
}
}
}
return plotter;
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public AccessibleContext getAccessibleContext() {
if (accessibleContext == null) {
accessibleContext = new AccessiblePoolChart();
}
return accessibleContext;
}
protected class AccessiblePoolChart extends AccessibleJPanel {
public String getAccessibleName() {
String name = Messages.MEMORY_TAB_POOL_CHART_ACCESSIBLE_NAME;
String keyValueList = "";
for (PoolPlotter poolPlotter : poolPlotters) {
String value = (poolPlotter.value * 100 / poolPlotter.max) + "%";
// Assume format string ends with newline
keyValueList +=
Resources.format(Messages.PLOTTER_ACCESSIBLE_NAME_KEY_AND_VALUE,
poolPlotter.toString(), value);
if (poolPlotter.threshold > 0L) {
String threshold =
(poolPlotter.threshold * 100 / poolPlotter.max) + "%";
if (poolPlotter.value > poolPlotter.threshold) {
keyValueList +=
Resources.format(Messages.MEMORY_TAB_POOL_CHART_ABOVE_THRESHOLD,
threshold);
} else {
keyValueList +=
Resources.format(Messages.MEMORY_TAB_POOL_CHART_BELOW_THRESHOLD,
threshold);
}
}
}
return name + "\n" + keyValueList + ".";
}
}
}
OverviewPanel[] getOverviewPanels() {
if (overviewPanel == null) {
overviewPanel = new MemoryOverviewPanel();
}
return new OverviewPanel[] { overviewPanel };
}
private static class MemoryOverviewPanel extends OverviewPanel {
MemoryOverviewPanel() {
super(Messages.HEAP_MEMORY_USAGE, usedKey, Messages.USED, Plotter.Unit.BYTES);
}
private void updateMemoryInfo(long used, long committed, long max) {
getInfoLabel().setText(Resources.format(Messages.MEMORY_TAB_INFO_LABEL_FORMAT,
formatBytes(used, true),
formatBytes(committed, true),
formatBytes(max, true)));
}
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java MemoryTab.java source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project
