JVM Performance Tuning

  1. JVM Architecture Fundamentals
    1. JVM Overview
      1. JVM Specification vs. Implementation
        1. JVM Lifecycle
          1. JVM Startup Process
            1. Runtime Phases
              1. JVM Shutdown
            2. Key Components of the JVM
              1. Classloader Subsystem
                1. Bootstrap Classloader
                  1. Platform Classloader
                    1. System Classloader
                      1. Custom Classloaders
                        1. Class Loading Process
                          1. Loading Phase
                            1. Linking Phase
                              1. Initialization Phase
                              2. Classloader Hierarchy
                                1. Parent Delegation Model
                                2. Runtime Data Areas
                                  1. Heap Memory
                                    1. Non-Heap Memory
                                      1. JVM Stacks
                                        1. Program Counter Registers
                                          1. Native Method Stacks
                                            1. Method Area
                                            2. Execution Engine
                                              1. Bytecode Interpreter
                                                1. Just-In-Time Compiler
                                                  1. Garbage Collector
                                                    1. Native Method Interface
                                                  2. Runtime Data Areas Deep Dive
                                                    1. The Heap
                                                      1. Heap Structure
                                                        1. Object Allocation
                                                          1. Heap Generations
                                                            1. Garbage Collection Regions
                                                            2. JVM Stacks
                                                              1. Stack Frames
                                                                1. Local Variable Array
                                                                  1. Operand Stack
                                                                    1. Frame Data
                                                                    2. Stack Overflow Conditions
                                                                      1. Thread-specific Stacks
                                                                      2. Method Area
                                                                        1. Class Metadata Storage
                                                                          1. Runtime Constant Pool
                                                                            1. Static Variables
                                                                              1. Method Bytecode
                                                                              2. Program Counter Registers
                                                                                1. Thread-specific Program Counters
                                                                                  1. Instruction Pointer Management
                                                                                  2. Native Method Stacks
                                                                                    1. Native Code Execution
                                                                                      1. JNI Integration
                                                                                    2. Execution Engine Components
                                                                                      1. Interpreter
                                                                                        1. Bytecode Execution
                                                                                          1. Interpretation Overhead
                                                                                            1. Performance Characteristics
                                                                                            2. Just-In-Time Compiler
                                                                                              1. Compilation Triggers
                                                                                                1. Optimization Levels
                                                                                                  1. Code Cache Management
                                                                                                  2. Garbage Collector
                                                                                                    1. GC Algorithms
                                                                                                      1. GC Threads
                                                                                                        1. GC Phases and Cycles

                                                                                                    Previous

                                                                                                    1. Introduction to JVM Performance

                                                                                                    Go to top

                                                                                                    Next

                                                                                                    3. Memory Management and Tuning