Java Performance Optimization and Profiling Techniques

Use performance analysis tools to locate bottlenecks, use VisualVM or JProfiler in the development and testing stage, and give priority to Async-Profiler in the production environment; 2. Reduce object creation, reuse objects, use StringBuilder to replace string splicing, and select appropriate GC strategies; 3. Optimize collection usage, select and preset initial capacity according to the scene; 4. Optimize concurrency, use concurrent collections, reduce lock granularity, and set thread pool reasonably; 5. Tune JVM parameters, set reasonable heap size and low-latency garbage collector and enable GC logs; 6. Avoid reflection at the code level, replace wrapper classes with basic types, delay initialization, and use final and static; 7. Continuous performance testing and monitoring, combined with JMH microbenchmark testing and APM tools, regularly analyze logs and dump files; Java performance optimization needs to be measured first and then optimized, and the tools and methods are correct to effectively improve system performance.

Java performance optimization and performance analysis are key links to improve application response speed, reduce resource consumption, and ensure system stability. Especially in scenarios with high concurrency and large data volume, reasonable optimization strategies can significantly improve system performance. The following are several core Java performance optimization directions and commonly used performance analysis technologies.

1. Positioning performance bottlenecks: Use performance analysis tools (Profiling Tools)

Before optimizing, bottlenecks must be positioned first. Blind optimization often results in half with twice the effort. Commonly used Java performance analysis tools include:

• JVisualVM / VisualVM
  Free, lightweight, integrated in JDK. It can monitor CPU and memory usage, perform thread analysis and heap dump analysis, which is suitable for preliminary investigation.

  

• JProfiler
  Commercial tools, powerful functions, support CPU sampling, memory analysis, thread deadlock detection, I/O monitoring, etc., and have a friendly graphical interface.

• YourKit
  Another commercial performance analyzer supports remote monitoring and method-level performance tracking, suitable for production environment sampling.

  

• Async-Profiler
  Open source, low-overhead Linux performance analysis tool, based on sampling, supports CPU, memory allocation, and lock competition analysis, which is especially suitable for use in production environments.

Recommendation: Use VisualVM or JProfiler in the development and testing phases; prioritize Async-Profiler in the production environment to avoid excessive burden on the system.

2. Key optimization directions

(1) Reduce object creation and GC pressure

Frequent object creation increases the burden of garbage collection (GC), resulting in increased pause times.

Optimization suggestions:

• Use object pools (such as ThreadLocal cache, custom pool) to reuse objects (suitable for objects with short life cycles and frequent creation).
• Avoid creating temporary objects in loops.
• Use StringBuilder instead of string stitching (especially in loops).
• Select the appropriate GC strategy (such as G1, ZGC, Shenandoah) to reduce pause time.

 // Avoid writing String result = "";
for (String s: list) {
    result = s; // Create a new String object every time}

// Change to StringBuilder sb = new StringBuilder();
for (String s: list) {
    sb.append(s);
}

(2) Optimize collection usage

Collections are the most commonly used structure in Java, and improper use can cause performance problems.

suggestion:

• Choose the appropriate collection type according to the scene:
  • ArrayList is suitable for random access, LinkedList is only used when intervening/deleting intermediate elements frequently.
  • HashMap looks fast, but pay attention to the initial capacity and load factor to avoid frequent capacity expansion.
• Preset the initial capacity of the set to reduce the overhead of dynamic expansion:

   List<String> list = new ArrayList<>(1000);
  Map<String, Integer> map = new HashMap<>(512);

(3) Concurrency and thread optimization

In multi-threaded programming, lock competition and context switching are common performance killers.

Optimization suggestions:

• Use concurrent collections (such as ConcurrentHashMap , CopyOnWriteArrayList ) instead of synchronous wrapper classes.
• Reduce lock granularity and avoid time-consuming operations (such as I/O) within the lock.
• Consider using lock-free structures (such as AtomicInteger , LongAdder ).
• Set the thread pool size reasonably to avoid the overhead of context switching caused by too many threads:

   // CPU-intensive: Number of threads ≈ number of CPU cores // I/O-intensive: The number of threads can be appropriately increased ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

(4) JVM parameter tuning

Reasonable JVM parameter settings are crucial to performance.

Key parameter suggestions:

• Heap size: -Xms and -Xmx are set to the same value to avoid dynamic expansion.
• Choose the right garbage collector:
  • G1GC: Suitable for large piles (above 4G), pursuing low latency.
  • ZGC/Shenandoah: Ultra-low pause (<10ms), suitable for delay-sensitive applications (JDK 11/12).
• Enable GC logs for easy analysis:

   -Xlog:gc*,gc heap=debug,gc compaction=info:file=gc.log:time,tags

  ---

  3. Code-level performance skills

  • Avoid overuse of reflection
    Low reflection performance and difficult to optimize. If necessary, you can cache Method object or use MethodHandle .

  • Use basic types to replace packaging classes
    Using int in collections is better than Integer and can be supported via IntStream or third-party libraries such as fastutil .

  • Delay initialization and lazy loading
    For large objects or time-consuming operations, use Supplier or double check locks to achieve lazy loading.

  • Optimization using final and static
    JVM has better inline optimization opportunities for final fields and static methods.

  ---

  4. Performance testing and monitoring

  Optimization is not one-time and requires continuous monitoring and verification.

  • Use JMH (Java Microbenchmark Harness) to perform microbenchmark testing to avoid incorrect performance measurements.
  • Integrate APM tools (such as SkyWalking, Pinpoint, New Relic) for real-time monitoring in production environments.
  • Regularly analyze GC logs, thread dumps, and heap dumps.

  ---

  Basically that's it. Java performance optimization is not "magic", but "science": measure first, then optimize; bottleneck first, then details . If the tool is used correctly, the direction is half right.

  The above is the detailed content of Java Performance Optimization and Profiling Techniques. For more information, please follow other related articles on the PHP Chinese website!