BestHub
Sign in
Tagged articles
490 articles
Page 2 of 5
IT Services Circle
IT Services Circle
Jun 22, 2024 · Backend Development

Comprehensive Guide to Java Backend Interview Topics: Object Creation, Reflection, Serialization, GC, I/O Multiplexing, and Network Troubleshooting

This article provides an in-depth review of common Java backend interview questions, covering alternative object creation methods, practical reflection scenarios, serialization techniques, garbage‑collection algorithms, I/O multiplexing mechanisms, network port listening, and troubleshooting tips for server‑client communication issues.

Garbage CollectionI/O MultiplexingJava
0 likes · 24 min read
Comprehensive Guide to Java Backend Interview Topics: Object Creation, Reflection, Serialization, GC, I/O Multiplexing, and Network Troubleshooting
Bin's Tech Cabin
Bin's Tech Cabin
Jun 19, 2024 · Fundamentals

Why PhantomReference Can Track GC While WeakReference Can’t in ZGC

Exploring the differences between PhantomReference and WeakReference in Java’s ZGC, this article explains how ZGC’s concurrent phases and the should_drop method use distinct bitmap bits to determine object liveness, revealing why only PhantomReference reliably tracks object reclamation in certain finalization scenarios.

Garbage CollectionJVMJava
0 likes · 11 min read
Why PhantomReference Can Track GC While WeakReference Can’t in ZGC
Bin's Tech Cabin
Bin's Tech Cabin
Jun 17, 2024 · Fundamentals

How Does Java’s FinalReference Keep Objects Alive During GC?

This article explains how the JVM creates and manages FinalReference objects, how they interact with the finalize() method, and how the ZGC and other GC phases discover, revive, and eventually reclaim objects, detailing the roles of ReferenceHandler, FinalizerThread, and related internal data structures.

FinalReferenceFinalizerThreadGarbage Collection
0 likes · 20 min read
How Does Java’s FinalReference Keep Objects Alive During GC?
Bin's Tech Cabin
Bin's Tech Cabin
Jun 15, 2024 · Fundamentals

When Does ZGC Actually Clear SoftReferences? Inside the JVM Reference Policy

This article explains how ZGC in OpenJDK 17 decides whether to reclaim SoftReference objects, detailing the unconditional clearing scenarios, the policies governing SoftReference lifetimes, and how the JVM quantifies memory pressure using heap size and the -XX:SoftRefLRUPolicyMSPerMB flag.

Garbage CollectionJVMReference Policy
0 likes · 15 min read
When Does ZGC Actually Clear SoftReferences? Inside the JVM Reference Policy
macrozheng
macrozheng
May 28, 2024 · Backend Development

Why Upgrading to JDK 17 with ZGC Can Slash GC Pauses to Sub‑millisecond

This article explains how moving to JDK 17 and the low‑latency ZGC garbage collector can reduce pause times to under 10 ms, improve throughput, and meet demanding real‑time service requirements, while providing practical upgrade steps, JVM tuning parameters, and performance comparisons.

Backend DevelopmentGarbage CollectionJava
0 likes · 8 min read
Why Upgrading to JDK 17 with ZGC Can Slash GC Pauses to Sub‑millisecond
Java Tech Enthusiast
Java Tech Enthusiast
May 27, 2024 · Backend Development

Understanding Garbage Collection in the JVM

The author celebrates landing a new job while emphasizing that mastering Java's garbage collection—identifying and reclaiming memory from unreachable objects via algorithms like reference counting or reachability analysis—is essential for robust backend development and preventing memory overflow.

Garbage CollectionJVMJava
0 likes · 4 min read
Understanding Garbage Collection in the JVM
Architecture Digest
Architecture Digest
May 27, 2024 · Backend Development

Upgrading to JDK 17 with ZGC: Performance Comparison and Migration Guide

This article explains why upgrading to JDK 17 and switching to the low‑latency ZGC garbage collector can dramatically reduce pause times and improve throughput, compares GC and CPU metrics against G1, and provides step‑by‑step installation and JVM tuning instructions with code examples.

Garbage CollectionJVMJava
0 likes · 6 min read
Upgrading to JDK 17 with ZGC: Performance Comparison and Migration Guide
FunTester
FunTester
May 8, 2024 · Fundamentals

How Garbage Collection Impacts Performance and How to Optimize It

This article explains the fundamentals of garbage collection, compares manual and automatic memory management, outlines common GC algorithms, and provides practical guidance on performance analysis, tool selection, and optimization techniques to improve application responsiveness and resource utilization.

GC AlgorithmsGarbage CollectionMemory Management
0 likes · 22 min read
How Garbage Collection Impacts Performance and How to Optimize It
Su San Talks Tech
Su San Talks Tech
Apr 22, 2024 · Fundamentals

Why Java’s Object Graph Traversal Pauses: Tri‑Color Marking & STW Solutions

This article explains the two‑phase reachability analysis in Java garbage collection, detailing why the object‑graph traversal stage incurs stop‑the‑world pauses, how the tri‑color marking model reveals issues like floating garbage and object disappearance, and describes incremental update and snapshot‑at‑the‑beginning techniques that avoid STW.

Garbage CollectionJavaSATB
0 likes · 14 min read
Why Java’s Object Graph Traversal Pauses: Tri‑Color Marking & STW Solutions
Tencent Cloud Developer
Tencent Cloud Developer
Apr 3, 2024 · Fundamentals

Seven Common GC Algorithms: Principles, Comparisons, and Optimizations

The article surveys seven common garbage‑collection algorithms—Mark‑Sweep, Reference Counting, Copying, Mark‑Compact, Conservative, Generational, and Incremental/Tri‑color—explaining their principles, strengths, weaknesses, evaluation criteria such as throughput and pause time, and practical optimizations, emphasizing that the best choice depends on specific application needs.

GC AlgorithmsGarbage CollectionGenerational GC
0 likes · 42 min read
Seven Common GC Algorithms: Principles, Comparisons, and Optimizations
Bin's Tech Cabin
Bin's Tech Cabin
Apr 1, 2024 · Fundamentals

Why System.gc Matters for Java NIO Memory Management

This article explains how Java's System.gc triggers full or concurrent garbage collection in NIO scenarios, detailing the JVM's handling of out‑of‑memory errors during memory‑mapped file operations and direct buffer allocations, and examines the behavior across various garbage collectors such as Serial, Parallel, G1, ZGC, and Shenandoah.

DirectByteBufferGarbage CollectionJVM
0 likes · 20 min read
Why System.gc Matters for Java NIO Memory Management
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 21, 2024 · Fundamentals

Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning

This article provides a comprehensive guide to JVM internals, covering runtime data areas, heap segmentation, object allocation, reference types, class loading phases, garbage collection algorithms, collector choices across JDK versions, performance tuning commands, and practical troubleshooting techniques for production Java applications.

Garbage CollectionJVMMemory Management
0 likes · 38 min read
Mastering JVM Memory: From Heap Layout to Garbage Collection Tuning
Open Source Linux
Open Source Linux
Mar 7, 2024 · Operations

How to Fix Disk‑Full Issues in Legacy Kubernetes Clusters Using Docker

This guide explains why old Kubernetes clusters that use Docker can run out of disk space, describes the symptoms such as pods stuck in ContainerCreating, and provides step‑by‑step commands to clean Docker files, prune images, adjust kubelet settings, and prevent future disk‑full problems.

Disk CleanupGarbage CollectionOperations
0 likes · 11 min read
How to Fix Disk‑Full Issues in Legacy Kubernetes Clusters Using Docker
DeWu Technology
DeWu Technology
Feb 28, 2024 · Cloud Native

Technical Overview of ZingJDK: ReadyNow, Falcon JIT, and C4 GC

ZingJDK, Azul’s high‑performance commercial JDK built on OpenJDK, combines ReadyNow® pre‑warming, the LLVM‑based Falcon JIT compiler, the pause‑free C4 concurrent compacting garbage collector, and a cloud‑native off‑load compiler to deliver dramatically faster startup and execution across JDK 7‑21, though it lacks dynamic Attach support and requires a commercial license.

Cloud NativeGarbage CollectionJIT
0 likes · 17 min read
Technical Overview of ZingJDK: ReadyNow, Falcon JIT, and C4 GC
php Courses
php Courses
Feb 26, 2024 · Backend Development

PHP Memory Management Functions: memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and memory_limit

This article explains PHP's key memory management functions—including memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and the memory_limit setting—providing usage syntax, examples, and guidance on optimizing script performance and preventing memory‑related issues.

Backend DevelopmentGarbage CollectionMemory Management
0 likes · 4 min read
PHP Memory Management Functions: memory_get_usage, memory_get_peak_usage, gc_collect_cycles, and memory_limit
Top Architect
Top Architect
Feb 20, 2024 · Backend Development

JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks

Over a month of systematic JVM tuning, the author reduced FullGC frequency from 40 times per day to once every ten days, halved YoungGC time, identified and fixed a memory leak caused by anonymous inner‑class listeners, and documented the step‑by‑step optimization process with configuration changes and performance results.

Garbage CollectionJVMJava
0 likes · 12 min read
JVM Garbage Collection Tuning Experience: Reducing FullGC Frequency and Solving Memory Leaks
DeWu Technology
DeWu Technology
Feb 5, 2024 · Fundamentals

Understanding Dart VM Garbage Collection and Memory Management

The article explains Dart VM’s generational garbage collection, detailing object allocation, the young‑generation Scavenge copying collector, old‑generation Mark‑Sweep and Mark‑Compact algorithms, safepoints, write‑barrier mechanics, debugging a write‑protect crash, and the importance of logging for memory‑management analysis.

DARTGC AlgorithmsGarbage Collection
0 likes · 33 min read
Understanding Dart VM Garbage Collection and Memory Management
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jan 31, 2024 · Backend Development

Understanding Java JVM Garbage Collectors: From Serial to Shenandoah

This article explains the main Java JVM garbage collectors—including Serial, Parallel, CMS, G1, ZGC, Epsilon, and Shenandoah—detailing their architectures, pause characteristics, suitable workloads, and key advantages, helping developers choose the right collector for different application sizes and latency requirements.

Garbage CollectionJVMJava
0 likes · 7 min read
Understanding Java JVM Garbage Collectors: From Serial to Shenandoah
政采云技术
政采云技术
Jan 25, 2024 · Fundamentals

Java JDK 12‑17 New Features and Enhancements Overview

This article provides a comprehensive overview of the major language and runtime enhancements introduced in JDK 12 through JDK 17, covering switch expressions, micro‑benchmarking with JMH, class‑data sharing, garbage‑collector improvements, new String methods, hidden and sealed classes, records, and unified asynchronous logging, all illustrated with code examples.

Garbage CollectionJDKJMH
0 likes · 23 min read
Java JDK 12‑17 New Features and Enhancements Overview
Test Development Learning Exchange
Test Development Learning Exchange
Jan 1, 2024 · Fundamentals

Handling Circular References and Memory Leaks in Python with weakref and gc Modules

This article explains how circular references cause memory leaks in Python, describes the role of reference counting and the cyclic garbage collector, and provides practical examples using the weakref and gc modules to create weak references, detect, and manually manage cyclic garbage.

Circular ReferencesGarbage CollectionMemory Management
0 likes · 6 min read
Handling Circular References and Memory Leaks in Python with weakref and gc Modules
Architects' Tech Alliance
Architects' Tech Alliance
Jan 1, 2024 · Fundamentals

Understanding SSD Architecture: Blocks, Pages, Wear Leveling, and Data Protection

This article explains the core components and operation of SSDs—including controllers, NAND flash, block and page structures, program/erase cycles, garbage collection, wear‑leveling strategies, bad‑block handling, data‑redundancy mechanisms, namespace concepts, over‑provisioning, and key reliability metrics—providing a comprehensive technical overview for storage engineers.

Data ProtectionGarbage CollectionNAND Flash
0 likes · 12 min read
Understanding SSD Architecture: Blocks, Pages, Wear Leveling, and Data Protection
Python Programming Learning Circle
Python Programming Learning Circle
Dec 29, 2023 · Fundamentals

Introduction to Object-Oriented Programming in Python

This article provides a comprehensive overview of Python's object‑oriented programming features, covering classes, class and instance variables, methods, inheritance, method overriding, built‑in class attributes, and garbage collection, supplemented with clear code examples and explanations.

Garbage CollectionInheritanceOOP
0 likes · 9 min read
Introduction to Object-Oriented Programming in Python
JD Cloud Developers
JD Cloud Developers
Dec 13, 2023 · Backend Development

Resolving Unexpected 2‑Second Young GC Pauses in Java Rule Engine

A Java rule‑engine experiences occasional 1‑2 second Young GC pauses after warm‑up, caused by dynamic promotion thresholds that trigger massive object promotion, and the article explains the root cause, demonstrates log analysis, and provides JVM tuning steps to eliminate the long pauses.

Garbage CollectionJVMJava
0 likes · 15 min read
Resolving Unexpected 2‑Second Young GC Pauses in Java Rule Engine
Test Development Learning Exchange
Test Development Learning Exchange
Dec 12, 2023 · Fundamentals

Python Memory Management and Optimization Techniques

Python automatically manages memory through garbage collection, and this article explains how the garbage collector works and presents ten practical techniques—including manual gc calls, generators, sys.getsizeof, slice copying, del statements, sys.intern, NumPy, pandas, reference counting, and __slots__—to reduce memory usage and improve performance.

Garbage CollectionMemory ManagementOptimization
0 likes · 5 min read
Python Memory Management and Optimization Techniques
JD Tech
JD Tech
Dec 5, 2023 · Backend Development

Comprehensive Guide to Upgrading from JDK 8 to JDK 11: Performance, New Features, and Migration Practices

This article provides a thorough analysis of upgrading Java applications from JDK 8 to JDK 11, covering performance improvements, garbage collector comparisons, new language features, module system changes, practical migration steps, common pitfalls, and best‑practice recommendations for enterprise backend development.

Garbage CollectionJDK11Migration
0 likes · 20 min read
Comprehensive Guide to Upgrading from JDK 8 to JDK 11: Performance, New Features, and Migration Practices
37 Interactive Technology Team
37 Interactive Technology Team
Nov 20, 2023 · Fundamentals

What Are Stack and Heap?

The article explains Go’s stack and heap memory, showing that stack allocations are fast, LIFO‑ordered and compile‑time sized while heap allocations grow upward, require garbage collection, and occur when variables escape a function, urging developers to prefer stack use for better performance.

Garbage CollectionGoHeap
0 likes · 6 min read
What Are Stack and Heap?
AI Illustrated Series
AI Illustrated Series
Nov 16, 2023 · Fundamentals

Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives

This article provides a comprehensive, step‑by‑step analysis of Go’s core concepts—including nil handling, the context package, string and rune internals, unsafe pointers, memory alignment, WaitGroup, semaphores, channels, slices, map implementations, sync.Map, garbage collection, and reflection—illustrated with concrete code examples and detailed reasoning.

Garbage CollectionGoMemory
0 likes · 30 min read
Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives
Ops Development Stories
Ops Development Stories
Nov 16, 2023 · Fundamentals

Unlocking G1 GC: Why Your Java Service Hangs and How to Fix It

This article explains the G1 garbage collector’s heap layout, collection cycles, pause prediction, log analysis, and monitoring tools, helping Java developers diagnose and resolve performance issues such as frequent restarts, OOM, CPU spikes, and periodic latency spikes.

Garbage CollectionJVMJava
0 likes · 19 min read
Unlocking G1 GC: Why Your Java Service Hangs and How to Fix It
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 13, 2023 · Backend Development

What’s New in Java? Key JDK Changes from String to Private Interface Methods

This article reviews the major updates introduced in recent JDK releases, covering the shift from char[] to byte[] in String, expanded pattern‑matching in switch, removal of biased locking, G1 garbage‑collector evolution, JDK/JRE consolidation, generics specialization, and the addition of private methods in interfaces.

Backend DevelopmentGarbage CollectionGenerics
0 likes · 9 min read
What’s New in Java? Key JDK Changes from String to Private Interface Methods
Architects' Tech Alliance
Architects' Tech Alliance
Nov 10, 2023 · Fundamentals

Factors Affecting NVMe SSD Performance: Hardware, Software, and Environmental Influences

The article analyzes how hardware components, software mechanisms, and environmental conditions collectively impact NVMe SSD performance, explaining why real‑world results often differ from vendor specifications and highlighting the roles of NAND type, controller architecture, PCIe bandwidth, garbage collection, temperature, and wear‑leveling.

Garbage CollectionHardwareNVMe
0 likes · 12 min read
Factors Affecting NVMe SSD Performance: Hardware, Software, and Environmental Influences
Ops Development Stories
Ops Development Stories
Nov 9, 2023 · Operations

How to Pinpoint Java Out‑Of‑Memory Errors Using jmap and VisualVM

This guide explains why frequent garbage collection and heap memory overflow occur in Java applications, demonstrates how to reproduce the issue with a sample program, and walks through various techniques—including jmap histograms, heap dumps, VisualVM analysis, and remote JMX monitoring—to diagnose and resolve out‑of‑memory errors.

Garbage CollectionHeap DumpJava
0 likes · 9 min read
How to Pinpoint Java Out‑Of‑Memory Errors Using jmap and VisualVM
IT Services Circle
IT Services Circle
Nov 7, 2023 · Backend Development

Understanding ThreadLocal Memory Leaks and How to Prevent Them

This article explains the internal structure of ThreadLocal, identifies scenarios where ThreadLocal can cause memory leaks—especially in thread‑pool environments—analyzes the root causes, and provides practical techniques such as using remove() and expungeStaleEntry() to avoid these leaks.

Garbage CollectionJavaMemory Leak
0 likes · 11 min read
Understanding ThreadLocal Memory Leaks and How to Prevent Them
Programmer DD
Programmer DD
Oct 25, 2023 · Backend Development

Why G1 Garbage Collector Beats CMS in Java 7+

The G1 Garbage Collector, introduced in Java 7 update 4, replaces CMS by using a region‑based design that minimizes pause times and improves throughput, and a detailed video with diagrams and code examples is provided to deepen understanding of its operation.

Backend DevelopmentGarbage CollectionJVM
0 likes · 2 min read
Why G1 Garbage Collector Beats CMS in Java 7+
FunTester
FunTester
Oct 23, 2023 · Backend Development

Understanding and Managing Memory Leaks in Java Applications

This article explains the concept of memory leaks in Java applications, why they matter, how to identify common leak patterns and symptoms, and provides best practices, tools, and code examples for preventing, detecting, and resolving memory leaks to improve performance and stability.

Best PracticesGarbage CollectionJava
0 likes · 18 min read
Understanding and Managing Memory Leaks in Java Applications
Tencent Cloud Developer
Tencent Cloud Developer
Oct 12, 2023 · Fundamentals

From 0 to 1: How to Design and Implement Your Own Scripting Language

The article walks readers through building a custom scripting language from scratch—explaining compilation basics, lexical scanning, parsing, bytecode generation, and virtual‑machine execution—using a sample language called eben to illustrate BNF syntax, variable scopes, control flow, functions, closures, object‑orientation, garbage collection, and the historical evolution of programming languages.

BNFGarbage CollectionScripting Language
0 likes · 46 min read
From 0 to 1: How to Design and Implement Your Own Scripting Language
Java Captain
Java Captain
Oct 7, 2023 · Fundamentals

Understanding the Java Virtual Machine: Architecture, Operation, and Optimization Strategies

This article provides a comprehensive overview of the Java Virtual Machine, detailing its core components such as the interpreter, class loader, and runtime, explaining its execution workflow from source code to bytecode and native code, and presenting practical optimization techniques for memory, garbage collection, and performance.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding the Java Virtual Machine: Architecture, Operation, and Optimization Strategies
Java Captain
Java Captain
Oct 7, 2023 · Fundamentals

Understanding the JVM Memory Model, Garbage Collection, and Memory Management Strategies

This article explains the Java Virtual Machine's memory architecture—including heap, method area, stack, program counter, and non‑heap memory—details common garbage‑collection algorithms such as mark‑sweep, copying, mark‑compact, and generational, and outlines Java's memory‑management practices like object lifecycle, memory partitioning, references, and synchronization.

Garbage CollectionJVMJava
0 likes · 6 min read
Understanding the JVM Memory Model, Garbage Collection, and Memory Management Strategies
Zhuanzhuan Tech
Zhuanzhuan Tech
Sep 27, 2023 · Backend Development

JDK17 Upgrade for Search Recommendation Service: Process, Issues, and Performance Improvements

This article details the motivation, steps, encountered challenges, and measurable performance gains of upgrading a high‑traffic search recommendation service from JDK 8 to JDK 17, highlighting new Java syntax, modern GC algorithms, deployment procedures, and the resulting reductions in latency, GC pause times, and heap usage.

Garbage CollectionJavaUpgrade
0 likes · 19 min read
JDK17 Upgrade for Search Recommendation Service: Process, Issues, and Performance Improvements
DeWu Technology
DeWu Technology
Sep 20, 2023 · Fundamentals

Understanding ZGC: Architecture, Key Features, and Execution Cycle

ZGC, introduced in JDK 11, is a non‑generational, highly concurrent Java garbage collector that uses colored pointers and load barriers to achieve sub‑10 ms pause times—even on terabyte‑scale heaps—while limiting throughput loss to under 15 % through three brief stop‑the‑world phases and four concurrent phases.

Garbage CollectionJVMPerformance
0 likes · 17 min read
Understanding ZGC: Architecture, Key Features, and Execution Cycle
Top Architect
Top Architect
Sep 19, 2023 · Backend Development

Analyzing and Resolving Unexpected JVM GC Spikes in Production

This article recounts a production incident where a container's CPU spiked due to abnormal JVM garbage collection, walks through step-by-step diagnostics using top, jstack, and thread analysis, explains the root cause in an Excel export routine, and concludes with a brief promotion of a ChatGPT community.

DockerGarbage CollectionJVM
0 likes · 8 min read
Analyzing and Resolving Unexpected JVM GC Spikes in Production
JD Tech
JD Tech
Aug 31, 2023 · Fundamentals

Understanding JVM Runtime Memory Layout, Garbage Collection Roots, and Algorithms

This article provides a comprehensive overview of the Java Virtual Machine's runtime memory areas, object layout, garbage collection roots, marking algorithms, generational hypotheses, remembered sets, and the main GC algorithms such as Mark‑Sweep, Mark‑Copy, and Mark‑Compact, explaining their principles and trade‑offs.

Garbage CollectionGenerational GCJVM
0 likes · 16 min read
Understanding JVM Runtime Memory Layout, Garbage Collection Roots, and Algorithms
vivo Internet Technology
vivo Internet Technology
Aug 23, 2023 · Backend Development

Memory Optimization for Core Services: JVM Tuning and Large Object Management

The article describes how vivo’s core music service reduced frequent garbage collections, long GC pauses, and RPC timeouts by switching to ParNew+CMS collectors, implementing fault‑transfer monitoring, optimizing large response objects, and adding non‑invasive payload checks, resulting in dramatically lower YGC/FGC frequencies and improved memory stability.

Backend DevelopmentGarbage CollectionJVM Optimization
0 likes · 12 min read
Memory Optimization for Core Services: JVM Tuning and Large Object Management
Su San Talks Tech
Su San Talks Tech
Aug 23, 2023 · Fundamentals

Why Does JVM Allocate Objects in Multiple Steps? Explore Creation & Memory Layout

This article explains the JVM's object creation process—including stack allocation, TLAB checks, Eden and Survivor spaces, and GC handling—and details the memory layout of Java objects, covering object headers, class pointers, array lengths, padding, and the effect of compressed oops on 32‑bit versus 64‑bit systems.

Garbage CollectionJVMJava
0 likes · 9 min read
Why Does JVM Allocate Objects in Multiple Steps? Explore Creation & Memory Layout
JD Retail Technology
JD Retail Technology
Aug 22, 2023 · Operations

Mastering JDK8 GC: Practical Tuning Guide for High‑Performance Applications

This guide summarizes JD.com’s extensive JDK8 garbage‑collector optimization experience, covering version requirements, how to select the right GC, core and collector‑specific parameter settings, logging configuration, and concrete methods to assess GC health for latency‑sensitive and throughput‑oriented workloads.

GC tuningGarbage CollectionJDK
0 likes · 5 min read
Mastering JDK8 GC: Practical Tuning Guide for High‑Performance Applications
Java Captain
Java Captain
Aug 18, 2023 · Backend Development

JVM GC Optimization: Reducing FullGC Frequency and Resolving Memory Leaks

This article documents a month‑long JVM garbage‑collection tuning effort that lowered FullGC from around 40 daily occurrences to one every ten days, halved YoungGC time, identified and fixed a memory‑leak caused by anonymous inner‑class listeners, and refined heap and metaspace settings to improve overall server throughput.

Garbage CollectionJVMJava
0 likes · 10 min read
JVM GC Optimization: Reducing FullGC Frequency and Resolving Memory Leaks
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Aug 12, 2023 · Backend Development

JVM Performance Tuning: Six-Step Process and Key Parameters

This article explains why JVM memory tuning is essential for high‑pay roles, outlines six practical steps—including GC monitoring, heap dump generation, analysis, and parameter adjustments—and provides detailed guidance on heap size, generation ratios, GC types, and thread stack settings to reduce Full GC frequency and improve application performance.

Full GCGarbage CollectionHeap Memory
0 likes · 7 min read
JVM Performance Tuning: Six-Step Process and Key Parameters
Top Architect
Top Architect
Aug 10, 2023 · Fundamentals

Understanding Automatic Garbage Collection and Generational GC in Java

This article explains the concept of automatic garbage collection in Java, detailing the mark‑sweep‑compact process, the need for generational collection, and how objects move through Eden, Survivor, and Old generations, while also noting promotional links for further resources.

Garbage CollectionGenerational GCJVM
0 likes · 8 min read
Understanding Automatic Garbage Collection and Generational GC in Java
Test Development Learning Exchange
Test Development Learning Exchange
Aug 6, 2023 · Fundamentals

Practical Python Garbage Collection and Memory Analysis: 10 Useful Code Examples

This article presents ten practical Python code examples demonstrating various garbage collection mechanisms and memory‑analysis tools, including reference counting, cyclic references, object inspection, tracemalloc, memory_profiler, pympler, and objgraph, to help developers understand and optimize memory usage.

DebuggingGarbage CollectionMemory Management
0 likes · 4 min read
Practical Python Garbage Collection and Memory Analysis: 10 Useful Code Examples
Architect
Architect
Aug 5, 2023 · Artificial Intelligence

Architecture and Evolution of a Game Recommendation System

From its inception as a simple game distribution platform to a sophisticated, multi‑layered recommendation architecture, this article details the background, early models, business growth, architectural evolution, caching strategies, GC optimization, rate limiting, experiment platform, multi‑path recall, dynamic tuning, and future intelligent enhancements of a game recommendation system.

A/B testingArtificial IntelligenceCaching
0 likes · 17 min read
Architecture and Evolution of a Game Recommendation System
Senior Tony
Senior Tony
Jul 23, 2023 · Backend Development

Master JVM Tuning: Balancing Pause Time, Throughput, and Memory Usage

This article explains the core trade‑offs of JVM tuning—short pause times versus high throughput—provides quantitative goals, outlines when tuning is needed, details step‑by‑step optimization procedures, and lists common GC strategies and command‑line parameters for effective Java performance tuning.

Garbage CollectionJVMJava
0 likes · 12 min read
Master JVM Tuning: Balancing Pause Time, Throughput, and Memory Usage
Architect
Architect
Jul 21, 2023 · Fundamentals

JVM Basics, Class Loading, Runtime Data Areas, Garbage Collection and Tuning Guide

This article provides a concise yet comprehensive overview of the Java Virtual Machine, covering its core components, how Java source files are compiled and executed, class‑loader mechanisms, runtime memory areas, garbage‑collection algorithms, and practical JVM tuning parameters for optimal performance.

Garbage CollectionJVMJava
0 likes · 31 min read
JVM Basics, Class Loading, Runtime Data Areas, Garbage Collection and Tuning Guide
Su San Talks Tech
Su San Talks Tech
Jun 19, 2023 · Backend Development

Master JVM Performance: Memory Model, OOM Cases, and Tuning Tools

This article reviews the Java HotSpot memory model, explains when JVM tuning is needed, details common OutOfMemoryError scenarios with reproducible code, introduces built‑in monitoring utilities and third‑party tools, and provides practical tuning parameters and case studies for optimizing Java applications.

Garbage CollectionJVMJava
0 likes · 24 min read
Master JVM Performance: Memory Model, OOM Cases, and Tuning Tools
Architecture Digest
Architecture Digest
Jun 16, 2023 · Backend Development

Generational Shenandoah GC Feature Removed from Java 21

Java 21, slated for release on September 19, 2023 as the next LTS version after Java 17, will drop the experimental Generational Shenandoah garbage‑collector feature during its Ramp‑down phase due to insufficient readiness, with the change slated for removal by the June 14 review deadline.

Garbage CollectionGenerational GCJDK21
0 likes · 4 min read
Generational Shenandoah GC Feature Removed from Java 21
FunTester
FunTester
Jun 9, 2023 · Fundamentals

Comparison of Java and Go Garbage Collection Mechanisms

This article compares the memory management and garbage collection architectures of Java and Go, detailing their heap and stack regions, GC trigger conditions, collection algorithms, fragmentation handling, root object selection, and write‑barrier strategies, and includes illustrative code examples.

Garbage CollectionJavaMemory Management
0 likes · 13 min read
Comparison of Java and Go Garbage Collection Mechanisms
Bilibili Tech
Bilibili Tech
Jun 2, 2023 · Backend Development

Investigation and Resolution of Service Availability Fluctuations in a High‑QPS Go Backend Service

An investigation of a 100k‑QPS Go monolith revealed that intermittent availability drops were caused by a memory‑leak in the third‑party gcache LFU implementation, which inflated GC work and produced long mark phases; upgrading gcache eliminated the leak and restored 0.999+ availability, highlighting the need for thorough observability and dependency monitoring.

Garbage CollectionGoPerformance debugging
0 likes · 10 min read
Investigation and Resolution of Service Availability Fluctuations in a High‑QPS Go Backend Service
JD Cloud Developers
JD Cloud Developers
May 31, 2023 · Fundamentals

How Shenandoah and ZGC Achieve Sub‑10ms Pauses in Modern Java

This article compares the Shenandoah and ZGC garbage collectors introduced in OpenJDK, explaining their design goals, key differences from G1, core mechanisms such as connection matrices and forwarding or colored pointers, and detailing each collector’s concurrent phases to achieve pause times under 10 ms regardless of heap size.

Garbage CollectionJVMJava
0 likes · 16 min read
How Shenandoah and ZGC Achieve Sub‑10ms Pauses in Modern Java
ITPUB
ITPUB
May 29, 2023 · Fundamentals

Is Java Really Obsolete? Exploring Its Evolution, Challenges, and Future

The article examines Java's 27‑year history, comparing its performance, startup time, and memory usage against modern languages and cloud‑native demands, while detailing JDK feature releases, module system, garbage collectors, AOT compilation, virtual threads, value types, GraalVM, and emerging frameworks to assess Java's relevance today and tomorrow.

AoTGarbage CollectionJDK
0 likes · 42 min read
Is Java Really Obsolete? Exploring Its Evolution, Challenges, and Future
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
May 29, 2023 · Backend Development

Why Is My Go Health‑Check So Slow? Diagnosing TCP Latency and GC Overhead

This article investigates why a Go‑based service health‑check system experiences high latency, examines differences from Nginx checks, runs experiments on physical machines and Docker, and explores goroutine scheduling, GOMAXPROCS, and garbage‑collection tuning to reduce average response time from 40 ms to under 10 ms.

DockerGarbage CollectionPerformance Optimization
0 likes · 10 min read
Why Is My Go Health‑Check So Slow? Diagnosing TCP Latency and GC Overhead
vivo Internet Technology
vivo Internet Technology
May 10, 2023 · Databases

Design and Optimization of a Disk‑Based KV Store Compatible with Redis on TiKV

The article details a Redis‑compatible, disk‑based KV service built atop TiKV using a compute‑storage split (Tula), describes custom key encoding and expiration mechanisms, and explains four optimization stages that introduce slot‑based hashing and adaptive concurrency to dramatically cut garbage‑collection latency while preserving write performance.

Database OptimizationGarbage CollectionKV Store
0 likes · 21 min read
Design and Optimization of a Disk‑Based KV Store Compatible with Redis on TiKV
JD Cloud Developers
JD Cloud Developers
May 10, 2023 · Fundamentals

Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1

This article explores the evolution of Java garbage collectors—from the simple Serial and Parallel collectors to the concurrent CMS and region-based G1—detailing their algorithms, tuning parameters, strengths, weaknesses, and best‑practice recommendations for selecting the optimal collector based on workload and memory constraints.

Garbage CollectionJVMJava
0 likes · 14 min read
Mastering Java Garbage Collectors: When to Choose Serial, Parallel, CMS, or G1
ByteDance Web Infra
ByteDance Web Infra
May 9, 2023 · Fundamentals

WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC

This article provides a comprehensive overview of the WebAssembly runtime, detailing its binary format, module loading and validation, execution engine designs, linear memory layout, garbage‑collection proposals, and the WebAssembly System Interface (WASI), while illustrating each concept with diagrams and code examples.

Garbage CollectionMemory ManagementRuntime
0 likes · 34 min read
WebAssembly Runtime Architecture: Loading, Parsing, Execution, Memory Management and GC
ByteFE
ByteFE
May 8, 2023 · Fundamentals

Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI

This article provides a comprehensive technical analysis of the WebAssembly runtime architecture, detailing the module loading and parsing process, stack-based execution engines, linear memory management strategies, and the evolving garbage collection proposals, while also introducing the WebAssembly System Interface (WASI) for cross-platform system interactions.

Bytecode ExecutionGarbage CollectionMemory Management
0 likes · 32 min read
Deep Dive into WebAssembly Runtime Architecture: Parsing, Execution, Memory Management, and WASI
DeWu Technology
DeWu Technology
May 5, 2023 · Fundamentals

Understanding JVM Safepoints: Concepts, Examples, and Tuning

JVM safepoints are pause points where the VM can stop all threads for operations like garbage collection; the article shows how counted loops can prevent threads from reaching safepoints, causing unexpected long sleeps, and explains tuning flags, loop‑counter changes, and best practices to avoid STW pauses.

Garbage CollectionJVMJava
0 likes · 18 min read
Understanding JVM Safepoints: Concepts, Examples, and Tuning
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
May 4, 2023 · Fundamentals

Comprehensive Guide to JVM Memory Model, Garbage Collection Algorithms, Collectors, Performance Tuning, and Tools

This article provides a comprehensive overview of the JVM, covering its memory model, heap and stack structures, four garbage‑collection algorithms, seven collectors including G1 and ZGC, performance‑tuning steps, analysis tools, and guidance on obtaining the full series of resources.

Garbage CollectionJVMJava
0 likes · 5 min read
Comprehensive Guide to JVM Memory Model, Garbage Collection Algorithms, Collectors, Performance Tuning, and Tools
Programmer DD
Programmer DD
Apr 30, 2023 · Backend Development

Why Java 17 Adoption Soared 430% in One Year – 2023 Ecosystem Insights

The 2023 New Relic Java ecosystem report reveals that Java 17 usage jumped over 430% in a single year, Java 11 remains dominant, Amazon Corretto now leads JDK market share, containerized deployments hit 70%, and the G1 garbage collector stays the top choice among Java 11+ users.

2023 ReportContainersGarbage Collection
0 likes · 6 min read
Why Java 17 Adoption Soared 430% in One Year – 2023 Ecosystem Insights
JD Cloud Developers
JD Cloud Developers
Apr 27, 2023 · Fundamentals

Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide

This article explains the JVM's runtime memory structure—including the method area, heap, stacks, and program counter—details object memory layout, garbage collection roots, marking algorithms, generational models, and various GC algorithms such as mark‑sweep, mark‑copy, and mark‑compact, providing a comprehensive overview.

GC AlgorithmsGarbage CollectionGenerational GC
0 likes · 16 min read
Understanding JVM Runtime Memory and Garbage Collection: A Complete Guide
JD Cloud Developers
JD Cloud Developers
Apr 5, 2023 · Backend Development

Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas

This article examines frequent mistakes when using Java thread pools—such as improper creation, unreasonable parameters, unreleased local pools, and unsafe concurrent operations—and provides detailed analysis, configuration guidelines, and best‑practice recommendations to prevent memory leaks, deadlocks, and performance issues.

Garbage CollectionJavaThreadPool
0 likes · 17 min read
Avoid Common ThreadPool Pitfalls in Java: Best Practices and Gotchas
21CTO
21CTO
Mar 31, 2023 · Backend Development

Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps

This article presents six practical Go performance optimizations—including GOMAXPROCS tuning for Kubernetes, struct field ordering, garbage‑collection limits, zero‑copy unsafe conversions, jsoniter usage, and sync.Pool pooling—that together can dramatically lower CPU, memory, and latency in production services.

Garbage CollectionGoKubernetes
0 likes · 9 min read
Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps
Selected Java Interview Questions
Selected Java Interview Questions
Mar 29, 2023 · Backend Development

JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node

This article presents a comprehensive, step‑by‑step guide on estimating capacity, selecting and configuring garbage collectors, sizing heap, young and survivor spaces, tuning thread stacks, and adding diagnostic options for a Java service that must handle one million login requests per day on a server with 8 GB of memory.

CMSG1Garbage Collection
0 likes · 26 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Java Backend Technology
Java Backend Technology
Mar 24, 2023 · Backend Development

Optimizing JVM Settings for 1M Daily Logins on an 8GB Server

This article walks through a step‑by‑step approach to sizing JVM heap, young generation, GC selection, and related parameters for a platform handling one million login requests per day on a node with 8 GB memory, providing practical formulas, example configurations, and tuning tips.

Garbage CollectionJVMJava
0 likes · 24 min read
Optimizing JVM Settings for 1M Daily Logins on an 8GB Server
Architect
Architect
Mar 18, 2023 · Backend Development

How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server

This article explains a step‑by‑step methodology for estimating capacity, selecting appropriate garbage collectors, sizing JVM memory regions, and tuning advanced parameters such as survivor ratio, tenuring threshold, and Metaspace to reliably support a login service that processes one million requests per day on a machine with 8 GB of RAM.

Garbage CollectionJVMJava
0 likes · 25 min read
How to Configure JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
JD Tech
JD Tech
Mar 16, 2023 · Fundamentals

A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC

This article explains the fundamentals of Java garbage collection, detailing classic algorithms such as reference counting, reachability analysis, mark‑sweep, copying, mark‑compact, and generational collectors, then introduces modern collectors like Serial, Parallel, CMS, G1, and the low‑latency ZGC, highlighting their mechanisms, advantages, and drawbacks.

Garbage CollectionJVMMemory Management
0 likes · 27 min read
A Comprehensive Overview of Java Garbage Collection Algorithms and ZGC
Ctrip Technology
Ctrip Technology
Mar 9, 2023 · Backend Development

Optimizing Hotel Query Service Memory Usage: GC Tuning, Native Memory Management, and Migration to jemalloc

This article details the systematic reduction of memory consumption for Ctrip's hotel query service by halving container memory, evaluating and tuning modern garbage collectors, diagnosing off‑heap leaks, and ultimately replacing the default ptmalloc allocator with jemalloc to achieve stable performance and lower resource costs.

Backend PerformanceContainerizationGarbage Collection
0 likes · 22 min read
Optimizing Hotel Query Service Memory Usage: GC Tuning, Native Memory Management, and Migration to jemalloc
Top Architect
Top Architect
Mar 8, 2023 · Backend Development

JVM Parameter Tuning for a Service Handling 10 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap, young generation, GC algorithm, Metaspace, and safety‑point settings—for a high‑traffic login service that receives one million requests per day on a server with 8 GB of memory, providing both practical code examples and interview‑style explanations.

Garbage CollectionJVMJava
0 likes · 25 min read
JVM Parameter Tuning for a Service Handling 10 Million Daily Login Requests on an 8 GB Node
Selected Java Interview Questions
Selected Java Interview Questions
Mar 5, 2023 · Backend Development

JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node

This article walks through a systematic approach to sizing and configuring JVM memory and garbage‑collector parameters for a service handling one million login requests per day on an 8 GB server, covering capacity planning, GC selection, heap region sizing, thread‑stack settings, dynamic age thresholds, large‑object handling, and diagnostic options such as heap dumps and GC logging.

Garbage CollectionJVMJava
0 likes · 23 min read
JVM Parameter Tuning for a Platform with 1 Million Daily Login Requests on an 8 GB Node
vivo Internet Technology
vivo Internet Technology
Feb 22, 2023 · Backend Development

Game Recommendation System: Architecture, Models, Scaling, and Operational Practices

The article details the design, evolution, and operational practices of Vivo’s large‑scale game recommendation platform, covering its initial rule‑based model, layered strategy framework, multi‑level caching, GC tuning, rate‑limiting, fine‑grained A/B testing, multi‑path recall, dynamic exposure control, and future intelligent extensions.

A/B testingBackend ArchitectureGarbage Collection
0 likes · 17 min read
Game Recommendation System: Architecture, Models, Scaling, and Operational Practices
ByteDance SYS Tech
ByteDance SYS Tech
Feb 16, 2023 · Fundamentals

Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism

This article dives deep into the OpenJDK G1 FullGC implementation, explaining its architecture, trigger conditions, preparation steps, and the four‑phase collection process while comparing single‑threaded and multi‑threaded implementations in JDK 8 and JDK 11, and highlighting code paths that can cause long GC pauses.

FullGCGarbage CollectionJava
0 likes · 18 min read
Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism