profile java memory use on linux - java

i have a socket server written in java, and i believe there is a memory leak. The i could not find anything in Netbeans' profiler, so i want to test it when it in deployed on my ubuntu server. How do i do this? What is an easy to install and use java profiler for ubuntu?

You can check out jprofiler. This works great.
http://www.ej-technologies.com/download/jprofiler/files.html

Try Java VisualVM:
sudo apt-get install visualvm
jvisualvm

First of all, if you couldn't find anything with the NetBeans profiler, then VisualVM won't give you much more satisfaction as VisualVM is a standalone version of NetBeans profiler.
That being said, my recommendation to hunt memory leaks would be Eclipse Memory Analyzer (MAT). In my opinion, this is simply the best Java heap analyzer you can get (even for money).
See also
Heap Dump Analysis with Memory Analyzer, Part 1: Heap Dumps
Heap Dump Analysis with Memory Analyzer, Part 2: Shallow Size
Automated Heap Dump Analysis: Finding Memory Leaks with One Click
Memory Analyzer Webinar
Getting Started
If you're strictly looking for a CPU and Memory profiler, famous commercial products include YourKit and JProfiler, YourKit being my preferred one (JXInsight is another excellent product but not strictly a profiler).
Related questions
Please recommend a Java profiler
What advantages have a commercial Java profiler over the free ones, e.g. the one in Netbeans?
Open Source Java Profilers
Eclipse Java Profiler
Which Java profiler is better: JProfiler or YourKit?

Related

In java if i extend a class and make it's object in main function, will there be any object of parent class is created in heap? [duplicate]

I've managed to get a memory 'leak' in a java application I'm developing. When running my JUnit test suite I randomly get out of memory exceptions (java.lang.OutOfMemoryError).
What tools can I use to examine the heap of my java application to see what's using up all my heap so that I can work out what's keeping references to objects which should be able to be garbage collected.
VisualVM is included in the most recent releases of Java. You can use this to create a heap dump, and look at the objects in it.
Alternatively, you can also create a heapdump commandine using jmap (in your jdk/bin dir):
jmap -dump:format=b,file=heap.bin <pid>
You can even use this to get a quick histogram of all objects
jmap -histo <pid>
I can recommend Eclipse Memory Analyzer (http://eclipse.org/mat) for advanced analysis of heap dumps. It lets you find out exactly why a certain object or set of objects is alive. Here's a blog entry showing you what Memory Analyzer can do: http://dev.eclipse.org/blogs/memoryanalyzer/2008/05/27/automated-heap-dump-analysis-finding-memory-leaks-with-one-click/
If you need something free, try VisualVM
From the project's description:
VisualVM is a visual tool integrating commandline JDK tools and lightweight profiling capabilities. Designed for both development and production time use.
This is a pretty old question. A lot of people might have started using IntelliJ since it was originally answered. IntelliJ has a plugin that can show memory usage called JVM Debugger Memory View.
Use the Eclipse Memory Analyzer
There's no other tool that I'm aware of any tool that comes close to it's functionality and performance and price (free and open source) when analysing heap dumps.
Use a profiler like JProfiler or YourKitProfiler
JProfiler worked very well for me....
http://www.ej-technologies.com/products/jprofiler/overview.html
If you're using a system which supports GTK you could try using JMP.
You can try the Memory Leak Detector that is part of the JRockit Mission Control tools suite. It allows you to inspect the heap while the JVM is running. You don't need to take snapshots all the time. You can just connect online to the JVM and then see how the heap changes between garbage collections. You can also inspect objects, follow references graphically and get stack traces from where your application is currently allocating objects. Here is a brief introduction.
The tool is free to use for development and you can download it here.

Making a "memory dump" of java application?

I have Java application, which, unfortunately, begins to consume quite big amounts of memory after some time. To complicate things, it's not only Java application, it is also JavaFX 2 application.
I suspect that there is some memory leak, maybe even in underlying JavaFX calls and native libs.
The ideal solution would be to get a dump of all java objects at some moment (with their memory usage), and then analyze that dump. Is there some way to achieve this?
Use jmap -heap:format=b <process-id> to create a binary dump of the heap which can then be loaded into several tools - my favorite being the "Eclipse Memory Analyzer"
There are lots of ways to get a heap dump, starting with simple tools like jmap to more fancy stuff like JVisualVM or even commerical tools as JProfiler. Correctly interpreting those dumps can be tricky though, so you might want to post exactly what you are looking for. Are going hunting for a memory leak, or are you interested in getting a general feel for your application?
You can use jvisualvm. It has plugin to see live memory and get a dump out of it.
I just re-discovered this article (archive.org archive) when researching ways to grab "JVM state right at this moment" - after a heap I pulled with jmap was about half the size of what the MBeans reported. I'll add it for completeness:
su $JVM_OWNER -c "gcore -o /tmp/jvm.core $YOUR_JVM_PID"
su $JVM_OWNER -c "jmap -dump:format=b,file=jvm.hprof /usr/bin/java /tmp/jvm.core"
Requires gdb installed (for gcore) and a JDK installation (for jmap). Also note you'd might need to adjust /usr/bin/java to the path of the JVM used for the process.

Viewing live heap in Eclipse

Is it possible to see the heap of a program in eclipse itself while it is executing? Is there a plugin for that?
I don't know if there is an Eclipse plugin, but if what matters is getting the information and not necessarily through Eclipse then you can do that with JVisualVM, and there are several plugins that provide all the details that you want.
One of its features is that you can make a heap dump.
Documentation says:
Take and browse heap dumps. When you need to browse contents of application memory or uncover a memory leak in your application,
you'll find the built-in HeapWalker tool really handy. It can read
files written in hprof format and is also able to browse heap dumps
created by the JVM on an OutOfMemoryException.
Eclipse does have a plugin called Eclipse Memory Analyzer (MAT). You can check it out here. I heard it is quite handy for heap analysis and fixing memory leaks in your program.
http://www.eclipse.org/mat/

jmap/jhat vs jVisualVM

I understand that jmap is used to create heap dumps and the same can be analysed by Jhat.
jVisualVM also can be used to analyze the heap dumps (and can do much more tasks such as profiling etc).
But what is the difference between analyzing heap dumps using jHat and visualVM (other than one if using Web and second is desktop). What Sun is providing different tools and which one is better?
PS: I have limited understanding of these tools as I have worked on limited profiling/analysis tools such as JProbe, Java Heap Dump Analyzer, etc. Please correct if my understanding is wrong somewhere.
jmap and jhat are the core tools with command line interface. VisualVM is a visual workbench integrating command line tools to manage things more easily without having to work through the command line options. If you know and free comfortable working with command line tools then go with them. VisualVM doesnt do anything extra but provides a good visual interface for a better user experience. I believe it internally uses jmap/jhat.
The difference is analogous to the difference between a graphical debugger and a commandline debugger. It is often easier to work in a visual mode.

General strategy to resolve Java memory leak?

I have a standalone program that I run locally, it is meant to be a server type program running 24/7. Recently I found that it has a memory leak, right now our only solution is to restart it every 4 hours. What is the best way to go about finding this memory leak? Which tool and method should we use?
If you are using Java from Sun and you use at least Java 6 update 10 (i.e. the newest), then try running jvisualvm from the JDK on the same machine as your program is running, and attach to it and enable profiling.
This is most likely the simplest way to get started.
When it comes to hunting memory problems, I use SAP Memory Analyzer Eclipse Memory Analyser (MAT), a Heap Dump analysis tool.
The Memory Analyzer provides a general purpose toolkit to analyze Java heap dumps. Besides heap walking and fast calculation of retained sizes, the Eclipse tool reports leak suspects and memory consumption anti-patterns. The main area of application are Out Of Memory Errors and high memory consumption.
Initiated by SAP, the project has since been open sourced and is now know as Eclipse Memory Analyser. Check out the Getting Started page and especially the Finding Memory Leaks section (I'm pasting it below because I fixed some links):
Start by running the leak report to automatically check for memory leaks.
This blog details How to Find a Leaking Workbench Window.
The Memory Analyzer grew up at SAP. Back then, Krum blogged about Finding Memory Leaks with SAP Memory Analyzer. The content is still relevant!
This is probably the best tool you can get (even for money) for heap dump analysis (and memory leaks).
PS: I do not work for SAP/IBM/Eclipse, I'm just a very happy MAT user with positive feedback.
You need a memory profiler. I recommend trying the Netbeans profiler.
One approach would be to take heap dumps on a regular basis, then trend the instance counts of your classes to try to work out which objects are being consistently created but not collected.
Another would be to switch off parts of your app to try to narrow down where the problem is.
Look at tools like jmap and jhat.
You might look up JMX and the jconsole app that ships with Java. You can get some interesting statistics out-of-the-box, and adding some simple instrumentation to your classes can provide a whole lot more.
As already stated jvisualvm is a great way to get started, but once you know what is leaking you may need to find what is holding references to the objects in question for which I'd recommend jmap and jhat, e.g
jmap -dump:live,file=heap.dump.out,format=b <pid>
and
jhat heap.dump.out
where <pid> is easily found from jvisualvm. Then in a browser navigate to localhost:7000 and begin exploring.
You need to try and capture Java heap dump which is a memory print of the Java process.
It's a critical process for memory consumption optimisation and finding memory leaks.
Java heap dump is an essential object for diagnosing memory-linked issues including java.lang.OutOfMemoryError, Garbage Collection issues, and memory leaks which are all part of Java web development process
For clarity, a Heap dump contains information such as Java classes and objects in a heap during instant of taking the snapshot.
To do it, you need to run jmap -dump:file=myheap.bin <program pid>.
To learn more about how to capture Java heat dumps, check out: https://javatutorial.net/capture-java-heap-dump

Categories

Resources