- System requirements
- Profiler architecture
- Profiler installation
- Uninstall profiler
- Running the profiler
- Profiler activation
- Welcome screen
- Start profiling
- Profiling overhead
- Snapshots
- Solving performance problems
- CPU profiling
- Thread profiling
- Virtual threads support
- Object allocation profiling
- Memory profiling
- Monitor profiling
- Exception profiling
- Telemetry
- Probes: monitor events of various kinds
- Inspections: automatic recognition of typical problems
- Automatically trigger actions on event
- Automatic deobfuscation
- Summary
- Filters
- Profiler command line
- Export of profiling results to external formats
- Profiler Java API
- Profiler HTTP API
- Settings
- Troubleshooting and FAQ
Group objects by class loader
When analyzing Java memory snapshots, it's often useful to understand the distribution of objects in the heap. One valuable approach is to group objects by their class loaders. Class loaders are responsible for loading classes into the Java Virtual Machine (JVM), and different parts of an application may use different class loaders. Understanding the distribution of objects per class loader can offer insights into various issues such as memory leaks, class loading problems, or performance bottlenecks.
Paths from GC roots to the loader object are explicitly available as a dependent Paths from GC Roots view. This allows you to learn why particular class loader is retained in memory.
Why analyzing class loaders is useful
1. Isolate memory leaks: Knowing which class loader is responsible for an unusually high number of object instances can help isolate the source of memory leaks.
2. Plugin or module analysis: In modular systems or applications that support plugins, each plugin or module may have its own class loader. Grouping by class loader helps in assessing the memory footprint of each module.
3. Isolate third-party libraries: Java applications often use multiple third-party libraries, each loaded by their own class loader or shared ones. Grouping by class loaders can isolate the classes from each library, allowing you to understand the memory consumption of each library separately.
4. Understand class versioning: In some complex systems where multiple versions of a class may exist, understanding which class loader loaded which version of class can help troubleshoot issues related to class version conflicts.