Tagged articles
lazy initialization
30 articles · Page 1 of 1
The author traces a 6-second Java service startup delay to eager initialization of large objects via static final fields, demonstrates how Java 27's LazyConstant API enables thread-safe, one-time lazy initialization with constant semantics, and explains when to use it versus Spring @Lazy, caches, or double-checked locking.
JEP 531Java 27Kubernetes scaling
0 likes · 19 min read

This article walks through seven concrete Spring Boot startup optimizations—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration slimming, class‑loading reduction, delayed database connections, and AOT/native compilation—showing real‑world benchmarks that cut launch times by around 70%.
AOTAuto-configurationJVM tuning
0 likes · 9 min read

The article explains that Spring's @Lazy annotation has two distinct mechanisms—class‑level lazy bean creation and dependency‑level proxy placeholders—detailing how each works, when to apply them, common pitfalls such as transaction and aspect failures, and best‑practice scenarios for reducing startup time while safely handling circular dependencies.
@LazyBean ProxyCircular Dependency
0 likes · 12 min read

This article walks through the complete Spring Bean lifecycle—covering scanning, instantiation, dependency injection, initialization, AOP proxy creation, and destruction—while highlighting common pitfalls, the differences for prototype and lazy‑loaded beans, and practical debugging tips.
AOPBean LifecyclePrototype Bean
0 likes · 10 min read


liandkJun 13, 2026 · Fundamentals
The article explains the Singleton pattern—ensuring a class has only one global instance—to save resources and avoid conflicts, illustrates two Java implementations (eager and lazy), and lists typical scenarios such as logging utilities, connection pools, global configuration, and exclusive resources.
Design PatternEager InitializationJava
0 likes · 4 min read


java1234Jan 27, 2026 · Backend Development
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read


Java OneDec 8, 2025 · Backend Development
This article explains Spring's default eager bean creation, demonstrates how to add @Lazy annotations or a global property to defer bean instantiation until needed, and discusses the benefits and drawbacks of lazy loading with code examples and runtime observations.
@BeanBackendSpring
0 likes · 4 min read

This article presents a step‑by‑step guide that combines lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration exclusion, class‑loading analysis, delayed datasource creation, and AOT/layered compilation to reduce Spring Boot startup latency by up to 70% in real‑world services.
AOT CompilationJVM tuningSpring Boot
0 likes · 10 min read

The article details how a high‑frequency Dubbo call bottleneck was resolved by creating a conditional Spring Boot auto‑configuration multi‑data‑source SDK that dynamically loads beans, avoids bean conflicts, and enables direct database access, dramatically reducing latency and system load.
Auto-configurationConditional BeanDubbo
0 likes · 12 min read

This article walks through seven practical Spring Boot startup‑time optimizations—lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, class‑loading reduction, lazy database connections, and AOT/layered compilation—backed by real‑world case studies and measurable performance gains.
AOTAuto-configurationJVM
0 likes · 10 min read

Learn seven practical strategies—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, dependency slimming, delayed datasource connections, and AOT/layered compilation—to dramatically reduce Spring Boot application startup time, memory usage, and class loading, with real‑world performance comparisons.
AOT CompilationAuto-configurationJVM tuning
0 likes · 9 min read

This article explains the Singleton design pattern, compares lazy and eager implementations in Java, discusses thread‑safety issues with double‑checked locking, presents complete code examples, and outlines the advantages, disadvantages, and appropriate use‑cases for singletons.
Design PatternEager InitializationJava
0 likes · 11 min read


21CTOJul 26, 2024 · Fundamentals
Rust 1.80 introduces LazyCell and LazyLock for deferred data initialization, adds cfg name and value checking to catch configuration errors, supports exclusive range patterns for more concise matching, and stabilizes APIs such as Rc, Arc, Duration, Option, Seek, BinaryHeap, and NonNull, enhancing safety and ergonomics for developers.
CFGExclusive RangesStable API
0 likes · 5 min read

Rust 1.80 introduces LazyCell and LazyLock, synchronized lazy-initialization primitives that differ from OnceCell and OnceLock in thread safety and built‑in initialization, and this article explains their characteristics, trade‑offs, and provides concrete code examples to help developers select the appropriate type for their use case.
ConcurrencyRustSync Primitives
0 likes · 8 min read

This tutorial walks through Spring Boot configuration techniques—including property classes, environment variable binding, validation, @Value usage, random ports, AOP proxy settings, lazy initialization, and handling circular dependencies—providing practical code examples for each feature.
ConfigurationPropertiesSpring Bootbackend development
0 likes · 8 min read

This article explains Kotlin's lazy initialization feature, describes its common usage patterns, dives into the internal source‑code implementations (Synchronized, Publication, and None), discusses thread‑safety concepts such as volatile and CAS, and provides practical recommendations for Android developers.
AndroidKotlinlazy initialization
0 likes · 11 min read

The article details how NetEase Cloud Music’s SpringBoot scaffolding suffered minute‑long startup times, how the team pinpointed bottlenecks such as Scala property parsing, RPC builder/service initialization and thousands of beans using log‑based timing and Arthas profiling, and how moving parsing to a Maven plugin, making RPC connections asynchronous, and applying custom lazy‑initialization cut startup time by roughly 40%.
JavaSpringBootlazy initialization
0 likes · 15 min read


政采云技术Oct 25, 2022 · Backend Development
This article explains how to analyze and accelerate SpringBoot startup by profiling with tools like Async Profiler, refactoring heavy business code, leveraging BeanPostProcessor for bean initialization metrics, using Spring's context indexer, and applying lazy initialization to reduce launch time in large Java backend services.
BeanPostProcessorSpringBootStartup Optimization
0 likes · 11 min read

This article explains the singleton design pattern, shows standard and lazy implementations in JavaScript with code examples, discusses reducing global variable pollution, and demonstrates practical usage in popular front‑end libraries such as Vuex, Ant Design message, and Axios request cancellation.
AxiosDesign PatternJavaScript
0 likes · 11 min read

This article explains why Java’s ArrayList uses a default initial capacity of 10, contrasts it with HashMap’s 16‑element default, and walks through the lazy‑initialization logic and growth algorithm that keep the capacity at ten until the first element is added.
Default CapacityHashMapJava
0 likes · 9 min read

This guide walks through analyzing and optimizing cold‑start latency for a Spring Boot e‑commerce app on Alibaba Cloud Function Compute,{} covering tracing, reserved instances, lazy initialization, JVM tuning, and instance concurrency settings to improve performance.
Instance ConcurrencyJVM tuningReserved Instance
0 likes · 10 min read

This article explains Go's sync.Once primitive, compares it with init, details various singleton implementations—including lazy, eager, and double‑checked locking—and provides practical code examples and a deep dive into its source implementation for thread‑safe one‑time initialization.
ConcurrencyGolazy initialization
0 likes · 7 min read

This article explains the concepts of eager versus lazy evaluation in Java, presents common scenarios for lazy initialization, demonstrates how to implement lazy loading with Supplier, virtual proxy, and delegate patterns, and shows practical Stream examples including infinite prime number generation.
ConcurrencyJavaStream
0 likes · 11 min read

This article explains the difference between eager and lazy evaluation, shows when and how to use lazy initialization in Java, demonstrates Supplier‑based lazy loading, virtual proxy patterns, and stream laziness with infinite streams and prime number generation, all with concrete code examples.
ConcurrencyJavaStream
0 likes · 12 min read

This article explains the definition, class diagram, and multiple Java implementations of the Singleton pattern—including eager, lazy, double‑checked locking, static inner class, and enum approaches—while discussing thread safety, volatile usage, and practical considerations.
Design PatternEnumJava
0 likes · 9 min read

This article explains the Java Singleton pattern, covering lazy (thread‑unsafe), eager, static inner‑class, enum, and double‑checked locking implementations, discusses their thread‑safety, performance, and serialization issues, and provides complete code examples for interview preparation.
Design PatternEnumJava
0 likes · 6 min read

Although developers often overlook high‑concurrency scenarios, this article highlights two typical backend Java concurrency bugs—shared request state in singleton beans and improper lazy initialization—explains their pitfalls, and demonstrates correct thread‑safe patterns such as double‑checked locking and proper singleton design.
ConcurrencyJavalazy initialization
0 likes · 5 min read

Spring Boot 2.2.0 has been officially released, offering faster startup, lower memory usage, optional lazy initialization via the spring.main.lazy-initialization property, full Java 13 compatibility, immutable @ConfigurationProperties through constructor binding, and extensive RSocket auto‑configuration with a new starter.
Javaconfiguration-propertieslazy initialization
0 likes · 4 min read

This article explains four main categories of Java singleton implementations—eager (hungry), lazy (lazy), holder, and enum—detailing their basic forms, variations, thread‑safety characteristics, performance trade‑offs, and code examples, while also discussing pitfalls such as reflection and serialization.
Design PatternEnumJava
0 likes · 10 min read

This article explains the Singleton design pattern in Java, covering its definition, the differences between lazy and eager implementations, thread‑safety issues, multiple code versions (simple, synchronized, double‑checked locking, volatile), and alternative approaches using static inner classes and enums, while discussing atomic operations and instruction reordering.
Design PatternEnumJava
0 likes · 14 min read
