420

Java Performance Optimizations

  1. Introduction
  • Your Own Performance Challenges…
  • Measure Don’t Guess
  • Core Concepts: Responsivity, Throughput, Load, Work Load, Utilization
  • Gowing Slower to go Faster: discharge the bottleneck
  • Time Budgeting
  • Stress Tests: Types2. Concurrency Patterns
  • This module explains the core Java Concurrency principles, with special emphasis on the most useful topics in day-to-day practice: the monitor object, wait()/notify() primitives and the Thread Pool Executor. The included hands-on lab will exercise these concepts and classes.
  • Basic Concepts
    • Deadlock, Live Lock, Race
    • Atomicity
    • Thread Safety
    • Cancelling an execution
  • Patterns in JDK
    • Lock
    • Semaphore
    • Latches
    • Barrier
    • Readers-Writers Lock
  • Monitor: synchronized, wait(), notify()
  • Thread Pools, Executors
  • Thread Local Storage
  • Best practices & Pitfalls3. Just-In-Time Compiler
  • Interpreted vs Compiled Code
  • Hot Spot Compiler
  • Optimizations: Static vs Dynamic
  • Example: Dynamic Optimizations with Escape Analysis
  • JIT Compiler: Levels, Monitoring
  • Code Cache
  • General Coding Advices4. Garbage Collector
  • GC Principles: Generations, Heap Fragmentation, ..
  • GC Algorithms
    • Serial Collector
    • Parallel/Throughput Collector
    • CMS Collector
    • G1 Collector
  • Choosing a GC: general guidelines
  • System.gc
  • Sizing for Heap, Generations, PermGen/Metaspace
  • Monitoring GC: jvm GC log output, jconsole, jstat, jVisualVM, HPJMeter
  • Tuning GC: Throughput, CMS
  • Thread Local Allocation Buffers5. Finding Memory Leaks
  • OutOfMemoryError: Causes
  • Out of Heap: possible leak sources
  • GC Roots
  • Investigating Leak using Tools: a full example
    • Visualize the Leak (jvisualVm, hpjmeter)
    • Heap Dump Analysis(jvisualvm, Eclipse MAT): largest set of instances for a class, path to nearest GC Root
    • Memory Profiling (jvisualVm): How many objects were just created, how many generations, by who?
  • GC Recap Quiz6. Tips for Performance Coding
  • This module gives general advice on how to write high-performance code in Java. Throughout the contents, I will often ask the attendees how would THEY implement a certain functionality already available in JVM (example: String.intern()). That’s why this module is more a brainstorm than a classic training, and motivated practitioners would make it a very-very-very interesting session. The discussions may easily divagate to general algorithms and macro-design decisions.
  • Intro: Performance in Java Enterprise App
  • Effective Memory Usage
    • Lazy Init, Eager Deinit
    • Canonicalization, String.intern()
    • Object Pools: WHY ?
    • Thread Locals
    • Weak, Soft References + Practice
  • Effective Multi-Threading
    • Amdhal’s Law
    • Synchronization Cost
    • CPU Register Flushing
    • How to Avoid Synchronization
  • Thread Pools
    • Executor Types
    • Sizing the Queue
    • Sizing the Thread Pool
    • Fork-Join-Pool (1 word)
  • Database
    • JDBC
    • JPA (+Discussions….)

Aplica pentru acest curs

Te rugam sa completezi formularul pentru a rezerva un loc la acest curs:

Invalid Input
Invalid Input
Invalid Input
Invalid Input
Invalid Input
Invalid Input
Invalid Input
Invalid Input