Skip to content
Tagged articles

garbage collection

500 articles · Page 5 of 5
Python Programming Learning Circle
Python Programming Learning Circle
Jun 3, 2020 · Fundamentals

Understanding CPython's Memory Management (Python 2.7)

This article explains how CPython implements its own memory‑management scheme—including the layered allocation model, pool and arena structures, block size classes, and reference‑count‑based reclamation—by dissecting the source code of Python 2.7’s obmalloc module.

CPythonObmallocgarbage collection
0 likes · 23 min read
Understanding CPython's Memory Management (Python 2.7)
Programmer DD
Programmer DD
May 22, 2020 · Backend Development

Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?

This article explains the design goals, architecture, key features, tuning options, and version history of Java's Z Garbage Collector (ZGC), highlighting its sub‑10 ms pause times for terabyte‑scale heaps, its use of colored pointers and load barriers, and the trade‑offs in throughput and configuration.

JVMJavaZGC
0 likes · 16 min read
Can ZGC Deliver Sub‑10ms Pauses for Massive Java Heaps?
Java Captain
Java Captain
May 20, 2020 · Fundamentals

Why Setting Unused Objects to null May Not Help Java Garbage Collection

This article explains, with concrete Java examples and JVM runtime‑stack analysis, why manually assigning null to objects that are out of scope does not always trigger earlier garbage collection, and how stack slot reuse can achieve the same effect without relying on a questionable practice.

JVMJavaRuntime Stack
0 likes · 8 min read
Why Setting Unused Objects to null May Not Help Java Garbage Collection
Java Captain
Java Captain
May 16, 2020 · Fundamentals

Deep Dive into Java ThreadLocal: Data Structure, Hash Algorithm, Cleanup, and Usage

This article provides an in‑depth analysis of Java’s ThreadLocal mechanism, covering its weak‑reference key, internal ThreadLocalMap structure, hash algorithm, collision resolution, cleanup strategies, expansion logic, source code walkthroughs, and practical usage scenarios such as trace‑ID propagation in distributed systems.

Distributed TracingJavaThreadLocal
0 likes · 27 min read
Deep Dive into Java ThreadLocal: Data Structure, Hash Algorithm, Cleanup, and Usage
Java Architect Essentials
Java Architect Essentials
Apr 17, 2020 · Fundamentals

Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization

This article provides an extensive overview of Java Virtual Machine fundamentals for interview preparation, covering JVM components, runtime data areas, heap vs. stack memory, garbage collection mechanisms, algorithms, collectors, memory allocation strategies, class loading processes, and tuning tools.

Class LoadingJVMPerformance Tuning
0 likes · 31 min read
Comprehensive Java JVM Interview Guide: Architecture, Memory, GC, Class Loading, and Optimization
Sohu Tech Products
Sohu Tech Products
Apr 8, 2020 · Fundamentals

Design and Implementation of Go's Garbage Collector

This article provides an in‑depth overview of Go's garbage collector, covering its design principles, mark‑sweep algorithm, tri‑color abstraction, write‑barrier techniques, incremental and concurrent collection, evolution across Go versions, and detailed implementation details of marking, sweeping, and memory reclamation.

garbage collectionmemory management
0 likes · 52 min read
Design and Implementation of Go's Garbage Collector
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.

JVMJavaPerformance Tuning
0 likes · 10 min read
JVM Memory Model, GC Log Analysis, and Production Parameter Optimization
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.

Heap DumpJVMJava
0 likes · 9 min read
Mastering JVM Performance: 6 Essential Parameters and GC Tuning Tips
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.

HotSpotJVMJava
0 likes · 14 min read
How to Pick the Best Java HotSpot GC: Serial, Parallel, CMS, G1 & ZGC
Python Programming Learning Circle
Python Programming Learning Circle
Mar 27, 2020 · Fundamentals

Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection

Python abstracts memory management through reference counting, handles cyclic references with a generational garbage collector, and employs the weak generational hypothesis to efficiently reclaim objects, as illustrated by code examples demonstrating object creation, deletion, and the behavior of different GC generations.

Generational GCReference Countinggarbage collection
0 likes · 8 min read
Understanding Python Memory Management: Reference Counting, Circular References, and Generational Garbage Collection
Programmer DD
Programmer DD
Mar 19, 2020 · Fundamentals

What’s New in JDK 14? 16 Game‑Changing Features You Need to Know

On March 17, JDK 14 was officially released, bringing 16 new JEPs—including pattern‑matching for instanceof, a new packaging tool, enhanced G1 memory allocation, JFR event streaming, helpful NullPointerExceptions, records, switch expressions, ZGC on macOS/Windows, and a second preview of Text Blocks—significantly expanding Java’s core capabilities.

JDK 14JEPJava
0 likes · 6 min read
What’s New in JDK 14? 16 Game‑Changing Features You Need to Know
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.

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

JVMJavaPerformance Tuning
0 likes · 31 min read
Mastering Java Garbage Collection: Algorithms, Regions, and Tuning Tips
Selected Java Interview Questions
Selected Java Interview Questions
Mar 2, 2020 · Fundamentals

Understanding Java Reference Types: SoftReference, WeakReference, and PhantomReference Implementation Details

This article explains Java's four reference types, focusing on the implementation and lifecycle of SoftReference, WeakReference, and PhantomReference, and clarifies how garbage collection policies, native and Java layers, and reference queues determine when these references are cleared or notified.

JavaPhantomReferenceSoftReference
0 likes · 14 min read
Understanding Java Reference Types: SoftReference, WeakReference, and PhantomReference Implementation Details
Architect's Tech Stack
Architect's Tech Stack
Feb 23, 2020 · Fundamentals

Top 5 New Features Expected in Java 14

This article outlines the five major preview features slated for Java 14, including instanceof pattern matching, text blocks with new escape sequences, record types, the incubating jpackage tool, and the deprecation of the ParallelScavenge + SerialOld garbage collector combination.

Text Blocksgarbage collectionjava14
0 likes · 9 min read
Top 5 New Features Expected in Java 14
Programmer DD
Programmer DD
Feb 23, 2020 · Backend Development

How to Replace the Deprecated CMS GC in JDK 9?

This article explains why the CMS garbage collector was removed in JDK 9, shows the deprecation warning, and evaluates three migration paths—switching to G1 GC, adopting ZGC, or continuing with CMS—helping developers choose the best option for their applications.

CMS GCG1 GCJDK9
0 likes · 5 min read
How to Replace the Deprecated CMS GC in JDK 9?
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Jan 22, 2020 · Fundamentals

Understanding the Flash‑Friendly File System (F2FS): Design, Implementation, and Future Directions

F2FS is a log‑structured, flash‑aware file system that transforms random writes into sequential ones, uses segment‑based layout, NAT indexing, and hot‑cold data segregation with sophisticated garbage‑collection to improve SSD performance, and is now deployed in Android devices with ongoing enhancements such as online resizing and cold‑data compression.

F2FSStorage Managementfile-system
0 likes · 17 min read
Understanding the Flash‑Friendly File System (F2FS): Design, Implementation, and Future Directions
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.

HeapJVMgarbage collection
0 likes · 16 min read
JVM Memory Architecture: Overview, Heap, Metaspace, Stack, and More
Efficient Ops
Efficient Ops
Jan 16, 2020 · Operations

Mastering WAS Memory Overflow: Elegant Strategies for Resolution

This article explains IBM WebSphere Application Server's memory architecture, common causes of Java OutOfMemoryError in WAS, and provides a step‑by‑step guide—including log collection, heap analysis, and preventive measures—to diagnose, resolve, and avoid memory overflow incidents in production environments.

OperationsWASgarbage collection
0 likes · 16 min read
Mastering WAS Memory Overflow: Elegant Strategies for Resolution
Tencent Cloud Middleware
Tencent Cloud Middleware
Jan 3, 2020 · Fundamentals

Why Reference Counting Fails: Understanding GC, Memory Leaks, and Circular References

This article explains the origins of garbage collection, illustrates common memory‑management pitfalls with C‑style malloc/free examples, introduces reference‑counting fundamentals, shows how cyclic references break the algorithm, and compares programmer‑assisted versus runtime solutions while highlighting their trade‑offs.

Automatic Memory ManagementCyclic ReferencesJava
0 likes · 16 min read
Why Reference Counting Fails: Understanding GC, Memory Leaks, and Circular References
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.

JVMJavaMemory Leak
0 likes · 10 min read
Diagnosing Java Memory Leaks: JVM GC Roots, Monitoring, and Code Fixes
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.

JVMJavaReachability Analysis
0 likes · 6 min read
Understanding Object Liveness Determination in Java: Reference Counting and Reachability Analysis
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 27, 2019 · Backend Development

Why Does Your Java App Freeze? Uncover Full GC Causes and Fixes

Discover why Java applications suddenly freeze due to full garbage collection, explore common GC triggers and memory‑leak scenarios, and learn practical strategies—such as eliminating leaks, applying concurrency limits, adaptive rate‑limiting, and traffic monitoring—to keep your backend services stable.

BackendFull GCJava
0 likes · 8 min read
Why Does Your Java App Freeze? Uncover Full GC Causes and Fixes
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.

Generational GCJVMReachability Analysis
0 likes · 8 min read
How the JVM Determines Object Liveness and Its Garbage Collection Algorithms
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 algorithmsInterview PreparationJVM
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.

JVMJavaRuntime
0 likes · 9 min read
Master JVM Memory Structure: A Deep Dive into Java’s Runtime Architecture
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 algorithmsJVMJava
0 likes · 14 min read
Mastering JVM Memory: Models, GC Algorithms, and Optimization Tips
Tech Musings
Tech Musings
Oct 25, 2019 · Backend Development

Choosing the Right Java Garbage Collector: A Practical Guide for JDK 1.8

This article explains the seven Java garbage collectors available up to JDK 1.8, compares their strengths and weaknesses, and shows how to select and tune the appropriate collector—Serial, Parallel, CMS, or G1—based on application characteristics and deployment environments.

CMSG1JDK
0 likes · 11 min read
Choosing the Right Java Garbage Collector: A Practical Guide for JDK 1.8
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.

JVMJavagarbage collection
0 likes · 9 min read
Unlocking Java: A Deep Dive into JVM Memory Architecture
Big Data Technology & Architecture
Big Data Technology & Architecture
Oct 13, 2019 · Backend Development

Practical Guide to Tuning the G1 Garbage Collector in Java

This article shares practical experience tuning Java's G1GC, including required JVM flags, key parameters such as G1NewSizePercent and InitiatingHeapOccupancyPercent, an automated script for systematic parameter adjustment, and tools for log analysis to achieve optimal garbage‑collection performance.

G1GCJVM tuningJava
0 likes · 4 min read
Practical Guide to Tuning the G1 Garbage Collector in Java
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 optimizationJVMPerformance Tuning
0 likes · 10 min read
How to Minimize Long GC Pauses in Java Applications
Meitu Technology
Meitu Technology
Aug 29, 2019 · Backend Development

Memory Optimization in Long Connection Services: A Three-Year Journey

Over three years, Meitu’s long‑connection service “bifrost,” built in Go with MQTT, cut memory use from 22.3 GB to 5.1 GB for 210 k connections—and about 10 GB for a million—by tuning buffers, reducing allocations, employing memory pools, and replacing a goroutine‑per‑connection model with an epoll‑driven event architecture.

GoLong ConnectionMQTT
0 likes · 13 min read
Memory Optimization in Long Connection Services: A Three-Year Journey
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.

G1JVMJava
0 likes · 29 min read
Java Memory Layout and Garbage Collection Principles
High Availability Architecture
High Availability Architecture
Aug 13, 2019 · Fundamentals

In‑Depth Study of Go’s Garbage Collection Algorithm and Its Evolution

This article provides a comprehensive analysis of Go’s non‑generational concurrent mark‑and‑sweep garbage collector, tracing its evolution from early stop‑the‑world implementations to the mixed write‑barrier design in Go 1.8, and explains how to interpret GC traces, tune GC parameters, and reduce latency caused by mark‑assist and STW pauses.

Concurrent Mark and SweepGoWrite Barrier
0 likes · 22 min read
In‑Depth Study of Go’s Garbage Collection Algorithm and Its Evolution
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.

Generational GCJVMJava
0 likes · 7 min read
Understanding Automatic Garbage Collection and Generational GC in the JVM
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.

InterviewJDKJRE
0 likes · 36 min read
Java Fundamentals: OOP Concepts, JVM/JDK/JRE, and Common Interview Topics
Node Underground
Node Underground
Jul 9, 2019 · Backend Development

Mastering Node.js Garbage Collection: Detect and Prevent Memory Leaks

This article explains how Node.js relies on the V8 engine for automatic memory management, details the garbage‑collection mechanisms (Scavenge, Mark‑Sweep, Mark‑Compact), shows practical code for monitoring and forcing GC, illustrates common memory‑leak patterns, and recommends tools for diagnosing and fixing leaks.

Memory LeakNode.jsV8
0 likes · 20 min read
Mastering Node.js Garbage Collection: Detect and Prevent Memory Leaks
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.

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

JVMPerformance Tuningdatabase optimization
0 likes · 20 min read
Making Java Applications Run Faster: Performance Tuning Tools and Practices
Architects' Tech Alliance
Architects' Tech Alliance
Feb 17, 2019 · Operations

Modeling SSD Garbage Collection as a Gambler's Ruin Problem: Probabilistic Analysis and Control Strategies

By drawing analogies between casino gambling and SSD garbage collection, the article uses probability theory, Brownian motion, and stochastic processes to model victim block selection, resource depletion, and I/O bandwidth fluctuations, proposing control strategies that balance performance stability and resource safety.

Performance ModelingSSDStochastic Processes
0 likes · 21 min read
Modeling SSD Garbage Collection as a Gambler's Ruin Problem: Probabilistic Analysis and Control Strategies
Programmer DD
Programmer DD
Jan 6, 2019 · Fundamentals

How to Detect and Prevent Java Memory Leaks: Real‑World Examples and Best Practices

This tutorial explains what Java memory leaks are, how they occur through static fields, unclosed resources, improper equals/hashCode, inner classes, finalizers, String interning, and ThreadLocal usage, and provides practical detection methods, profiling tools, and concrete prevention strategies to keep applications performant.

Best PracticesJavaMemory Leak
0 likes · 16 min read
How to Detect and Prevent Java Memory Leaks: Real‑World Examples and Best Practices
Programmer DD
Programmer DD
Dec 24, 2018 · Operations

Mastering Java CMS GC: How It Works, When It Triggers, and Tuning Tips

This comprehensive guide explains the purpose, lifecycle, trade‑offs, common issues, and performance‑tuning strategies of Java's Concurrent Mark‑Sweep (CMS) garbage collector, helping developers understand when it runs and how to configure it for low‑latency applications.

CMSJavaPerformance Tuning
0 likes · 15 min read
Mastering Java CMS GC: How It Works, When It Triggers, and Tuning Tips
Programmer DD
Programmer DD
Dec 20, 2018 · Fundamentals

Mastering G1 GC: Why It Exists, How It Works, and Tuning Tips

This article explains the origins, design goals, and detailed mechanisms of Java's G1 garbage collector—including regions, CSet, RSet, SATB, the full collection cycle, common pitfalls, and practical tuning recommendations—to help developers achieve predictable pause times and high throughput.

G1GCJavaPerformance Tuning
0 likes · 25 min read
Mastering G1 GC: Why It Exists, How It Works, and Tuning Tips
Java Captain
Java Captain
Dec 17, 2018 · Fundamentals

Understanding Java Heap and Stack Memory with Examples

This article explains the differences between Java heap and stack memory, their advantages and disadvantages, and demonstrates how string objects are stored and shared using code examples that illustrate memory allocation and reference behavior.

HeapJavaString
0 likes · 4 min read
Understanding Java Heap and Stack Memory with Examples
Java Backend Technology
Java Backend Technology
Dec 14, 2018 · Fundamentals

Why Does Your JVM Keep Objects Alive After Method Returns? A Memory & GC Deep Dive

This article investigates why objects allocated in a Java method are not immediately reclaimed after the method exits, demonstrating through experiments how JVM heap regions, especially the Eden space, influence garbage collection timing, and provides practical steps to control memory and CPU usage by deliberately allocating small and large objects.

JVMJavagarbage collection
0 likes · 8 min read
Why Does Your JVM Keep Objects Alive After Method Returns? A Memory & GC Deep Dive
Programmer DD
Programmer DD
Nov 13, 2018 · Backend Development

How to Detect and Prevent Java Memory Leaks: Real‑World Examples and Fixes

This tutorial explains what Java memory leaks are, why they occur, and how to identify them at runtime, covering common leak sources such as static fields, unclosed resources, faulty equals/hashCode implementations, inner classes, finalize methods, string interning, and ThreadLocal misuse, plus practical prevention techniques and profiling tools.

Best PracticesJavaMemory Leak
0 likes · 15 min read
How to Detect and Prevent Java Memory Leaks: Real‑World Examples and Fixes
Architects' Tech Alliance
Architects' Tech Alliance
Nov 2, 2018 · Industry Insights

Why NVMe SSD Performance Varies and How to Optimize It for Data Centers

NVMe SSD performance can be unpredictable, so this article opens the SSD "black box" to examine hardware, firmware, and workload factors—such as NAND type, multi‑queue design, garbage collection, and I/O patterns—and offers software‑level strategies to maximize flash efficiency in modern data‑center storage systems.

Flash MemoryIO PatternsNVMe
0 likes · 30 min read
Why NVMe SSD Performance Varies and How to Optimize It for Data Centers
Programmer DD
Programmer DD
Sep 19, 2018 · Backend Development

What’s New in JDK 11? Explore the Latest Java Features and Improvements

This article outlines the Java Community Process’s shift to a six‑month release cadence, explains the Release Candidate stage, and details JDK 11’s most notable enhancements—including ZGC, Epsilon, var extensions, removal of Java EE/CORBA modules, and a revamped HTTP client—providing developers with a concise overview of the new runtime capabilities.

HTTP ClientJDK 11Java
0 likes · 6 min read
What’s New in JDK 11? Explore the Latest Java Features and Improvements
Java Architect Essentials
Java Architect Essentials
Aug 15, 2018 · Fundamentals

Java 11 Upcoming Features and Their Differences from Java 9 and 10

The article outlines the scheduled Java 11 release, detailing four major JEP proposals—including local‑variable syntax for lambda parameters, the low‑overhead Epsilon garbage collector, dynamic class‑file constants, and removal of Java EE/CORBA modules—while also discussing the shift to a faster release cycle and long‑term support model.

JEPJava11LTS
0 likes · 6 min read
Java 11 Upcoming Features and Their Differences from Java 9 and 10
Programmer DD
Programmer DD
Apr 24, 2018 · Backend Development

Demystifying G1 GC: How Java’s Modern Collector Manages Heap Regions

This article walks through the G1 garbage collector’s heap structure, region‑based allocation, young‑generation collection steps, and the detailed phases of old‑generation collection, providing clear diagrams and practical insights for Java developers.

G1 GCHeap RegionsJava
0 likes · 9 min read
Demystifying G1 GC: How Java’s Modern Collector Manages Heap Regions
21CTO
21CTO
Mar 22, 2018 · Fundamentals

What’s New in Java 10? Top 10 Features You Need to Know

This article reviews Java 10’s major enhancements—including local‑variable type inference, time‑based release cadence, new garbage‑collector interfaces, parallel G1 GC, heap‑allocation on alternative memory devices, repository consolidation, default root certificates, experimental Graal JIT, ThreadLocal handshakes, and removal of the javah tool—highlighting their impact for developers.

JDK 10JEPJava
0 likes · 9 min read
What’s New in Java 10? Top 10 Features You Need to Know
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 8, 2018 · Fundamentals

Understanding Java Reference Types and JVM Memory Management

This article explains Java's four reference types, the JVM's memory layout, object lifecycle states, common garbage‑collection algorithms, collector implementations, heap segmentation, class‑loading mechanics, and includes typical interview questions to help developers master memory management in Java.

HeapJVMgarbage collection
0 likes · 15 min read
Understanding Java Reference Types and JVM Memory Management
Architect's Tech Stack
Architect's Tech Stack
Mar 8, 2018 · Fundamentals

JDK 10 Release Date, Download Links, and Major New Features

The article explains that JDK 10 was released on March 20 2018, describes how to obtain it via the early‑access program, and details its key innovations such as local‑variable type inference, a clean garbage‑collector interface, G1 parallelization, repository consolidation, and several proposed enhancements.

JDK10JEPJava
0 likes · 11 min read
JDK 10 Release Date, Download Links, and Major New Features
Java Architect Essentials
Java Architect Essentials
Mar 8, 2018 · Fundamentals

Understanding Java Garbage Collection: Young Generation, Old Generation, and Permanent Generation

This article explains Java's garbage collection mechanisms, detailing the roles and algorithms of the young generation (copying algorithm), old generation (mark‑sweep and mark‑compact), and permanent generation, along with object promotion criteria, efficiency comparisons, and memory utilization considerations.

AlgorithmsJVMgarbage collection
0 likes · 5 min read
Understanding Java Garbage Collection: Young Generation, Old Generation, and Permanent Generation
Java Captain
Java Captain
Feb 6, 2018 · Backend Development

Will JVM Garbage Collector Reclaim Long-Unused Singleton Objects?

This article investigates whether the JVM garbage collector can reclaim singleton instances that remain unused for extended periods, presenting a test program, analyzing GC logs, and explaining the GC root mechanism that keeps static singleton references alive, concluding that HotSpot 1.6 does not collect such objects.

HotSpotJVMJava
0 likes · 6 min read
Will JVM Garbage Collector Reclaim Long-Unused Singleton Objects?
Java Captain
Java Captain
Jan 27, 2018 · Fundamentals

Key Java Interview Questions and Answers (2017 Edition)

This article compiles essential Java interview questions covering topics such as switch statements, equality operators, object methods, reference types, hashCode, string handling, overriding, abstract classes, XML parsing, thread control, memory layout, polymorphism, garbage collection, and collections, providing concise explanations to help job seekers prepare effectively.

InterviewJavaMemory
0 likes · 16 min read
Key Java Interview Questions and Answers (2017 Edition)
Java Captain
Java Captain
Jan 3, 2018 · Fundamentals

Overview of Java Garbage Collection and Memory Management

This article provides a comprehensive overview of Java's garbage collection mechanism, memory regions, object access methods, allocation strategies, GC algorithms, and the various collectors used in the HotSpot JVM, helping developers understand and optimize Java memory usage.

GC algorithmsJVMgarbage collection
0 likes · 22 min read
Overview of Java Garbage Collection and Memory Management
Meituan Technology Team
Meituan Technology Team
Dec 28, 2017 · Backend Development

Java Garbage Collection Optimization Strategies and Case Studies

When all other tuning options fail, this article guides Java developers through a systematic GC optimization process—covering essential concepts, a goal‑oriented workflow, and three real‑world case studies that illustrate adjusting generation sizes, employing CMS flags, and fixing PermGen to dramatically reduce pause times and latency.

JVMJavaPerformance Tuning
0 likes · 21 min read
Java Garbage Collection Optimization Strategies and Case Studies
Java Captain
Java Captain
Dec 14, 2017 · Fundamentals

Understanding Java Garbage Collection Mechanisms and Algorithms

Java's garbage collection mechanism, introduced to simplify memory management, employs various algorithms such as reference counting, tracing (mark‑and‑sweep), compacting, copying, and generational collection, each with distinct advantages, drawbacks, and implementation details, while also addressing common memory‑leak pitfalls.

AlgorithmsGenerational GCgarbage collection
0 likes · 10 min read
Understanding Java Garbage Collection Mechanisms and Algorithms
MaGe Linux Operations
MaGe Linux Operations
Sep 15, 2017 · Fundamentals

Master Python OOP: Classes, Inheritance, and Object Lifecycle Explained

This article introduces Python's object‑oriented programming fundamentals, covering class definitions, class and instance variables, the __init__ constructor, the role of self, inheritance, method overriding, built‑in class attributes, garbage collection, and private members, complemented by illustrative code snippets.

ClassesInheritanceOOP
0 likes · 9 min read
Master Python OOP: Classes, Inheritance, and Object Lifecycle Explained
21CTO
21CTO
Sep 1, 2017 · Fundamentals

Is Go’s 10ms GC Pause Claim Real? A Deep Dive into GC Theory and Trade‑offs

This article critically examines Go’s advertised sub‑10 ms garbage‑collection pauses, compares its concurrent mark‑sweep collector with Java’s GC algorithms, and explores the fundamental trade‑offs of throughput, pause time, memory overhead, and scalability that shape modern garbage‑collector design.

Generational GCGoJava
0 likes · 18 min read
Is Go’s 10ms GC Pause Claim Real? A Deep Dive into GC Theory and Trade‑offs
Baidu Intelligent Testing
Baidu Intelligent Testing
Sep 1, 2017 · Fundamentals

Understanding Python Garbage Collection and Memory Leaks

This article explains Python's garbage collection mechanisms, demonstrates how reference counting works, shows how to detect and fix memory leaks using the gc module, and illustrates the issue with urllib2 through code examples and visual diagrams.

PythonReference Countinggarbage collection
0 likes · 5 min read
Understanding Python Garbage Collection and Memory Leaks
Hujiang Technology
Hujiang Technology
Jul 18, 2017 · Fundamentals

A Crash Course in Memory Management: ArrayBuffer, SharedArrayBuffer, and Manual vs Automatic Management in JavaScript

This article explains the fundamentals of memory management, illustrating why ArrayBuffer and SharedArrayBuffer were added to JavaScript, how automatic garbage collection works, and what manual memory handling with functions like malloc and free entails, especially when using WebAssembly and C.

ArrayBufferJavaScriptWebAssembly
0 likes · 6 min read
A Crash Course in Memory Management: ArrayBuffer, SharedArrayBuffer, and Manual vs Automatic Management in JavaScript