Tagged articles

165 articles

Page 2 of 2

Mar 20, 2021 · Fundamentals

A Humorous Overview of 23 Classic Software Design Patterns

This article presents a playful yet informative walkthrough of twenty‑three classic software design patterns—Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method and Visitor—using everyday analogies to illustrate their intent and structure.

AdapterBuilderDesign Patterns

0 likes · 18 min read

A Humorous Overview of 23 Classic Software Design Patterns

Java Captain

Mar 19, 2021 · Fundamentals

A Humorous Guide to 23 Software Design Patterns Using Dating Analogies

This article humorously explains 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by comparing each pattern to everyday dating scenarios.

AdapterBuilderDesign Patterns

0 likes · 18 min read

A Humorous Guide to 23 Software Design Patterns Using Dating Analogies

Top Architect

Mar 3, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains Spring's approach to resolving circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype bean limitations, provides a simplified implementation example, and draws an analogy to the classic two‑sum algorithm to illustrate the core concept.

BackendDesign PatternsJava

0 likes · 9 min read

How Spring Solves Circular Dependencies and the Underlying Essence

Selected Java Interview Questions

Feb 21, 2021 · Fundamentals

Understanding Double-Checked Locking Singleton Pattern in Java

This article explains the double-checked locking implementation of the Singleton pattern in Java, detailing why two null checks are necessary, the role of the volatile keyword in preventing instruction reordering and ensuring visibility across threads, and provides a complete example code.

JavaSingletonconcurrency

0 likes · 5 min read

Understanding Double-Checked Locking Singleton Pattern in Java

Java Captain

Feb 20, 2021 · Backend Development

Spring Framework Design Patterns: Summary and Implementation Details

This article provides a comprehensive overview of the design patterns used in the Spring framework—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—explaining their implementation, underlying principles, and practical significance with code examples.

AdapterBeanFactoryDecorator

0 likes · 15 min read

Spring Framework Design Patterns: Summary and Implementation Details

Architect's Tech Stack

Feb 18, 2021 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article provides a comprehensive overview of how Spring implements classic design patterns such as Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, and Template Method, explaining their implementation details, underlying principles, and practical code examples within the Spring container.

Design PatternsFactoryObserver

0 likes · 15 min read

Summary of Design Patterns Used in the Spring Framework

Full-Stack Internet Architecture

Feb 18, 2021 · Fundamentals

Comprehensive Guide to the Singleton Pattern in Java: Implementations, Pitfalls, and the Secure Enum Solution

This article explains various Java singleton implementations—including eager, lazy, double‑checked locking, static inner class, and enum—demonstrates their thread‑safety issues, shows how reflection and serialization can break them, and presents the enum approach as a truly safe solution.

JavaReflectionSingleton

0 likes · 11 min read

Comprehensive Guide to the Singleton Pattern in Java: Implementations, Pitfalls, and the Secure Enum Solution

Java Captain

Feb 15, 2021 · Backend Development

Understanding Spring Boot Controller Scope: Singleton vs Prototype and Thread Safety

This article explains why Spring MVC controllers are singleton by default, demonstrates the thread‑safety issues caused by non‑static member variables, shows how applying @Scope("prototype") changes behavior, and summarizes the five Spring bean scopes with practical recommendations.

BackendControllerSingleton

0 likes · 5 min read

Understanding Spring Boot Controller Scope: Singleton vs Prototype and Thread Safety

Liangxu Linux

Feb 6, 2021 · Operations

How to Make a Bash Script Run Only Once: Lock Files and flock Explained

This guide shows how to prevent a Bash script from being executed multiple times by detecting existing instances, using lock files with process checks, and employing the flock command for reliable atomic locking, complete with practical code examples and pitfalls to avoid.

BashOperationsSingleton

0 likes · 8 min read

How to Make a Bash Script Run Only Once: Lock Files and flock Explained

Programmer DD

Feb 6, 2021 · Fundamentals

Master 22 Design Patterns Through Hilarious Real‑World Analogies

This article humorously explains 22 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by likening each to everyday dating and food scenarios, making the concepts easy to grasp.

AdapterBuilderFactory Method

0 likes · 18 min read

Master 22 Design Patterns Through Hilarious Real‑World Analogies

Java Architect Essentials

Jan 17, 2021 · Backend Development

Java Parking System Implementation Example

This article presents a complete Java-based parking system example, detailing functional requirements for users and administrators, and providing full source code for client interaction, entity definitions, service interfaces, and their implementations, illustrating backend development concepts such as singleton patterns, service layers, and basic CRUD operations.

Backend DevelopmentCode ExampleJava

0 likes · 17 min read

Java Parking System Implementation Example

Full-Stack Internet Architecture

Jan 8, 2021 · Backend Development

Deep Dive into Java HashMap, ConcurrentHashMap, JMM, and Concurrency Fundamentals

This article provides a comprehensive overview of Java's HashMap and ConcurrentHashMap implementations, explains core concurrency concepts such as thread states, the differences between concurrency and parallelism, memory models, volatile semantics, singleton patterns, thread pools, ThreadLocal, CAS, and the AQS framework.

HashMapJMMJava

0 likes · 31 min read

Deep Dive into Java HashMap, ConcurrentHashMap, JMM, and Concurrency Fundamentals

Top Architect

Dec 8, 2020 · Backend Development

Understanding Thread Safety of Spring Beans: Singleton vs Prototype Scope

This article explains why Spring beans are not inherently thread‑safe, compares the singleton and prototype scopes, shows how stateless beans can be safe, demonstrates the impact of static fields and injected beans, and provides practical code examples and recommendations for achieving thread safety in Spring applications.

JavaSingletonbean

0 likes · 11 min read

Understanding Thread Safety of Spring Beans: Singleton vs Prototype Scope

php Courses

Nov 2, 2020 · Backend Development

Implementing a Redis Multi-Database Singleton Wrapper in ThinkPHP

This guide demonstrates how to set up a Redis multi-database singleton wrapper in a ThinkPHP project, covering prerequisite installation, configuration of connection parameters, creation of a custom Redis class with static instance management, and example usage of Redis commands across different databases.

BackendCachePHP

0 likes · 3 min read

Implementing a Redis Multi-Database Singleton Wrapper in ThinkPHP

Full-Stack Internet Architecture

Oct 27, 2020 · Fundamentals

Understanding the Java static Keyword: Variables, Methods, Blocks, and Advanced Uses

This article provides a comprehensive guide to Java's static keyword, covering its use on variables, methods, code blocks, inner classes, static imports, memory placement, lifecycle, serialization, class‑loading order, and common patterns such as logging and the double‑checked‑locking singleton.

JavaSingletonclass loading

0 likes · 12 min read

Understanding the Java static Keyword: Variables, Methods, Blocks, and Advanced Uses

Alibaba Cloud Developer

Sep 9, 2020 · Fundamentals

Master Core Design Patterns: Factory, Singleton, Decorator, Strategy, Proxy, Observer

This article explains six essential software design patterns—Factory, Singleton, Decorator, Strategy, Proxy, and Observer—covering their concepts, structure, advantages, drawbacks, typical use cases, and provides concise Java code examples for each.

DecoratorFactory PatternJava

0 likes · 19 min read

Master Core Design Patterns: Factory, Singleton, Decorator, Strategy, Proxy, Observer

Programmer DD

Sep 2, 2020 · Backend Development

Why Spring Boot Controllers Are Singleton by Default and How to Avoid Thread Safety Issues

This article explains that Spring Boot controllers are singleton by default, why that makes them unsafe when using non‑static fields, demonstrates the problem with sample code, and provides practical solutions such as using prototype scope or ThreadLocal variables.

Bean ScopeControllerSingleton

0 likes · 5 min read

Why Spring Boot Controllers Are Singleton by Default and How to Avoid Thread Safety Issues

Laravel Tech Community

Sep 1, 2020 · Fundamentals

PHP Design Patterns: Singleton, Factory, Registry, Adapter, and Observer

This article introduces common PHP design patterns—including Singleton, Factory, Registry, Adapter, and Observer—explaining their purpose, structure, typical use cases, and providing complete code examples for each pattern to illustrate how they can be implemented in object‑oriented applications.

AdapterDesign PatternsFactory

0 likes · 7 min read

PHP Design Patterns: Singleton, Factory, Registry, Adapter, and Observer

Architect's Alchemy Furnace

Aug 18, 2020 · Backend Development

Understanding Spring Bean Scopes and Thread Safety: Singleton vs Prototype

This article explains Spring's bean scopes, compares singleton and prototype beans regarding thread safety, demonstrates the issue with shared state through code examples, and provides practical solutions such as using prototype scope or ThreadLocal to avoid concurrency problems.

Bean ScopeJavaSingleton

0 likes · 5 min read

Understanding Spring Bean Scopes and Thread Safety: Singleton vs Prototype

Java Backend Technology

Aug 18, 2020 · Backend Development

Why Spring Controllers Are Not Thread‑Safe and How to Fix Them

Spring MVC controllers are singleton by default, which can cause thread‑unsafe behavior when using non‑static member variables; this article demonstrates the issue with example endpoints, shows how prototype scope resolves it, and outlines best practices such as avoiding stateful fields or using ThreadLocal.

Bean ScopeControllerJava

0 likes · 5 min read

Why Spring Controllers Are Not Thread‑Safe and How to Fix Them

Top Architect

Aug 6, 2020 · Backend Development

Understanding Spring Controller Bean Scope: Singleton vs Prototype and Thread Safety

This article explains why Spring MVC controllers are singleton by default, demonstrates the thread‑safety issues caused by shared instance variables, shows how to test the behavior with sample code, and presents solutions such as using prototype scope, avoiding member variables, or employing ThreadLocal.

Bean ScopeControllerJava

0 likes · 6 min read

Understanding Spring Controller Bean Scope: Singleton vs Prototype and Thread Safety

Selected Java Interview Questions

Jul 27, 2020 · Backend Development

Understanding Spring Controller Scope and Thread Safety

The article explains why Spring MVC controllers are singleton by default, demonstrates the resulting thread‑unsafe behavior with example code, shows how applying @Scope("prototype") makes them prototype scoped, and provides best‑practice recommendations and a summary of Spring bean scopes.

ControllerSingletonbean

0 likes · 5 min read

Understanding Spring Controller Scope and Thread Safety

Huawei Cloud Developer Alliance

Jun 1, 2020 · Fundamentals

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

This article explores several advanced Java singleton implementations—including double‑check locking with volatile, static inner‑class lazy loading, and enum‑based singletons—explaining their mechanisms, thread‑safety benefits, and trade‑offs for modern backend development.

DCLJavaSingleton

0 likes · 8 min read

Master Java Singleton: DCL, Volatile, Static Inner Class & Enum Explained

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

Java Backend Technology

Apr 18, 2020 · Backend Development

Why Spring Beans Default to Singleton: Benefits and Drawbacks Explained

This article explains Spring's five bean scopes, focusing on the differences between singleton and prototype beans, their performance advantages, thread-safety concerns, and why Spring chooses singleton as the default scope.

Bean ScopeSingletonperformance

0 likes · 5 min read

Why Spring Beans Default to Singleton: Benefits and Drawbacks Explained

Selected Java Interview Questions

Apr 17, 2020 · Backend Development

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

This article explains the advantages of Java thread pools, breaks down the ThreadPoolExecutor parameters and execution flow, compares common pool types, and demonstrates how to implement a thread‑pool as a singleton to efficiently manage concurrency in backend applications.

BackendDesignPatternJava

0 likes · 10 min read

Understanding Java Thread Pools: Benefits, Detailed Parameters, and Singleton Implementation

Java Backend Technology

Mar 26, 2020 · Fundamentals

Mastering Java Enums: From Basics to Advanced Design Patterns

This article explains what Java enums are, why they are useful, how to define simple and custom enum types, compare them safely, use them in switch statements, enrich them with fields, methods and constructors, and apply them in advanced scenarios such as EnumSet, EnumMap, Singleton and Strategy patterns, as well as Java 8 stream APIs and JSON serialization.

EnumMapEnumSetEnums

0 likes · 17 min read

Mastering Java Enums: From Basics to Advanced Design Patterns

ITFLY8 Architecture Home

Mar 19, 2020 · Backend Development

How Spring Implements 9 Core Design Patterns – From Simple Factory to Template Method

This article explains how Spring applies nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and the benefits they bring to Spring's IoC container and AOP mechanisms.

Backend DevelopmentFactory MethodSingleton

0 likes · 18 min read

How Spring Implements 9 Core Design Patterns – From Simple Factory to Template Method

Selected Java Interview Questions

Feb 19, 2020 · Backend Development

Understanding Singleton and Prototype Scope in Spring MVC Controllers

This article explains how Spring MVC controller beans behave under singleton and prototype scopes, showing that normal instance fields are shared only in singleton beans while static fields are always shared, and recommends using @Scope("prototype") when defining controller attributes.

ControllerJavaSingleton

0 likes · 5 min read

Understanding Singleton and Prototype Scope in Spring MVC Controllers

FunTester

Feb 15, 2020 · Backend Development

Understanding Double-Checked Locking Singleton Pattern in Java

This article explains the double‑checked locking design pattern for thread‑safe singletons in Java, demonstrates its performance drawbacks, and presents alternative implementations such as early initialization, init‑on‑demand holder, and enum‑based singletons, highlighting their advantages and limitations.

JavaSingletonconcurrency

0 likes · 6 min read

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

Architecture Digest

Jan 11, 2020 · Backend Development

Design Patterns Used in MyBatis Source Code

This article examines how MyBatis implements numerous classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—through its source code, explaining each pattern's role, related classes, and code examples to deepen developers' understanding of backend architecture.

AdapterBuilderDecorator

0 likes · 17 min read

Design Patterns Used in MyBatis Source Code

Selected Java Interview Questions

Nov 24, 2019 · Fundamentals

Introduction to the Singleton Design Pattern

The Singleton pattern ensures a class has only one instance, providing a global point of access, and is explained with its definition, implementation steps, advantages, disadvantages, thread‑safety concerns, usage guidelines, and typical real‑world scenarios such as configuration management, logging, and resource pooling.

JavaObject-OrientedSingleton

0 likes · 9 min read

Introduction to the Singleton Design Pattern

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 19, 2019 · Backend Development

Resolving Circular Dependencies in Spring: Constructor vs Setter Injection and Bean Scopes

This article explains how Spring handles circular dependencies through constructor injection errors, demonstrates how setter injection with singleton scope avoids the issue, and shows why prototype‑scoped beans still fail, providing code examples and internal mechanism details.

Bean ScopeConstructor InjectionSetter Injection

0 likes · 9 min read

Resolving Circular Dependencies in Spring: Constructor vs Setter Injection and Bean Scopes

Full-Stack Internet Architecture

Sep 16, 2019 · Fundamentals

Why Java Provides Both synchronized and volatile: A Deep Dive into Concurrency

This article explains the distinct roles of Java's synchronized and volatile keywords, analyzes their performance and ordering characteristics, demonstrates how instruction reordering can cause bugs in double‑checked locking, and shows why volatile remains indispensable for safe concurrent programming.

JavaSingletondouble-checked locking

0 likes · 12 min read

Why Java Provides Both synchronized and volatile: A Deep Dive into Concurrency

Qunar Tech Salon

Aug 8, 2019 · Frontend Development

Understanding Design Patterns in JavaScript

This article explains why and how to use various JavaScript design patterns—such as module, revealing module, ES6 modules, singleton, factory, and decorator—by describing their purpose, benefits, and providing clear code examples while warning against over‑use.

DecoratorDesign PatternsFactory

0 likes · 14 min read

Understanding Design Patterns in JavaScript

Java Backend Technology

Jun 27, 2019 · Backend Development

Is Your Java Singleton Really a Singleton? Thread, Reflection & Serialization Pitfalls

This article examines various Java singleton implementations—eager, lazy, double‑checked locking, static inner class, enum, and Kotlin object—analyzing their thread safety, reflection and serialization vulnerabilities, and shows how to harden them using volatile, constructor guards, and readResolve.

JavaReflectionSingleton

0 likes · 12 min read

Is Your Java Singleton Really a Singleton? Thread, Reflection & Serialization Pitfalls

Java Captain

May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.

Design PatternsFactoryIoC

0 likes · 17 min read

Common Design Patterns Used in the Spring Framework

Java Captain

Mar 9, 2019 · Fundamentals

Understanding Java Enums: Usage, Switch Cases, Singleton Implementation, and Database Integration

This article explores Java enums in depth, covering their basic definition, typical usage patterns such as iteration and switch statements, implementing singletons, integrating with databases via MyBatis type handlers, and addressing common misconceptions about memory consumption, illustrating each concept with clear code examples.

JavaMyBatisSingleton

0 likes · 7 min read

Understanding Java Enums: Usage, Switch Cases, Singleton Implementation, and Database Integration

Java Captain

Feb 10, 2019 · Backend Development

Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—through configuration examples and Java code, illustrating their roles in building flexible, maintainable backend applications.

AdapterBackend DevelopmentDesign Patterns

0 likes · 9 min read

Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method

Java Captain

Jan 12, 2019 · Fundamentals

Understanding the Singleton Pattern in Java: Concepts, Comparisons, and Implementations

This article explains the Singleton design pattern in Java, outlines its characteristics, compares it with static classes, clarifies common misconceptions, and presents multiple thread‑safe and non‑thread‑safe implementation techniques with code examples.

JavaSingletondesign pattern

0 likes · 10 min read

Understanding the Singleton Pattern in Java: Concepts, Comparisons, and Implementations

Senior Brother's Insights

Jan 2, 2019 · Backend Development

9 Essential Spring Design Patterns Explained with Code Samples

This article walks through nine commonly used design patterns in Spring, such as Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method, providing clear explanations, XML configurations, and Java code examples to illustrate each pattern in practice.

AdapterDesign PatternsFactory

0 likes · 9 min read

9 Essential Spring Design Patterns Explained with Code Samples

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

Senior Brother's Insights

Aug 23, 2018 · Fundamentals

Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More

Explore the GOF 23 design patterns with a deep dive into the Singleton pattern, covering its purpose, characteristics, comparison to static classes, and multiple Java implementations—including eager, lazy, double‑checked locking, volatile, static inner class, and enum approaches—plus Spring’s real‑world usage.

Design PatternsJavaSingleton

0 likes · 12 min read

Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More

Java Captain

Aug 15, 2018 · Backend Development

Understanding Java Thread Pools: Benefits, Parameters, Types, and Singleton Implementation

This article explains the advantages of using thread pools in Java, details the key parameters of ThreadPoolExecutor, compares concurrency and parallelism, describes common pool types, and provides a singleton pattern implementation with complete code examples.

ExecutorServiceJavaSingleton

0 likes · 10 min read

Understanding Java Thread Pools: Benefits, Parameters, Types, and Singleton Implementation

Programmer DD

Jun 6, 2018 · Fundamentals

Why Double‑Checked Locking Fails in Java and How to Fix It

This article explains why the classic Double‑Checked Locking implementation of a lazy singleton is unsafe in Java, analyzes the underlying object‑creation reordering problem, and presents two reliable solutions—using a volatile field or a static holder class—to achieve thread‑safe lazy initialization.

JavaSingletonconcurrency

0 likes · 7 min read

Why Double‑Checked Locking Fails in Java and How to Fix It

Java Backend Technology

Apr 17, 2018 · Backend Development

Mastering the Singleton Pattern in Java: Eager, Lazy, and Thread‑Safe Implementations

This article explains the concept of design patterns and dives deep into the Singleton pattern in Java, covering its purpose, eager and lazy implementations, thread‑safety challenges, double‑checked locking, volatile usage, static inner class, and enum approaches, while illustrating each with clear code examples and diagrams.

Double-Check LockingJavaSingleton

0 likes · 11 min read

Mastering the Singleton Pattern in Java: Eager, Lazy, and Thread‑Safe Implementations

Java Captain

Apr 14, 2018 · Fundamentals

Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy

This article introduces several core Java design patterns—including Singleton (lazy, eager, static inner class, enum, double‑checked locking), Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy—explaining their intent, providing concise code examples, and showing how they solve common software design problems.

DecoratorDesign PatternsFactory

0 likes · 13 min read

Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy

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.

Garbage CollectionHotSpotJVM

0 likes · 6 min read

Will JVM Garbage Collector Reclaim Long-Unused Singleton Objects?

MaGe Linux Operations

Jan 24, 2018 · Backend Development

Ace Alibaba Python Engineer Interview: Real Questions & Answers

This article shares Alibaba's Python engineer job requirements, detailed interview questions covering list operations, word frequency, GIL, multithreading, design patterns, and common Python concepts, along with concise answers to help candidates prepare effectively.

AlibabaCoding QuestionsGIL

0 likes · 10 min read

Ace Alibaba Python Engineer Interview: Real Questions & Answers

Java Captain

Jan 5, 2018 · Fundamentals

Overview of Design Patterns, SOLID Principles, and Java Implementations

This article introduces the three major categories of design patterns, explains the six SOLID principles, and provides detailed Java code examples for creational patterns such as Factory Method, Abstract Factory, Singleton, Builder, and Prototype, illustrating their structure and usage.

BuilderCreationalDesign Patterns

0 likes · 14 min read

Overview of Design Patterns, SOLID Principles, and Java Implementations

MaGe Linux Operations

Dec 13, 2017 · Fundamentals

Unlock Python Metaprogramming: Master Metaclasses, Singletons, and Decorators

This article demystifies Python metaprogramming by exploring objects, classes, metaclasses, import‑time vs run‑time behavior, singleton implementations, decorators, and descriptors, showing how to harness these advanced features to write cleaner, more elegant code while explaining underlying concepts and practical examples.

PythonSingletondecorators

0 likes · 9 min read

Unlock Python Metaprogramming: Master Metaclasses, Singletons, and Decorators

Architecture Digest

Dec 13, 2017 · Mobile Development

Practical Code Refactoring Lessons from a Mobile Development Leader

The author, a mobile development team leader, shares a detailed account of a recent iOS codebase refactoring, describing the removal of unused libraries and code, architectural improvements, memory‑leak fixes, and best‑practice guidelines such as avoiding singletons, unnecessary layers, and over‑reliance on third‑party frameworks.

Singletonarchitecturecode cleanup

0 likes · 11 min read

Practical Code Refactoring Lessons from a Mobile Development Leader

Programmer DD

Dec 6, 2017 · Fundamentals

Mastering Java Singleton: From Lazy Initialization to Enum with Thread‑Safety

This article walks through multiple Java Singleton implementations—lazy initialization, double‑checked locking, volatile‑protected, static‑inner‑class, and enum—explaining their thread‑safety characteristics, the pitfalls of instruction reordering, and how reflection and serialization can break or preserve the pattern.

JavaSingletondesign pattern

0 likes · 10 min read

Mastering Java Singleton: From Lazy Initialization to Enum with Thread‑Safety

Senior Brother's Insights

Dec 4, 2017 · Fundamentals

Mastering Thread‑Safe Singleton in Java: Double‑Check, Static Holder, Enum & Reflection Hacks

Explore multiple Java singleton implementations—including a thread‑safe double‑checked locking version, a static inner‑class approach, an enum‑based solution, and a reflection‑based attack—while learning their key technical details, advantages, pitfalls, and how to protect against serialization and reflection vulnerabilities.

JavaReflectionSingleton

0 likes · 6 min read

Mastering Thread‑Safe Singleton in Java: Double‑Check, Static Holder, Enum & Reflection Hacks

Java Captain

Nov 13, 2017 · Fundamentals

Understanding the Singleton Design Pattern in Java: Implementations, Thread Safety, and Best Practices

This article explains the Singleton design pattern in Java, covering its definition, lazy and eager implementations, thread‑safety issues such as double‑checked locking and volatile, and alternative approaches like static inner classes and enums, providing code examples and practical insights.

Singletondesign patterndouble-checked locking

0 likes · 14 min read

Understanding the Singleton Design Pattern in Java: Implementations, Thread Safety, and Best Practices

Hujiang Technology

Oct 26, 2017 · Frontend Development

Design Patterns in Front-End JavaScript Development

This article explains how to apply common design patterns such as Singleton and Observer in front‑end JavaScript, demonstrating practical extensions using Function.prototype, discussing the Open‑Closed Principle, and providing code examples for flexible, maintainable code without invasive modifications.

Design PatternsJavaScriptObserver

0 likes · 10 min read

Design Patterns in Front-End JavaScript Development

Java Backend Technology

Oct 24, 2017 · Fundamentals

ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading

This article examines common Java singleton implementations—including eager, thread‑safe lazy, double‑checked locking, and static inner‑class approaches—explaining their requirements, potential memory‑leak pitfalls such as ThreadLocal‑induced OOM, and how improper usage in multithreaded environments can lead to unexpected instance creation and performance issues.

Design PatternsJavaOOM

0 likes · 6 min read

ThreadLocal OOM? Exploring Singleton Pitfalls in Java Multithreading

Hujiang Technology

Jul 20, 2017 · Mobile Development

Kotlin Class Extensions, Companion Objects, Singleton Design, Dynamic Proxy, and Pseudo‑Multiple Inheritance

This article explains Kotlin's class extension functions, highlights pitfalls of static resolution, demonstrates smart casts, describes companion objects and singleton patterns, and shows how to implement dynamic proxies and pseudo‑multiple inheritance with practical code examples for Android development.

Class ExtensionsCompanion ObjectDynamic Proxy

0 likes · 11 min read

Kotlin Class Extensions, Companion Objects, Singleton Design, Dynamic Proxy, and Pseudo‑Multiple Inheritance

Tencent TDS Service

Mar 9, 2017 · Mobile Development

Mastering the Singleton Pattern in Android: Pitfalls, Best Practices, and Real‑World Implementations

This article explores the Singleton design pattern in depth, covering its definition, various Java implementations, thread‑safety concerns, serialization, reflection and cloning pitfalls, Android‑specific considerations, and practical recommendations for using singletons effectively in mobile projects.

JavaSingletondesign pattern

0 likes · 38 min read

Mastering the Singleton Pattern in Android: Pitfalls, Best Practices, and Real‑World Implementations

21CTO

May 10, 2016 · Fundamentals

Mastering Core Design Patterns: Singleton, Adapter, Observer, and Factory Implementations in Java

This article introduces six fundamental design patterns—Singleton, Adapter, Observer, Simple Factory, Factory Method, and Abstract Factory—explaining their concepts, class diagrams, and providing complete Java code examples to illustrate each pattern's practical implementation.

AdapterDesign PatternsFactory

0 likes · 9 min read

Mastering Core Design Patterns: Singleton, Adapter, Observer, and Factory Implementations in Java

Architecture Digest

May 10, 2016 · Fundamentals

Common Design Patterns in Java: Singleton, Adapter, Observer, Simple Factory, Factory Method, and Abstract Factory

This article introduces several core Java design patterns—including Singleton, Adapter, Observer, Simple Factory, Factory Method, and Abstract Factory—explaining their concepts, class diagrams, and providing complete code examples for each implementation variant.

AdapterDesign PatternsFactory

0 likes · 8 min read

Common Design Patterns in Java: Singleton, Adapter, Observer, Simple Factory, Factory Method, and Abstract Factory

Tencent Music Tech Team

Apr 27, 2016 · Mobile Development

Cross-Process Singleton Implementation in Android Using AIDL

The article explains how to turn a traditional Android singleton into a cross‑process object by having the singleton implement an AIDL interface, exposing it through a bound Service, and using Parcelable‑based Binder serialization so multiple processes share the same instance while handling IPC, threading, and data‑type constraints.

AIDLAndroidCross-Process

0 likes · 17 min read

Cross-Process Singleton Implementation in Android Using AIDL

Art of Distributed System Architecture Design

May 19, 2015 · Fundamentals

Why the Singleton Pattern Matters: Lazy Loading, Thread Safety, and Real‑World Java Examples

This article explains the Singleton design pattern in Java, illustrates why a single instance is essential for configuration classes, compares eager and lazy initialization, shows thread‑safe implementations, and demonstrates extensions that limit the number of instances with practical code samples.

JavaSingletondesign pattern

0 likes · 12 min read