JVM uygulama performansını nasıl optimize edersiniz?

Question

IT Interview Practice · Accepted Answer

JVM uygulamalarını optimize etmek **profiling** ile darboğazları bulma, **JVM/GC tuning**, **kod seviyesi** iyileştirmeler ve JIT compiler'ı kullanmayı kapsar. Her zaman olduğu gibi, kural şudur: **önce ölç, kanıtlanmış darboğazı optimize et** — asla tahmin etme.

## Optimize etmeden önce profil oluşturun

```text
Tools:
  ✓ JProfiler / YourKit / VisualVM — CPU & memory profiling, hotspots
  ✓ Java Flight Recorder (JFR) + Mission Control — low-overhead production profiling
  ✓ async-profiler — flame graphs for CPU/allocation
  ✓ heap dumps + Eclipse MAT — memory leak analysis
```

Profiling, zamanın ve belleğin *nereye* gittiğini ortaya çıkarır, böylece gerçekten önemli olan %20'yi optimize edersiniz, alakasız kodda mikro-optimizasyon yapmak yerine.

## JIT compiler sizin için çalışır

```text
The JVM's JIT (Just-In-Time) compiler identifies "hot" frequently-run code and
compiles it to optimized native machine code at runtime (with inlining, etc.).
→ Java often approaches native speed for hot paths after warm-up.
→ Implication: benchmark AFTER warm-up; let the JIT optimize before measuring.
```

## GC tuning

```bash
# choose a collector appropriate to the workload, size the heap
java -Xms2g -Xmx2g \          # set heap size (avoid resizing; -Xms = -Xmx)
     -XX:+UseG1GC \           # G1 (balanced, default) — or ZGC for low pause
     -XX:MaxGCPauseMillis=200 \
MyApp
```

```text
✓ Right-size the heap (too small → frequent GC; too large → long pauses)
✓ Pick the GC for your goal: G1 (balanced), Parallel (throughput), ZGC (low latency)
✓ Reduce allocation churn — fewer short-lived objects = less GC pressure
```

## Kod seviyesi optimizasyonları

```text
✓ Better algorithms & data structures — biggest wins (HashMap O(1) vs list O(n))
✓ Avoid unnecessary object creation (esp. in loops; reuse, use primitives over wrappers)
✓ Use StringBuilder for string building in loops (not + concatenation)
✓ Minimize autoboxing (Integer vs int) in hot paths
✓ Cache expensive results; use connection/thread pools
✓ Lazy initialization for costly objects not always needed
✓ Reduce I/O round-trips; batch database queries (avoid N+1)
```

## Veritabanı genellikle gerçek darboğazdır

```text
For server apps, the slow part is frequently DB queries (N+1, missing indexes) or
network I/O — NOT Java code. Profiling reveals this so you fix the true cause.
```

## Erken optimizasyondan kaçının

```text
"Premature optimization is the root of all evil." Write clear, correct code first;
profile under realistic load; then optimize the measured hotspots specifically.
```

## Neden önemli

JVM performans optimizasyonu yüksek değerli ancak **disiplinli ve ölçüm odaklı** olmalıdır — tahmin etmek çabayı boşa harcaması ve karmaşıklık ekler.

Tam araç setini bilmek önemlidir: profiler'lar (JFR, async-profiler) gerçek darboğazları konumlandırmak için; JIT'i anlamak (çalışma zamanında sıcak kodu optimize eder, bu nedenle benchmark'lar ısınma gerektirir); GC tuning (heap boyutlandırması ve collector seçimi — G1/ZGC — iş hacmi ve duraklatma sürelerini dengelemek için); ve kod seviyesi kazanç (daha iyi algoritmalar/veri yapıları, tahsis ve autoboxing'i azaltma, pooling, batching).

Darboğazın genellikle Java kodu değil, **veritabanı veya I/O** olduğunu tanımak çabayı doğru şekilde yönlendirir.

Bu kombinasyon — önce profil oluştur, JVM ve GC'yi uygun şekilde tune et, kanıtlanmış hotspot'ları optimize et ve erken mikro-optimizasyondan kaçın — büyük JVM uygulamalarını hızlı ve ölçeklenebilir tutarken, üst düzey operasyonel uzmanlığı yansıtır.

Optimize etmeden önce profil oluşturun

JIT compiler sizin için çalışır

GC tuning

Kod seviyesi optimizasyonları

Veritabanı genellikle gerçek darboğazdır

Erken optimizasyondan kaçının

Neden önemli

İlgili sorular