Tagged articles

25 articles

Page 1 of 1

Jan 27, 2026 · Backend Development

7 Proven Spring Boot Startup Hacks to Slash Over 70% of Boot Time

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.

Database ConnectionSpring Bootauto-configuration

0 likes · 9 min read

7 Proven Spring Boot Startup Hacks to Slash Over 70% of Boot Time

Java One

Dec 8, 2025 · Backend Development

How to Enable Lazy Initialization for Spring Beans to Boost Startup Performance

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.

Backendbeanlazy-initialization

0 likes · 4 min read

How to Enable Lazy Initialization for Spring Beans to Boost Startup Performance

Java Backend Technology

Nov 19, 2025 · Backend Development

How to Slash Spring Boot Startup Time by 70% with 7 Proven Optimizations

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 compilationSpring Bootcomponent-scan

0 likes · 10 min read

How to Slash Spring Boot Startup Time by 70% with 7 Proven Optimizations

Java Companion

Nov 4, 2025 · Backend Development

Boosting Dubbo Performance with Spring Boot Auto‑Configuration and a Multi‑Data‑Source SDK

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.

Conditional BeanDubboMulti-DataSource

0 likes · 12 min read

Boosting Dubbo Performance with Spring Boot Auto‑Configuration and a Multi‑Data‑Source SDK

Su San Talks Tech

Oct 30, 2025 · Backend Development

7 Proven Techniques to Slash Spring Boot Startup Time by Over 70%

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.

AoTJVMSpring Boot

0 likes · 10 min read

7 Proven Techniques to Slash Spring Boot Startup Time by Over 70%

Architect

Jul 10, 2025 · Backend Development

7 Proven Techniques to Slash Spring Boot Startup Time by 70%

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 compilationSpring Bootauto-configuration

0 likes · 9 min read

7 Proven Techniques to Slash Spring Boot Startup Time by 70%

Selected Java Interview Questions

Sep 24, 2024 · Fundamentals

Understanding the Singleton Pattern: Lazy and Eager Implementations in Java

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.

Eager InitializationJavaSingleton

0 likes · 11 min read

Understanding the Singleton Pattern: Lazy and Eager Implementations in Java

21CTO

Jul 26, 2024 · Fundamentals

What’s New in Rust 1.80? Lazy Initialization, cfg Checks, and Exclusive Ranges

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

What’s New in Rust 1.80? Lazy Initialization, cfg Checks, and Exclusive Ranges

BirdNest Tech Talk

Jul 26, 2024 · Fundamentals

How to Choose Between Rust’s LazyLock, LazyCell, OnceLock, and OnceCell

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.

RustStandard LibrarySync Primitives

0 likes · 8 min read

How to Choose Between Rust’s LazyLock, LazyCell, OnceLock, and OnceCell

Spring Full-Stack Practical Cases

Jul 16, 2024 · Backend Development

Master Spring Boot Configuration: @ConfigurationProperties, @Value, AOP & Lazy Init

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.

Backend DevelopmentConfigurationPropertiesSpring Boot

0 likes · 8 min read

Master Spring Boot Configuration: @ConfigurationProperties, @Value, AOP & Lazy Init

Sohu Tech Products

May 4, 2023 · Mobile Development

Understanding Kotlin Lazy Initialization: Usage, Source Code Analysis, and Best Practices

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.

AndroidKotlinMobile Development

0 likes · 11 min read

Understanding Kotlin Lazy Initialization: Usage, Source Code Analysis, and Best Practices

NetEase Cloud Music Tech Team

Mar 8, 2023 · Backend Development

SpringBoot Application Startup Analysis and Optimization in NetEase Cloud Music

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

SpringBoot Application Startup Analysis and Optimization in NetEase Cloud Music

政采云技术

Oct 25, 2022 · Backend Development

SpringBoot Application Startup Optimization Techniques

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.

BeanPostProcessorSpringBootlazy-initialization

0 likes · 11 min read

SpringBoot Application Startup Optimization Techniques

Rare Earth Juejin Tech Community

Oct 8, 2022 · Frontend Development

Understanding the Singleton Pattern in JavaScript: Concepts, Implementations, and Real‑World Applications

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.

JavaScriptSingletonVuex

0 likes · 11 min read

Understanding the Singleton Pattern in JavaScript: Concepts, Implementations, and Real‑World Applications

Senior Brother's Insights

Jun 13, 2022 · Fundamentals

Why Does Java’s ArrayList Default to a Capacity of 10?

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.

ArrayListData StructuresDefault Capacity

0 likes · 9 min read

Why Does Java’s ArrayList Default to a Capacity of 10?

Alibaba Cloud Native

Jan 19, 2022 · Cloud Native

How to Cut Spring Boot Serverless Cold‑Start Time with Reserved Instances and Lazy Init

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 ConcurrencyReserved InstanceServerless

0 likes · 10 min read

How to Cut Spring Boot Serverless Cold‑Start Time with Reserved Instances and Lazy Init

360 Zhihui Cloud Developer

Oct 21, 2021 · Backend Development

Mastering sync.Once in Go: Thread‑Safe Singleton Patterns Explained

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.

GoSingletonconcurrency

0 likes · 7 min read

Mastering sync.Once in Go: Thread‑Safe Singleton Patterns Explained

Top Architect

Feb 22, 2021 · Backend Development

Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns

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.

Design PatternsJavaStream

0 likes · 11 min read

Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns

Programmer DD

Feb 19, 2021 · Backend Development

Mastering Lazy Initialization and Stream Laziness in Java 8

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.

JavaStreamSupplier

0 likes · 12 min read

Mastering Lazy Initialization and Stream Laziness in Java 8

Full-Stack Internet Architecture

Oct 14, 2020 · Fundamentals

Singleton Pattern – Ensuring a Unique Instance in Java

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.

Javadesign patternenum

0 likes · 9 min read

Singleton Pattern – Ensuring a Unique Instance in Java

Selected Java Interview Questions

May 9, 2020 · Fundamentals

Java Singleton Pattern: Lazy, Eager, Static Inner Class, Enum, and Double-Checked Locking

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.

JavaSingletondesign pattern

0 likes · 6 min read

Java Singleton Pattern: Lazy, Eager, Static Inner Class, Enum, and Double-Checked Locking

FunTester

Jan 26, 2020 · Backend Development

Common Concurrency Bugs in Backend Java Development and Their Solutions

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.

JavaSingletonconcurrency

0 likes · 5 min read

Common Concurrency Bugs in Backend Java Development and Their Solutions

Architect's Tech Stack

Oct 24, 2019 · Backend Development

Spring Boot 2.2.0 Released with Performance Boosts, Lazy Initialization, Java 13 Support, Immutable @ConfigurationProperties, and RSocket Integration

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

Spring Boot 2.2.0 Released with Performance Boosts, Lazy Initialization, Java 13 Support, Immutable @ConfigurationProperties, and RSocket Integration

Selected Java Interview Questions

Oct 20, 2019 · Fundamentals

Java Singleton Pattern Implementations and Variants

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.

JavaSingletondesign pattern

0 likes · 10 min read

Java Singleton Pattern Implementations and Variants

Java Captain

Oct 2, 2018 · Fundamentals

Understanding the Singleton Design Pattern in Java: Lazy, Eager, Double‑Check, Volatile, Static Inner Class and Enum Implementations

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.

JavaSingletondesign pattern

0 likes · 14 min read

Understanding the Singleton Design Pattern in Java: Lazy, Eager, Double‑Check, Volatile, Static Inner Class and Enum Implementations