Skip to content
Tagged articles

garbage collection

500 articles · Page 2 of 5
Test Development Learning Exchange
Test Development Learning Exchange
Dec 29, 2024 · Fundamentals

Understanding Python's del Statement and Garbage Collection

This article explains how Python's del statement removes variable references, how the interpreter's garbage collection mechanisms reclaim memory—including reference counting and cyclic‑reference detection—and provides multiple code examples demonstrating proper resource cleanup in automated testing scenarios.

code-examplesdelgarbage collection
0 likes · 7 min read
Understanding Python's del Statement and Garbage Collection
Sohu Tech Products
Sohu Tech Products
Dec 25, 2024 · Mobile Development

Why BuildContext Leaks Memory in Flutter and How to Prevent It

This article explains how BuildContext and various closure patterns in Flutter can cause memory leaks, demonstrates typical leak scenarios with code examples, and provides practical strategies such as disposing listeners, nullifying references, and using WeakReference or Finalizer to ensure proper garbage collection.

AnimationControllerBuildContextDart
0 likes · 10 min read
Why BuildContext Leaks Memory in Flutter and How to Prevent It
Top Architecture Tech Stack
Top Architecture Tech Stack
Dec 23, 2024 · Backend Development

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

This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.

JVMJavaPerformance Tuning
0 likes · 25 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Lobster Programming
Lobster Programming
Dec 5, 2024 · Fundamentals

How Does Java’s JVM Load Classes and Execute Code? A Deep Dive

This article explains how Java classes are loaded into the JVM, details the class loader’s parent‑delegation mechanism, and walks through the execution flow of a sample program, covering stack frames, heap allocation, dynamic linking, method area, program counter, native method stack, and garbage collection.

Class LoadingJVMJava
0 likes · 9 min read
How Does Java’s JVM Load Classes and Execute Code? A Deep Dive
Top Architect
Top Architect
Nov 22, 2024 · Backend Development

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

This article walks through a systematic approach to sizing and configuring JVM parameters—including heap size, young generation, GC algorithm selection, and advanced options—for a high‑traffic login service that processes one million requests per day on a server with 8 GB of memory, while explaining the underlying performance‑analysis methodology.

JVMJavaPerformance Tuning
0 likes · 27 min read
JVM Parameter Tuning for a Platform Handling 1 Million Daily Login Requests on an 8 GB Node
Java Architecture Stack
Java Architecture Stack
Nov 18, 2024 · Fundamentals

Inside Go’s Runtime: How mcache and mheap Manage Memory

This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.

ConcurrencyGoRuntime
0 likes · 12 min read
Inside Go’s Runtime: How mcache and mheap Manage Memory
Architect
Architect
Nov 14, 2024 · Backend Development

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

This article explains, step by step, how to estimate capacity, choose the appropriate garbage collector, size the young and old generations, configure stack memory, adjust object aging thresholds, and fine‑tune CMS or G1 settings so that a Java service handling one million daily logins can run reliably on an 8 GB node.

BackendJVMJava
0 likes · 24 min read
How to Set JVM Parameters for a Platform Handling 1 Million Daily Login Requests on an 8 GB Server
Su San Talks Tech
Su San Talks Tech
Nov 7, 2024 · Backend Development

Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems

This article explains how to analyze per‑second object memory usage in a 100k TPS e‑commerce order flow, choose an appropriate garbage collector, set heap and young‑generation sizes, and apply common JVM tuning parameters to reduce Full GC pauses and improve latency and throughput.

JVMJavagarbage collection
0 likes · 6 min read
Optimizing JVM GC for High‑Throughput E‑Commerce Order Systems
DaTaobao Tech
DaTaobao Tech
Oct 28, 2024 · Fundamentals

Garbage Collection Algorithms and Reference Counting in QuickJS

QuickJS manages memory using reference counting for each object combined with a cycle‑collector that periodically scans roots, decrements child references, and frees objects whose counts drop to zero, while also supporting traditional reachability‑based garbage‑collection techniques such as mark‑sweep, copying, and generational collection.

AlgorithmC++JavaScript
0 likes · 9 min read
Garbage Collection Algorithms and Reference Counting in QuickJS
Cognitive Technology Team
Cognitive Technology Team
Oct 23, 2024 · Fundamentals

Overview of Garbage Collection Algorithms and JVM Garbage Collectors

This article provides a comprehensive overview of garbage collection techniques, covering reference counting, reachability analysis, generational management, copy, mark‑sweep, and mark‑compact algorithms, and explains the JVM's serial, parallel, CMS, and G1 collectors along with their operational characteristics and trade‑offs.

Copy AlgorithmG1Generational GC
0 likes · 9 min read
Overview of Garbage Collection Algorithms and JVM Garbage Collectors
MaGe Linux Operations
MaGe Linux Operations
Oct 8, 2024 · Backend Development

Master Java JVM Tuning: Key Commands, GC Options & Reference Types

This article explains how to launch Java processes from the command line, explores JVM -X and -XX tuning parameters, details garbage‑collection algorithms, describes reference strengths, and clarifies object reachability to help developers optimize Java application performance.

JVMJavaReference Types
0 likes · 13 min read
Master Java JVM Tuning: Key Commands, GC Options & Reference Types
BirdNest Tech Talk
BirdNest Tech Talk
Oct 4, 2024 · Fundamentals

How Go’s New unique Package Enables Efficient Interning and Memory Savings

Go 1.23 introduces the unique package, which provides generic interning for comparable values, allowing canonicalization of strings and structs, reducing memory usage and speeding up equality checks; the article walks through a simple map‑based implementation, its limitations, the advanced Handle[T] design, real‑world netip usage, and future prospects.

Memory Optimizationcanonicalizationgarbage collection
0 likes · 10 min read
How Go’s New unique Package Enables Efficient Interning and Memory Savings
Code Mala Tang
Code Mala Tang
Sep 30, 2024 · Backend Development

Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks

This article explains how Node.js manages memory, details V8's garbage‑collection mechanisms, shows how to monitor heap usage, demonstrates techniques for increasing allocation limits, and provides practical code samples and third‑party tools for detecting and fixing memory leaks in production environments.

Memory LeaksNode.jsgarbage collection
0 likes · 20 min read
Mastering Node.js Memory: Optimize Heap, GC, and Prevent Leaks
FunTester
FunTester
Sep 30, 2024 · Backend Development

Unlock Java Performance: Essential Profiling Techniques and Tools

This guide introduces Java performance analysis fundamentals, covering profiling tools, key metrics such as CPU, memory, thread behavior, and practical methods to detect and resolve common issues like memory leaks, GC pauses, high CPU usage, I/O bottlenecks, and inefficient collection usage.

CPU analysisJavaMemory Leak
0 likes · 13 min read
Unlock Java Performance: Essential Profiling Techniques and Tools
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 27, 2024 · Backend Development

Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example

This article explains why JVM tuning is essential for performance, outlines a step‑by‑step optimization workflow—including GC monitoring, heap dumps, parameter tuning, and tool usage—provides a concrete Java code example that triggers memory pressure, and shares effective JVM flags to prevent out‑of‑memory errors.

JVMJavabackend development
0 likes · 7 min read
Master JVM Tuning: Practical Steps, Tools, and Real-World Code Example
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 6, 2024 · Fundamentals

Understanding Java Garbage Collection Algorithms and Their Use Cases

This article provides a comprehensive overview of Java garbage collection, covering the principles of reference counting and reachability analysis, detailing major GC algorithms such as mark‑sweep, copying, and mark‑compact, explaining object allocation strategies, and reviewing traditional and modern collectors like Serial, CMS, and G1, with practical tuning tips for each.

GC algorithmsJVMgarbage collection
0 likes · 19 min read
Understanding Java Garbage Collection Algorithms and Their Use Cases
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 23, 2024 · Backend Development

Upgrading to JDK 21 and Adopting Generational ZGC: Motivation, Design, Implementation, Monitoring, and Performance Evaluation

This article explains why the backend services were upgraded from JDK 8 to JDK 21, introduces the generational ZGC garbage collector, details its architecture, tuning parameters, integration steps, monitoring setup, and presents performance test results that demonstrate reduced allocation stalls, lower latency, higher throughput, and near‑zero GC pauses.

BackendGenerational ZGCJDK21
0 likes · 20 min read
Upgrading to JDK 21 and Adopting Generational ZGC: Motivation, Design, Implementation, Monitoring, and Performance Evaluation
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 23, 2024 · Fundamentals

Understanding JVM Memory Structure and Object Lifecycle

This article explains the JVM memory architecture—including heap, stack, native stack, method area, and program counter—detailing heap generations, object allocation strategies, object layout, reference types, and the complete lifecycle of Java objects from creation to garbage collection.

JVMObject Lifecyclegarbage collection
0 likes · 11 min read
Understanding JVM Memory Structure and Object Lifecycle
Radish, Keep Going!
Radish, Keep Going!
Aug 7, 2024 · Backend Development

Boost Go Performance: Mastering GC with go trace, GOGC & GOMEMLIMIT

This article demonstrates how to analyze and optimize Go's garbage collection using go trace, comparing single‑threaded and concurrent implementations, and shows how tuning GOGC and GOMEMLIMIT can dramatically improve runtime and memory usage, with detailed code samples and performance metrics.

GOGCGOMEMLIMITGo
0 likes · 13 min read
Boost Go Performance: Mastering GC with go trace, GOGC & GOMEMLIMIT
JD Retail Technology
JD Retail Technology
Aug 2, 2024 · Operations

JVM Memory Model, Garbage Collection, and Optimization Guide

This article explains the JVM memory architecture, object lifecycle, young and old generation garbage‑collection mechanisms, tuning goals such as low latency, high throughput and large heap, and provides practical advice on monitoring, common memory‑related problems, and choosing appropriate collectors for different application scenarios.

JVMJavaPerformance Tuning
0 likes · 17 min read
JVM Memory Model, Garbage Collection, and Optimization Guide
Radish, Keep Going!
Radish, Keep Going!
Jul 25, 2024 · Backend Development

How to Slash Go GC Overhead on Large Heaps: Techniques and Code

This article examines why Go's garbage collector can become a CPU bottleneck with large heaps, demonstrates the performance impact with benchmark programs, and presents practical strategies—such as using pointer‑free allocations, mmap‑backed memory, and string interning—to dramatically reduce GC pause times.

GoLarge heapUnsafe
0 likes · 13 min read
How to Slash Go GC Overhead on Large Heaps: Techniques and Code
JavaEdge
JavaEdge
Jul 8, 2024 · Backend Development

Master Java Metaspace: Tuning Metadata GC Threshold and JVM Flags

This article explains Java Metaspace and metadata GC thresholds, compares PermGen with Metaspace, and provides detailed JVM flag configurations—including size settings and compressed pointer options—to help developers optimize memory usage and garbage‑collection performance.

JavaPerformance Tuninggarbage collection
0 likes · 8 min read
Master Java Metaspace: Tuning Metadata GC Threshold and JVM Flags
High Availability Architecture
High Availability Architecture
Jun 27, 2024 · Backend Development

Understanding and Tuning Z Garbage Collector (ZGC) for Low‑Latency Java Applications

This article explains the principles, features, and workflow of Java's Z Garbage Collector, provides detailed configuration and logging guidance, and shares AutoMQ's practical tuning experiences that achieve sub‑millisecond pause times and improved performance for latency‑sensitive backend services.

AutoMQJavaPerformance Tuning
0 likes · 26 min read
Understanding and Tuning Z Garbage Collector (ZGC) for Low‑Latency Java Applications
JD Cloud Developers
JD Cloud Developers
Jun 26, 2024 · Backend Development

Understanding Java Heap Memory: Prevent OutOfMemory Errors and Optimize GC

This article explains Java heap memory concepts, garbage collection, common memory issues like leaks and OutOfMemoryError, and outlines the team's quality assurance framework—including left‑shift code review, right‑shift monitoring, and continuous delivery practices—to help prevent and resolve production alerts.

JavaOutOfMemoryErrorgarbage collection
0 likes · 10 min read
Understanding Java Heap Memory: Prevent OutOfMemory Errors and Optimize GC
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 26, 2024 · Fundamentals

Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors

This article provides a comprehensive overview of Java's G1 and ZGC garbage collectors, explaining their memory layout, internal structures such as regions, card tables, and RSet, detailing Young and Mixed GC processes, three‑color marking, SATB, incremental updates, and the low‑pause design of ZGC.

G1JVMZGC
0 likes · 30 min read
Mastering Java G1 and ZGC: Deep Dive into Modern Garbage Collectors
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.

I/O multiplexingJavaReflection
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.

JVMJavaPhantomReference
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.

FinalReferenceFinalizerThreadJVM
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.

JVMReference PolicySoftReference
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.

JavaPerformance TuningZGC
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.

JVMJavagarbage collection
0 likes · 4 min read
Understanding Garbage Collection in the JVM
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 algorithmsResource Utilizationgarbage collection
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.

JavaSATBSTW
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 algorithmsGenerational GCMark‑Sweep
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.

DirectByteBufferJVMJava
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.

JVMPerformance Tuninggarbage collection
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.

Operationsdisk cleanupgarbage collection
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.

JITJVMZingJDK
0 likes · 17 min read
Technical Overview of ZingJDK: ReadyNow, Falcon JIT, and C4 GC
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.

JVMJavaMemory Leak
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 algorithmsVM
0 likes · 33 min read
Understanding Dart VM Garbage Collection and Memory Management
政采云技术
政采云技术
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.

JDKJMHJava
0 likes · 23 min read
Java JDK 12‑17 New Features and Enhancements Overview
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.

NAND flashNVMeSSD
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.

ClassesInheritanceOOP
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.

JVMJavagarbage collection
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.

Pythongarbage collectionmemory management
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.

JDK11Module Systemgarbage collection
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.

GoHeapgarbage collection
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.

ConcurrencyContextGo
0 likes · 30 min read
Unlocking Go’s Secrets: nil, context, slices, maps, and concurrency primitives
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.

NVMeSSDSoftware
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.

Heap DumpJavaVisualVM
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.

ConcurrencyJavaMemory 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.

G1 GCJVMJava
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 PracticesJavaMemory Leak
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.

BNFScripting LanguageSyntax Parsing
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.

JVMJavagarbage collection
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.

JVMJavaRuntime
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.

JavaUpgradegarbage collection
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.

ConcurrencyJVMZGC
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.

DockerJVMgarbage collection
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.

Generational GCJVMRuntime
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.

JVM OptimizationPerformance Tuningbackend development
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.

JVMJavaMemory Layout
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.

BackendGC tuningJDK
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.

BackendJVMJava
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.

BackendFull GCJVM
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.

Generational GCJVMJava
0 likes · 8 min read
Understanding Automatic Garbage Collection and Generational GC in Java