JProfiler is an award-winning all-in-one Java profiler.

JProfiler's intuitive GUI helps you find performance bottlenecks, pin down memory leaks and resolve threading issues. *Exceptional ease of use * When you profile, you need the most powerful tool you can get. At the same time, you do not want to spend time learning how to use the tool. JProfiler is just that: simple and powerful at the same time. Configuring sessions is straight-forward, third party integrations make getting started a breeze and profiling data is presented in a natural way. On all levels, JProfiler has been carefully designed to help you get started with solving your problems. *Real-time display of profiling data* With JProfiler you can immediately observe profiling data as your application is running. CPU, memory and thread profiling views are updated live and can be inspected without the need to wait for the measurement to complete. For a large number of use-cases, this ability provides you with an extremely fast path to a solution. In addition, you can save snapshots at any time, interactively as well as programmatically. *The unique heap walker * Finding a memory leak can be impossible without the right tool. JProfiler's heap walker offers you an intuitive interface to solve both simple and complex memory problems. 5 different views show different aspects of the current set of objects. Each view allows you to create new object sets based on the displayed data. Each view provides you with essential insights on the selected objects. Questions like why objects are not garbage collected are answered with a single click of the mouse. *The powerful CPU profiler* Fixing performance bottlenecks is the most frequent use case for a profiler. However, CPU data can be overwhelming in its level of detail and the way data is collected can make a huge difference in usability. With JProfiler, you have a decisive advantage when trying to find the reason for a problem. Call tree view filters, aggregation levels and thread status selectors are just some examples of JProfiler's versatility in this area. *The integrated thread profiler*

Problems related to threading are much more frequent than one might assume. Without a thread profiler, you only have a minimal chance to tackle such issues. A whole range of otherwise opaque problems can be solved when using JProfiler, such as increasing liveness in a multi-threaded application that uses too much locking. Thread profiling not only has a separate view section in JProfiler, it is also tightly integrated into the CPU profiling views. *Excellent support for Java Enterprise Edition* Dedicated support for JEE is present in most views in JProfiler. For example, in the JEE aggregation level you see the call tree in terms of the JEE components in your application. Also, JProfiler adds a semantic layer on top of the low-level profiling data, like JDBC, JMS and JNDI calls that are presented in the CPU profiling views. With its JEE support, JProfiler bridges the gap between a code profiler and a high-level JEE monitoring tool. *Extensive QA capabilities * JProfiler is ideally suited as a QA tool, both during development as well as for dedicated QA teams. The rich functionality around snapshot comparisons makes it easy to track progress. JProfiler has strong support for command line operations. This includes the ability to profile, export snapshot data and create snapshots comparisons from the command line. The ant tasks bundled with JProfiler allow you to perform all command line operations from your build script. *Broadest support for platforms, IDEs and application servers* JProfiler integrates into your environment: We provide native agent libraries for a wide range of platforms, both for 32-bit and 64-bit JVMs. Integrations into all popular IDEs makes profiling during development as easy as running your application. And the large number of integrations wizards for nearly all application servers on the market ensures that you can get started with a few clicks and not with reading documentation. *Low overhead* JProfiler records data only when you need it. In fact, you can start your application with the JProfiler agent and attach the JProfiler GUI at a later time. When you do not record any data, the overhead is extremely small. That's what we call on demand profiling.

Invariably, there are a lot of things you can adjust in an advanced profiler. JProfiler shows you how your profiling settings will impact performance and offers you templates to quickly select profiling settings for common use cases. *Extensibility* JProfiler is extensible. It is built on a well-documented platform that allows you to build your own custom profiler for special situations or your own analysis tool for snapshots. With the interceptor API you can add additional semantic layers to the profiling data, similar to the built-in JDBC, JMS and JNDI profiling. The ready-to-run examples show you how easy it is to extend JProfiler with a few lines of code. *Here are some key features of "JProfiler":* ................................................ *Live profiling of a local session:* Once you define how your application is started, JProfiler can profile it and you immediately see live data from the profiled JVM. To eliminate the need for session configuration, you can use one of the many IDE plugins to profile the application from within your favorite IDE. *Live profiling of a remote session:* By modifying the VM parameters of the java start command you can get any Java application to listen for a connection from the JProfiler GUI. The profiled application can not only run on your local computer, JProfiler can attach to a profiled application over the network. In addition, JProfiler provides numerous integration wizards for all popular application servers that help you in setting up your application for profiling. *Offline profiling:* You do not have to connect with the JProfiler GUI to the profiled application in order to profile it: With offline profiling you can use JProfiler's powerful trigger system or the JProfiler API to control the profiling agent and save snapshots to disk. At a later time you can open these snapshots in the JProfiler GUI or programmatically export profiling views with the command line export tool or the export ant task. *Snapshot comparisons:* In JProfiler, you can save a snapshot of all current profiling data to disk. JProfiler offers a rich comparison facility to see what has changed between two or more snapshots. Alternatively you can create comparison reports programmatically with the command line comparison tool or the comparison ant task.

*Viewing an HPROF snapshot:* JProfiler can open HPROF snapshots that have been taken with JVM tools such as jconsole or jmap or that have been triggerd by the -XX:+HeapDumpOnOutOfMemoryError JVM parameter. *Memory profiling:* JProfiler's memory view section offers dynamically updated views on memory usage and views that show information about allocations spots. All views have several aggregation levels and can show live and garbage collected objects. *All objects:* Shows classes or packages of all objects on the heap with instance counts and size information. You can mark current values and show differences. *Recorded objects:* Shows classes or packages of all recorded objects. You can mark current values and show differences. *Allocation call tree:* Shows a call tree or methods, classes, packages or Java EE components with annotated allocations of selected classes. *Allocation hot spots:* Shows a list of methods, classes, packages or Java EE components that allocate selected classes. You can mark current values and show differences. The tree of backtraces can be shown for each hot spot. *Class tracker:* Shows a timeline with a graph of instance counts for selected classes. *Heap walker:* *Classes:* Shows all classes and their instances. Allocations" Shows allocation tree and allocation hot spots for recorded objects. *Biggest objects:* Shows the objects that block the largest parts of the heap from being garbage collected. The dominator tree can be expanded in place to show

these retained objects. *References:* Shows a graph of references for individual objects and offers a "show path to garbage collector root" functionality. Also offers cumulated views for incoming and outgoing references. *Data:* Shows instance and class data for individual objects. *Time:* Shows a time-resolved histogram of recorded objects. *CPU profiling:* *Call tree:* Shows a cumulated top-down tree of all recorded call sequences in the JVM. JDBC, JMS and JNDI service calls are annotated into the call tree. The call tree can be split for different request URL to a servlet or JSP. You can mark methods for "exceptional method run recording" and see the slowest invocations separatly. *Hot spots:* Shows the list of the most time consuming methods. The tree of backtraces can be shown for each hot spot. Hotspots can be calculated for method calls, JDBC, JMS and JNDI service calls, as well as for URL invocations. *Call graph:* Shows a graph of call sequences starting from selected methods, classes, packages or Java EE components. *Method statistics:* Shows statistical information about the distribution of call times for all methods together with a call time distribution graph, that can be used to spot outliers. *Call tracer:* Shows recorded chronological traces for method calls grouped by thread, package and class. *Thread profiling:* *Thread history:* Shows a timeline with thread activity and thread status. *Thread monitor:* Shows a list of all live threads with their current activity.

*Thread dumps:* You can take multiple threads dumps and analyze them in the thread dumps view. *Monitor profiling:* *Current locking graph:* Shows a graph of all waiting and blocking situations in the JVM. *Current monitors:* Shows the currently used monitors and their associated threads. *Locking history graph:* Shows the history of recorded waiting and blocking situations as graphs. *Monitor history:* Shows the history of recorded waiting and blocking events. *Monitor usage statistics:* Shows statistics for monitors grouped by monitors, threads and classes of monitors. *VM telemetry:* *Heap:* Shows a timeline with a graph of the used heap and the heap size. *Recorded objects:* Shows a timeline with a graph of live objects and arrays that have been recorded. *Recorded throughput:* Shows a timeline with a graph of the rates of object creation and garbage collection for recorded objects. *GC activity:* Shows a timeline with a graph of garbage collector activity. *Classes:* Shows a timeline with a graph of loaded classes. *Threads:* Shows a timeline with a graph of active threads. *CPU load:*

 Shows a timeline with a graph of the CPU load generated by the profiled application.