BestHub
Sign in
Tagged articles
1031 articles
Page 9 of 11
21CTO
21CTO
Apr 12, 2020 · Backend Development

What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips

The author, a 985‑master’s graduate, shares a detailed chronicle of her preparation and interview experiences across dozens of Chinese tech giants, listing the technical questions asked—ranging from Java fundamentals, JVM internals, concurrency, data structures, design patterns, to system design—and offering practical advice for future candidates.

AlgorithmsJVMbackend
0 likes · 11 min read
What I Learned from 20+ Java Backend Interviews: Questions, Answers, and Tips
Java Captain
Java Captain
Apr 3, 2020 · Backend Development

SpringBoot Project Optimization: Configuration Files and JVM Tuning

This article explains how to optimize a SpringBoot application by adjusting Tomcat settings in the application.properties file, tuning JVM parameters with examples, and demonstrates two practical methods—IDE configuration and command‑line scripts—to improve performance and resource usage.

JVMJavaPerformance
0 likes · 6 min read
SpringBoot Project Optimization: Configuration Files and JVM Tuning
FunTester
FunTester
Apr 3, 2020 · Fundamentals

JVM Memory Model, GC Log Analysis, and Production Parameter Optimization

This article examines production JVM memory architecture, explains GC log generation and analysis, details the ParNew + CMS collector behavior, and provides practical parameter tuning recommendations to optimize heap size, young generation, and garbage collection for stable Java applications in production environments.

Garbage CollectionJVMJava
0 likes · 10 min read
JVM Memory Model, GC Log Analysis, and Production Parameter Optimization
Top Architect
Top Architect
Apr 1, 2020 · Backend Development

How to Prepare for Java Junior and Senior Technical Interviews

Preparing thoroughly for Java junior and senior technical interviews requires covering core Java concepts, Spring and Spring Boot frameworks, database fundamentals, multithreading, JVM internals, and architectural knowledge, while practicing problem‑solving and understanding interviewers' expectations to increase success chances.

InterviewJVMJava
0 likes · 10 min read
How to Prepare for Java Junior and Senior Technical Interviews
FunTester
FunTester
Apr 1, 2020 · Backend Development

Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips

Learn how to optimize Java applications by configuring six critical JVM parameters—including heap size, Metaspace limits, GC algorithm selection, logging, heap dumps, thread stack size, and network timeouts—while understanding their impact on performance, memory usage, and troubleshooting common out‑of‑memory issues.

Garbage CollectionHeap DumpJVM
0 likes · 9 min read
Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips
Architect's Tech Stack
Architect's Tech Stack
Mar 31, 2020 · Backend Development

Investigation of Excessive Native Memory Usage in a Spring Boot Application

This article details a step‑by‑step investigation of unusually high native memory consumption in a Spring Boot service, covering JVM configuration, system‑level diagnostics with jcmd, pmap, gperftools, strace, GDB, and jstack, and explains how the MCC component’s default package scanning caused the leak and how configuring scan paths or upgrading Spring Boot resolved the issue.

JVMLinux toolsMemory Leak
0 likes · 11 min read
Investigation of Excessive Native Memory Usage in a Spring Boot Application
JavaEdge
JavaEdge
Mar 31, 2020 · Fundamentals

How to Pick the Best Java HotSpot GC: Serial, Parallel, CMS, G1 & ZGC

This guide compares the major HotSpot JVM garbage collectors—including Serial, ParNew, Parallel Scavenge, Parallel Old, CMS, G1, and ZGC—explaining their algorithms, threading models, typical use cases, key JVM flags, performance trade‑offs, and how to select the most suitable collector for different application workloads.

Garbage CollectionHotSpotJVM
0 likes · 14 min read
How to Pick the Best Java HotSpot GC: Serial, Parallel, CMS, G1 & ZGC
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2020 · Backend Development

Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results

This article explains the three forms of using the synchronized keyword in Java—method, static method, and block synchronization—demonstrates each with runnable code examples, analyzes the JVM monitorenter/monitorexit instructions, and clarifies why synchronized methods and blocks enforce mutual exclusion and visibility guarantees.

JVMJavaMonitor
0 likes · 13 min read
Understanding Java Synchronized: Basic Usage, Underlying Mechanism, and Execution Results
Java Captain
Java Captain
Mar 27, 2020 · Fundamentals

Comprehensive Overview of Java JVM Runtime Data Areas, Memory Model, Garbage Collection, and Class Loading

This article provides a detailed explanation of the Java Virtual Machine's runtime memory regions, the Java Memory Model, garbage collection mechanisms, heap layout, HotSpot VM internals, class loading process, and performance tuning parameters, offering a solid foundation for Java developers and architects.

Garbage CollectionJVMJava
0 likes · 29 min read
Comprehensive Overview of Java JVM Runtime Data Areas, Memory Model, Garbage Collection, and Class Loading
Programmer DD
Programmer DD
Mar 23, 2020 · Backend Development

How Does OpenJDK 14 Stack Up Against Java 8? Benchmark Results Revealed

This article presents a comprehensive performance comparison of OpenJDK 14 with OpenJDK 8 and other major releases, using Phoronix benchmarks across workloads such as SPECjbb, Java 2D, SciMark, DaCapo, Jython, Daytrader, Renaissance, and HBase, and draws conclusions about overall speed trends.

JVMJava 14Java performance
0 likes · 7 min read
How Does OpenJDK 14 Stack Up Against Java 8? Benchmark Results Revealed
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 16, 2020 · Backend Development

Mastering Java Backend Interview Questions: Concurrency, JVM, Spring, and Distributed Systems

This article compiles typical Java backend interview questions and detailed answers covering self‑introduction, personal growth, concurrency primitives, JVM memory management, GC tuning, cache design, large‑scale data storage, Spring IoC, AOP, distributed session handling, and common design patterns.

Backend DevelopmentInterviewJVM
0 likes · 18 min read
Mastering Java Backend Interview Questions: Concurrency, JVM, Spring, and Distributed Systems
FunTester
FunTester
Mar 10, 2020 · Backend Development

Understanding JVM Hotspot Compilation and Performance Gains in Java

The article explains how the JVM selectively compiles frequently executed Java code into optimized native code, demonstrates significant performance improvements through JIT compilation with two demo programs, and highlights the trade‑offs between interpretation and compilation for hotspot methods.

HotSpotJITJVM
0 likes · 5 min read
Understanding JVM Hotspot Compilation and Performance Gains in Java
Big Data Technology Architecture
Big Data Technology Architecture
Mar 4, 2020 · Databases

HBase Memory‑Related Performance Tuning Guide

This article explains how to optimize HBase performance by properly configuring JVM memory, selecting suitable garbage‑collection strategies, enabling MSLAB and BucketCache, and adjusting read/write cache ratios to reduce fragmentation and improve throughput.

CacheGarbage CollectionHBase
0 likes · 8 min read
HBase Memory‑Related Performance Tuning Guide
macrozheng
macrozheng
Mar 3, 2020 · Fundamentals

Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips

This article provides a comprehensive overview of Java's automatic garbage collection, covering memory regions, identification methods, core algorithms such as mark‑sweep, copying, and generational collection, detailed explanations of various collectors (Serial, CMS, G1, etc.), and practical tuning insights for optimal performance.

Garbage CollectionJVMJava
0 likes · 31 min read
Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips
Programmer DD
Programmer DD
Feb 8, 2020 · Backend Development

Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors

This guide explains the most important JVM parameters—such as -Xms, -Xmx, -Xss, and various -XX options—detailing how each setting influences heap, stack, and generation sizes and how proper configuration can avoid common OutOfMemoryError scenarios in Java applications.

JVMJavaMemory Management
0 likes · 3 min read
Master Java Memory: Essential JVM Flags to Prevent OutOfMemory Errors
Tencent Cloud Developer
Tencent Cloud Developer
Jan 19, 2020 · Backend Development

Tencent Kona JDK: OpenJDK Foundations, Technical Trends, and Big Data Practices

The talk reviews OpenJDK’s evolution, contrasts Oracle JDK, introduces Tencent’s Kona JDK as a free, long‑term, production‑hardened fork optimized for massive micro‑service and big‑data workloads, and discusses emerging Java‑on‑Java, value‑type, Project Panama/Loom, and SIMD Vector API trends shaping JVM performance.

Big DataCloud ComputingJVM
0 likes · 15 min read
Tencent Kona JDK: OpenJDK Foundations, Technical Trends, and Big Data Practices
Architect's Tech Stack
Architect's Tech Stack
Jan 18, 2020 · Fundamentals

JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More

This article provides a comprehensive overview of the Java Virtual Machine memory layout, covering heap regions, Metaspace, stack frames, native method stack, program counter, direct memory, and code cache, along with configuration tips, diagnostic commands, and illustrative code examples to help readers understand memory allocation and garbage collection.

Garbage CollectionHeapJVM
0 likes · 16 min read
JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More
vivo Internet Technology
vivo Internet Technology
Jan 8, 2020 · Fundamentals

Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading

The article demonstrates that Kotlin coroutines on the JVM are merely a convenient API layered on traditional Java threads rather than true lightweight coroutines, contrasting them with Go’s M:N goroutine scheduling, and discusses experimental Kotlin‑Native and OpenJDK Loom projects that aim to provide genuine coroutine support.

CoroutinesGoJVM
0 likes · 20 min read
Understanding Kotlin Coroutines, Go Coroutines, and JVM Threading
JD Retail Technology
JD Retail Technology
Jan 7, 2020 · Backend Development

Performance Optimization Practices for the Tongtian Tower Backend System

This article summarizes the Tongtian Tower backend performance optimization experience, detailing background, achieved improvements of 10‑30%, optimization principles, testing methods, metric analysis, and concrete strategies such as RPC scheduling, JVM tuning, logging, thread‑pool and code refinements to enhance latency and throughput.

JVMPerformance OptimizationRPC scheduling
0 likes · 12 min read
Performance Optimization Practices for the Tongtian Tower Backend System
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Dec 20, 2019 · Backend Development

Why Java and Python Behave Differently on Armv8 and How to Optimize JVM Performance

This article compares Java and Python on Armv8 platforms, explaining why both compile to machine code and rely on virtual machines, detailing JVM feature support across architectures, and offering configuration tips to prevent CodeCache overflow and improve performance, while also noting Python's compatibility on Kunpeng servers.

CodeCacheJVMJava
0 likes · 6 min read
Why Java and Python Behave Differently on Armv8 and How to Optimize JVM Performance
HomeTech
HomeTech
Dec 20, 2019 · Cloud Native

Practical Experience of Containerizing Java Applications: Docker, JVM Tuning, Multi‑Stage Builds, and Operational Tips

This article shares the 2019 cloud‑native migration experience of an e‑commerce team, covering Docker and Kubernetes basics, Java‑Docker compatibility, memory and CPU limits, log collection, JDK version choices, Dockerfile and multi‑stage build practices, health checks, graceful shutdown, and common pitfalls encountered during containerization.

ContainerizationDockerJVM
0 likes · 21 min read
Practical Experience of Containerizing Java Applications: Docker, JVM Tuning, Multi‑Stage Builds, and Operational Tips
360 Tech Engineering
360 Tech Engineering
Dec 17, 2019 · Backend Development

Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring, and Code Fixes

This article explains how Java memory leaks can occur despite automatic garbage collection, describes JVM GC‑Root analysis, outlines practical monitoring with Spring Boot Actuator, Prometheus, and Grafana, and provides step‑by‑step debugging commands and code adjustments to locate and fix the leak.

Garbage CollectionJVMJava
0 likes · 10 min read
Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring, and Code Fixes
Huajiao Technology
Huajiao Technology
Dec 17, 2019 · Backend Development

Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring with Spring Boot Actuator, Prometheus, Grafana, and MAT

This article explains how Java memory leaks can occur despite automatic garbage collection, describes JVM reachability analysis, shows how to monitor and detect leaks using Spring Boot Actuator, Prometheus, and Grafana, and provides step‑by‑step instructions for heap dump analysis and code fixes.

Garbage CollectionGrafanaJVM
0 likes · 11 min read
Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring with Spring Boot Actuator, Prometheus, Grafana, and MAT
Architect's Tech Stack
Architect's Tech Stack
Dec 13, 2019 · Backend Development

Comprehensive Java Interview Guide and Preparation Checklist

This article provides a detailed Java interview preparation guide, covering personal experience, overall interview process, essential knowledge areas such as core Java, data structures, algorithms, JVM, multithreading, databases, networking, design patterns, distributed systems, caching, frameworks, emerging technologies, and practical tips for success.

Design PatternsInterviewJVM
0 likes · 9 min read
Comprehensive Java Interview Guide and Preparation Checklist
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 11, 2019 · Backend Development

How Alibaba’s ElasticHeap, Wisp2, and ZGC Transform Java Performance for Cloud‑Native Apps

This article explains how Alibaba’s JVM team introduced ElasticHeap, static compilation, Wisp2 coroutines, feedback‑directed optimization, and ZGC to dramatically reduce Java heap usage, startup time, CPU load, and pause times, delivering cloud‑native performance improvements demonstrated during the Double‑11 traffic peak.

ElasticHeapJVMJava
0 likes · 11 min read
How Alibaba’s ElasticHeap, Wisp2, and ZGC Transform Java Performance for Cloud‑Native Apps
Selected Java Interview Questions
Selected Java Interview Questions
Nov 29, 2019 · Fundamentals

Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis

The article explains how Java determines whether an object is alive using two main garbage‑collection algorithms—Reference Counting and Reachability Analysis—detailing their mechanisms, limitations such as circular references, the role of GC Roots, finalization, and method‑area reclamation, with illustrative code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis
Big Data Technology Architecture
Big Data Technology Architecture
Nov 19, 2019 · Backend Development

CMS GC JVM Parameter Tuning Guide for HBase Clusters

This article explains the fundamentals of the CMS (Concurrent Mark Sweep) garbage collector, presents a comprehensive set of JVM parameters optimized for HBase clusters, and provides detailed analysis of key settings to improve performance and reduce GC pauses.

CMS GCGarbage CollectionHBase
0 likes · 7 min read
CMS GC JVM Parameter Tuning Guide for HBase Clusters
Big Data Technology & Architecture
Big Data Technology & Architecture
Nov 18, 2019 · Big Data

Understanding JVM Garbage Collection and Flink Memory Management

This article explains the fundamentals of JVM garbage collection, its generational algorithms and associated performance issues, and then details Apache Flink's memory management architecture, including MemorySegment, off‑heap buffers, serialization mechanisms, and type information for efficient big‑data processing.

Big DataFlinkGarbage Collection
0 likes · 7 min read
Understanding JVM Garbage Collection and Flink Memory Management
FunTester
FunTester
Nov 16, 2019 · Backend Development

Using Groovy and Gradle for Configuration Synchronization and Database Integration

This article explains how Groovy, combined with Gradle, can serve as a native application server to synchronize environment‑specific property files with a MySQL registry, demonstrating practical build‑script configuration, file‑system traversal, and Groovy‑SQL database operations for robust CI/CD workflows.

Build AutomationConfiguration ManagementGradle
0 likes · 9 min read
Using Groovy and Gradle for Configuration Synchronization and Database Integration
Senior Brother's Insights
Senior Brother's Insights
Nov 12, 2019 · Fundamentals

What Really Happens When Java Loads a Class and Creates an Object?

When Java executes a new expression, the JVM first ensures the class is loaded using the parent‑delegation model, then follows a five‑step loading and linking process before allocating heap memory, initializing fields, running static and instance code, and finally returning a reference to the new object.

InitializationJVMJava
0 likes · 8 min read
What Really Happens When Java Loads a Class and Creates an Object?
Senior Brother's Insights
Senior Brother's Insights
Nov 10, 2019 · Backend Development

Master JVM Performance: Using jps, jstack, jmap, jstat & hprof

This guide introduces essential JVM performance monitoring tools—including jps, jstack, jmap, jhat, jstat, and hprof—explains their command syntax, demonstrates step‑by‑step usage with real‑world examples, and shows how to interpret their output to diagnose memory leaks, thread issues, GC behavior, and CPU hotspots.

HprofJVMjmap
0 likes · 14 min read
Master JVM Performance: Using jps, jstack, jmap, jstat & hprof
Architecture Digest
Architecture Digest
Nov 7, 2019 · Fundamentals

How the JVM Determines Object Liveness and Its Garbage Collection Algorithms

This article explains the JVM memory model, how the JVM decides whether an object is alive using reference counting and reachability analysis, and describes the main garbage‑collection algorithms—including mark‑sweep, mark‑compact, copying, and generational collection—along with their advantages and drawbacks.

Garbage CollectionGenerational GCJVM
0 likes · 8 min read
How the JVM Determines Object Liveness and Its Garbage Collection Algorithms
Java Captain
Java Captain
Nov 4, 2019 · Backend Development

Spring Boot Project and JVM Tuning Guide

This article explains how to optimize Spring Boot applications by adjusting configuration properties and JVM parameters, provides essential Tomcat settings, demonstrates practical tuning steps with and without IDE support, and details the meaning of common JVM flags for improved performance.

JVMPerformanceSpringBoot
0 likes · 6 min read
Spring Boot Project and JVM Tuning Guide
Senior Brother's Insights
Senior Brother's Insights
Nov 4, 2019 · Fundamentals

Why Understanding Java Memory Model Boosts Your Code Efficiency

This article explains the hardware memory architecture, the role of caches, and how the Java Memory Model abstracts thread interaction with main and working memory, detailing the eight fundamental JMM operations, their ordering rules, and special considerations for long and double types to help developers write correct, high‑performance concurrent Java code.

CacheJVMJava
0 likes · 11 min read
Why Understanding Java Memory Model Boosts Your Code Efficiency
Programmer DD
Programmer DD
Nov 4, 2019 · Operations

Master JVM Performance: Essential Tools and Real‑World Tuning Guide

This article introduces the most common JVM performance problems in enterprise Java applications and provides a practical guide to using core monitoring and tuning tools such as jps, jstack, jmap, jstat and hprof, complete with command syntax, sample outputs and step‑by‑step troubleshooting examples.

JVMJavaMonitoring Tools
0 likes · 13 min read
Master JVM Performance: Essential Tools and Real‑World Tuning Guide
Programmer DD
Programmer DD
Nov 3, 2019 · Backend Development

Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews

This article explains Java garbage collection fundamentals, detailing JVM memory layout, key -X and -XX parameters, the mechanisms of object survival, and the main GC algorithms—Mark‑Sweep, Copying, Mark‑Compact, and generational collection—providing clear diagrams and interview‑ready insights.

GC AlgorithmsGarbage CollectionInterview preparation
0 likes · 9 min read
Master Java GC: Understand Memory, Parameters, and Algorithms for Interviews
Programmer DD
Programmer DD
Nov 2, 2019 · Backend Development

Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture

This article explains the Java Virtual Machine’s memory layout, covering the five runtime regions—heap, method area, JVM stacks, native method stacks, and program counter—along with their purposes, thread‑visibility, garbage‑collection behavior, and common pitfalls such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture
JavaEdge
JavaEdge
Oct 30, 2019 · Fundamentals

Inside the Java Launcher: How the JVM Starts and Executes Main

This article walks through the native entry point of the Java launcher, explaining how the main function delegates to JLI_Launch, initializes the JVM, loads the main class, constructs arguments, and finally invokes the Java main method with detailed code excerpts.

CJVMJava
0 likes · 8 min read
Inside the Java Launcher: How the JVM Starts and Executes Main
FunTester
FunTester
Oct 30, 2019 · Fundamentals

Mastering JVM Memory: Models, GC Algorithms, and Optimization Tips

This article provides a comprehensive overview of the JVM memory model, garbage collection algorithms, various collectors and their trade‑offs, class loading steps, object lifecycle, escape analysis, and practical tuning commands for optimizing Java applications.

GC AlgorithmsGarbage CollectionJVM
0 likes · 14 min read
Mastering JVM Memory: Models, GC Algorithms, and Optimization Tips
Senior Brother's Insights
Senior Brother's Insights
Oct 27, 2019 · Fundamentals

Why Accessing a Superclass Static Field Skips Subclass Initialization – JVM Class Loading Explained

This article examines common Java interview questions about static field access, demonstrates how the JVM loads and initializes classes, explains why a subclass may not be initialized when referencing a superclass static variable, and details each phase of the JVM class‑loading lifecycle.

Bytecode VerificationInitializationJVM
0 likes · 13 min read
Why Accessing a Superclass Static Field Skips Subclass Initialization – JVM Class Loading Explained
Senior Brother's Insights
Senior Brother's Insights
Oct 18, 2019 · Fundamentals

Unlocking Java: A Deep Dive into JVM Memory Architecture

This article provides a comprehensive introduction to the Java Virtual Machine’s memory architecture, detailing the five runtime areas—Program Counter, JVM Stack, Native Method Stack, Heap, and Method Area—their thread scope, memory allocation, garbage‑collection behavior, and common errors such as OutOfMemoryError and StackOverflowError.

Garbage CollectionJVMJava
0 likes · 9 min read
Unlocking Java: A Deep Dive into JVM Memory Architecture
Architect's Tech Stack
Architect's Tech Stack
Oct 15, 2019 · Backend Development

Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas

This article explains how Java objects store behavior and state, describes the JVM method area where method bytecode resides, and demonstrates runtime class modification using java.lang.instrument.Instrumentation, BTrace scripts, and the Arthas diagnostic tool to solve real‑world debugging problems.

ArthasBTraceInstrumentation
0 likes · 14 min read
Understanding Java Object Behavior, Method Area, and Dynamic Tracing with Instrumentation, BTrace, and Arthas
Architect's Tech Stack
Architect's Tech Stack
Oct 12, 2019 · Backend Development

How to Minimize Long GC Pauses in Java Applications

Long garbage collection pauses can degrade Java application performance and SLA, so this guide outlines seven practical steps—including reducing object allocation rates, increasing young generation size, selecting appropriate GC algorithms, avoiding swap usage, tuning GC threads, managing I/O load, and limiting System.gc() calls—to minimize pause times.

GC optimizationGarbage CollectionJVM
0 likes · 10 min read
How to Minimize Long GC Pauses in Java Applications
Programmer DD
Programmer DD
Oct 9, 2019 · Fundamentals

Mastering JVM Class Loading: Key Concepts, Models, and Practical Tips

This article explains the JVM class loading mechanism, covering the loading and unloading process, lifecycle stages, the parent‑delegation model, timing of loading and unloading, practical debugging with -verbose:class, and the impact of custom class loaders on application behavior.

Backend DevelopmentJVMJava
0 likes · 9 min read
Mastering JVM Class Loading: Key Concepts, Models, and Practical Tips
Programmer DD
Programmer DD
Oct 7, 2019 · Backend Development

How Many Threads Can a Java JVM Actually Handle? Limits, Experiments, and Tips

This article explores the maximum number of threads a Java Virtual Machine can support, examining factors such as CPU, operating system, JVM version, and memory, and presents real‑world experiments, code examples, and theoretical calculations to help developers understand and manage thread limits effectively.

JVMJavaMemory
0 likes · 6 min read
How Many Threads Can a Java JVM Actually Handle? Limits, Experiments, and Tips
Programmer DD
Programmer DD
Sep 27, 2019 · Fundamentals

Why Does a Java Process Use Far More Memory Than Its Heap?

This article explains why a Java process consumes far more virtual memory than the configured heap size by detailing JVM subsystems, off‑heap allocations, native libraries, thread stacks, and other factors that contribute to overall memory usage.

HeapJVMJava
0 likes · 7 min read
Why Does a Java Process Use Far More Memory Than Its Heap?
Big Data Technology Architecture
Big Data Technology Architecture
Sep 26, 2019 · Databases

Elasticsearch Core Overview and Key Performance Metrics

This article provides a comprehensive guide to Elasticsearch’s architecture, node roles, data organization, and the most important performance metrics—including search, indexing, memory, JVM garbage collection, host‑level system metrics, cluster health, and resource saturation—offering practical advice on monitoring and tuning the cluster for reliability and efficiency.

Cluster ManagementElasticsearchJVM
0 likes · 27 min read
Elasticsearch Core Overview and Key Performance Metrics
Programmer DD
Programmer DD
Sep 21, 2019 · Backend Development

Unlocking the JVM: A Deep Dive into Java’s Runtime Architecture

This article explains the Java Virtual Machine’s architecture, covering its role as the JRE implementation, the three main subsystems—class loader, runtime data area, and execution engine—and detailing components such as class loading phases, memory areas, the interpreter, JIT compiler, and garbage collection.

Class LoaderJITJVM
0 likes · 7 min read
Unlocking the JVM: A Deep Dive into Java’s Runtime Architecture
Java Captain
Java Captain
Sep 14, 2019 · Fundamentals

Understanding the RUNNABLE Thread State in Java

This article explains the Java RUNNABLE thread state, how it differs from traditional OS ready/running states, its relationship with time‑slicing, blocking I/O, and why the JVM reports many blocked operations as RUNNABLE, illustrated with code examples and diagrams.

JVMJavaRunnable
0 likes · 12 min read
Understanding the RUNNABLE Thread State in Java
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 13, 2019 · Backend Development

Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty

This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.

Backend DevelopmentDesign PatternsInterview preparation
0 likes · 12 min read
Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty
Ctrip Technology
Ctrip Technology
Aug 28, 2019 · Fundamentals

Java Memory Layout and Garbage Collection Principles

This article provides a comprehensive overview of the JVM runtime memory areas, explains how the JVM determines garbage objects, reviews major GC algorithms and collectors—including the latest ZGC—and offers practical code examples and command‑line instructions for reproducing various OutOfMemoryError scenarios.

G1Garbage CollectionJVM
0 likes · 29 min read
Java Memory Layout and Garbage Collection Principles
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 20, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management

Java’s garbage collection, a critical yet often overlooked feature, encompasses various algorithms such as reference counting, reachability analysis, mark‑sweep, copying, and generational collection, each with distinct mechanisms, trade‑offs, and impacts on memory regions like Eden, Survivor, and Old spaces.

GC AlgorithmsGarbage CollectionJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: Algorithms, Roots, and Memory Management
Architect's Tech Stack
Architect's Tech Stack
Aug 1, 2019 · Fundamentals

Common Java OutOfMemoryError Types and Their Solutions

This article lists the most frequent Java OutOfMemoryError cases—including Java heap space, GC overhead limit exceeded, PermGen/Metaspace, native thread creation failures, array size limits, and direct buffer memory—explains their root causes, and provides practical troubleshooting steps and JVM tuning parameters to resolve them.

DebuggingJVMMemory Management
0 likes · 11 min read
Common Java OutOfMemoryError Types and Their Solutions
FunTester
FunTester
Aug 1, 2019 · Fundamentals

Essential Java JVM Commands Visualized in a Handy Mind Map

The author shares a concise mind map of key Java JVM commands learned during performance testing, offering a quick reference that can be downloaded as an XMind file for developers seeking to optimize their Java applications.

JVMXmindbackend
0 likes · 2 min read
Essential Java JVM Commands Visualized in a Handy Mind Map
Java Captain
Java Captain
Jul 26, 2019 · Fundamentals

Java Fundamentals: Spring Lifecycle, TCP Handshake, Thread Pool, JVM Memory, JMM, Spring MVC, JDBC, Spring Cloud, and Dubbo Overview

This article provides a comprehensive overview of core Java concepts and related technologies, covering Spring's lifecycle, TCP three-way handshake and four-way termination, thread pool execution flow, JVM memory structure and Java Memory Model, as well as Spring MVC, JDBC, Spring Cloud components, and Dubbo service framework.

JVMJavaSpringCloud
0 likes · 11 min read
Java Fundamentals: Spring Lifecycle, TCP Handshake, Thread Pool, JVM Memory, JMM, Spring MVC, JDBC, Spring Cloud, and Dubbo Overview
Java Captain
Java Captain
Jul 25, 2019 · Fundamentals

Understanding Automatic Garbage Collection and Generational GC in the JVM

This article explains how Java's automatic garbage collection works, covering the mark‑sweep‑compact phases, the need for generational collection, the structure of the JVM heap (young, old, and permanent generations), and the detailed object promotion process illustrated with diagrams.

Garbage CollectionGenerational GCJVM
0 likes · 7 min read
Understanding Automatic Garbage Collection and Generational GC in the JVM
Architect's Tech Stack
Architect's Tech Stack
Jul 24, 2019 · Backend Development

Understanding the G1 Garbage Collector in Java: Detailed Process and Log Analysis

This article explains the G1 (Garbage‑First) garbage collector introduced in JDK7, its region‑based architecture, key differences from CMS, and the complete GC cycle—including Young GC, concurrent phases, mixed GC, and Full GC—while providing real‑world log examples and performance insights for Java developers.

GC LogsGarbage CollectionJVM
0 likes · 10 min read
Understanding the G1 Garbage Collector in Java: Detailed Process and Log Analysis
Architecture Digest
Architecture Digest
Jul 23, 2019 · Fundamentals

Java Fundamentals: OOP Concepts, JVM/JDK/JRE, and Common Interview Topics

This article provides a comprehensive overview of core Java concepts for interview preparation, covering object‑oriented programming fundamentals, differences between OOP and procedural programming, detailed explanations of JVM, JDK, JRE, comparisons with C++, string handling, constructors, inheritance, polymorphism, threading, garbage collection, and related code examples.

Garbage CollectionInterviewJDK
0 likes · 36 min read
Java Fundamentals: OOP Concepts, JVM/JDK/JRE, and Common Interview Topics
Programmer DD
Programmer DD
Jul 22, 2019 · Backend Development

Unlock Hidden JVM Memory: Track Native Allocations with NMT

This tutorial explains why Java applications often exceed their -Xmx limits, enumerates the main sources of native memory consumption in the JVM, and shows how to monitor and analyze these allocations using Native Memory Tracking (NMT) commands and flags.

JVMJavaMemory Management
0 likes · 13 min read
Unlock Hidden JVM Memory: Track Native Allocations with NMT
Architect's Tech Stack
Architect's Tech Stack
Jul 14, 2019 · Backend Development

Performance Evaluation of Java 8 Stream API: Benchmarks and Insights

This article presents a comprehensive benchmark of Java 8 Stream API on large‑scale data, comparing serial and parallel stream operations with traditional external iteration across primitive, object, and reduction workloads, and draws practical recommendations on when to use streams for optimal performance.

JVMParallelismPerformance
0 likes · 8 min read
Performance Evaluation of Java 8 Stream API: Benchmarks and Insights
Java Backend Technology
Java Backend Technology
Jul 13, 2019 · Fundamentals

Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms

This article explains Java garbage collection in depth, covering its definition, historical origins, reference‑counting and reachability algorithms, GC roots, memory regions such as Eden, Survivor and Old, and the main collection strategies like Mark‑Sweep, Copying, Mark‑Compact and Generational collection.

Garbage CollectionGenerational GCJVM
0 likes · 15 min read
Why Java’s Garbage Collection Matters: From Roots to Generational Algorithms
Architect's Tech Stack
Architect's Tech Stack
Jul 10, 2019 · Backend Development

Common Java OutOfMemoryError Causes and Their Solutions

This article enumerates the most frequent Java OutOfMemoryError scenarios—including heap space exhaustion, GC overhead limits, oversized array allocations, PermGen/Metaspace depletion, thread creation failures, and native method errors—detailing their causes and practical JVM flag or code fixes to resolve them.

HeapJVMMemory Leak
0 likes · 7 min read
Common Java OutOfMemoryError Causes and Their Solutions
Java Backend Technology
Java Backend Technology
Jun 24, 2019 · Backend Development

What I Learned from 2 Months of Java Backend Interviews: Tips & Insights

Over two months, I interviewed with multiple companies for Java backend roles, sharing detailed experiences from technical rounds—covering JVM, concurrency, distributed locks, databases, and system design—to highlight key questions, effective answers, and practical advice for succeeding in similar backend development interviews.

DatabaseDistributed SystemsInterview
0 likes · 17 min read
What I Learned from 2 Months of Java Backend Interviews: Tips & Insights
58 Tech
58 Tech
Jun 18, 2019 · Fundamentals

Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices

This article explains the design principles, region-based architecture, object allocation strategies, Young and Mixed G1 GC phases, concurrent marking, three‑color marking, and practical tuning parameters for the G1 garbage collector in Java, illustrating concepts with code snippets and diagrams.

Garbage CollectionJVMJava
0 likes · 17 min read
Understanding G1 Garbage Collector: Design, Algorithms, and Tuning Practices
Architect's Tech Stack
Architect's Tech Stack
Jun 15, 2019 · Backend Development

Making Java Applications Run Faster: Performance Tuning Tools and Practices

This article presents a comprehensive guide to Java application performance optimization, covering OS‑level and JVM‑level diagnostics, profiling tools, GC analysis, JVM tuning, application‑code refactoring, and database‑layer adjustments, illustrated with real‑world case studies and code examples.

Database OptimizationGarbage CollectionJVM
0 likes · 20 min read
Making Java Applications Run Faster: Performance Tuning Tools and Practices
Java Captain
Java Captain
May 27, 2019 · Fundamentals

Java Runtime Memory Areas, Object Creation, and Common Interview Questions

This article explains Java's runtime memory regions, including the program counter, stacks, heap, method area, constant pool, and direct memory, and details the HotSpot object creation process, memory layout, access mechanisms, as well as String and wrapper class behaviors, providing essential knowledge for Java interview preparation.

Interview preparationJVMJava
0 likes · 19 min read
Java Runtime Memory Areas, Object Creation, and Common Interview Questions
21CTO
21CTO
May 24, 2019 · Backend Development

How Many Threads Can a JVM Actually Support? Limits, Factors, and Real-World Tests

The maximum number of Java Virtual Machine threads depends on CPU, operating system, JVM version, memory allocation, and configuration, with practical limits ranging from a few thousand on modest hardware to over ten thousand on high‑end systems, as demonstrated by several real‑world experiments.

JVMJavaMemory
0 likes · 5 min read
How Many Threads Can a JVM Actually Support? Limits, Factors, and Real-World Tests
Alibaba Cloud Native
Alibaba Cloud Native
May 8, 2019 · Fundamentals

Why Alibaba Dragonwell Is the Next OpenJDK for Enterprise Java

Alibaba Dragonwell is a free, long‑term supported OpenJDK distribution that incorporates Alibaba's internal AJDK enhancements, adds performance‑boosting features like JWarmUp and Java Flight Recorder, and provides serviceability tools such as large‑array warnings and mini heap dumps for production Java workloads.

Alibaba DragonwellJVMJWarmUp
0 likes · 9 min read
Why Alibaba Dragonwell Is the Next OpenJDK for Enterprise Java
Java Captain
Java Captain
May 3, 2019 · Fundamentals

Understanding the Composition of the Java Virtual Machine (JVM)

This article explains the overall architecture of the JVM, details each component of its runtime data area—including program counter, stacks, heap, and method area—and discusses related concepts such as the runtime constant pool and direct memory, providing a comprehensive overview for developers.

JVMJavaMemory Management
0 likes · 9 min read
Understanding the Composition of the Java Virtual Machine (JVM)
Java Captain
Java Captain
May 2, 2019 · Operations

Essential Linux and JVM Tools for Troubleshooting and Performance Analysis

This article compiles a comprehensive set of Linux commands, JVM utilities, and Java debugging tools—including tail, grep, awk, find, tsar, btrace, greys, JProfiler, jps, jstack, jmap, jstat, and IntelliJ plugins—to help engineers quickly diagnose, monitor, and resolve production issues while optimizing performance.

DebuggingJVMLinux
0 likes · 13 min read
Essential Linux and JVM Tools for Troubleshooting and Performance Analysis