iluwatar / java-design-patterns

Design patterns implemented in Java

Design Patterns Implemented in Java

Read in different language : zh, ko, fr, tr, ar, es, pt, id, ru, de, ja, vi, bn, np, it, da

Introduction

Design patterns are the best, formalized practices a programmer can use to solve common problems when designing an application or system.

Design patterns can speed up the development process by providing tested, proven development paradigms.

Reusing design patterns helps prevent subtle issues that cause major problems, and it also improves code readability for coders and architects who are familiar with the patterns.

Getting Started

This site showcases Java Design Patterns. The solutions have been developed by experienced programmers and architects from the open-source community. The patterns can be browsed by their high-level descriptions or by looking at their source code. The source code examples are well commented and can be thought of as programming tutorials on how to implement a specific pattern. We use the most popular battle-proven open-source Java technologies.

Before you dive into the material, you should be familiar with various Software Design Principles.

All designs should be as simple as possible. You should start with KISS, YAGNI, and Do The Simplest Thing That Could Possibly Work principles. Complexity and patterns should only be introduced when they are needed for practical extensibility.

Once you are familiar with these concepts you can start drilling down into the available design patterns by any of the following approaches:

• Search for a specific pattern by name. Can't find one? Please report a new pattern here.
• Using tags such as Performance, Gang of Four or Data access.
• Using pattern categories, Creational, Behavioral, and others.

Hopefully, you find the object-oriented solutions presented on this site useful in your architectures and have as much fun learning them as we had while developing them.

How to Contribute

If you are willing to contribute to the project you will find the relevant information in our developer wiki. We will help you and answer your questions in the Gitter chatroom.

The Book

The design patterns are now available as an e-book. Find out more about "Open Source Java Design Patterns" here: https://payhip.com/b/kcaF9

The project contributors can get the book for free. Contact the maintainer via Gitter chatroom or email (iluwatar (at) gmail (dot) com ). Send a message that contains your email address, Github username, and a link to an accepted pull request.

License

This project is licensed under the terms of the MIT license.

Contributors

Ilkka Seppälä 📆 🚧 🖋	Subhrodip Mohanta 💻 👀 🚧	amit1307 💻	Narendra Pathai 💻 🤔 👀	Jeroen Meulemeester 💻	Joseph McCarthy 💻
Thomas 💻	Anurag Agarwal 💻	Markus Moser 🎨 💻 🤔	Sabiq Ihab 💻	Amit Dixit 💻	Piyush Kailash Chaudhari 💻
joshzambales 💻	Kamil Pietruszka 💻	Zafar Khaydarov 💻 📖	Paul Campbell 💻	Argyro Sioziou 💻	TylerMcConville 💻
saksham93 💻	nikhilbarar 💻	Colin But 💻	Ruslan 💻	Juho Kang 💻	Dheeraj Mummareddy 💻
Bernardo Sulzbach 💻	Aleksandar Dudukovic 💻	Yusuf Aytaş 💻	Mihály Kuprivecz 💻	Stanislav Kapinus 💻	GVSharma 💻
Srđan Paunović 💻	Petros G. Sideris 💻	Pramod Gupta 👀	Amarnath Chandana 💻	Anurag870 💻 📖	Wes Gilleland 💻
Harshraj Thakor 💻	Martin Vandenbussche 💻	Alexandru Somai 💻	Artur Mogozov 💻	anthony 💻	Christian Cygnus 💻
Dima Gubin 💻	Joshua Jimenez 💻	Kai Winter 💻	lbroman 💻	Przemek 💻	Prafful Agarwal 🖋
Sanket Panhale 🖋	staillebois 💻	Krisztián Nagy 💻	Alexander Ivanov 💻	Yosfik Alqadri 💻	Agustí Becerra Milà 💻
Juan Manuel Suárez 💻	Luigi Cortese 💻	Katarzyna Rzepecka 💻	adamski.pro 💻	Shengli Bai 💻	Boris 💻
Dmitry Avershin 💻	靳阳 💻	hoangnam2261 💻	Arpit Jain 💻	Jón Ingi Sveinbjörnsson 💻	Kirill Vlasov 💻
Mitchell Irvin 💻	Ranjeet 💻	PhoenixYip 💻	M Saif Asif 💻	kanwarpreet25 💻	Leon Mak 💻
Per Wramdemark 💻	Evan Sia Wai Suan 💻	AnaghaSasikumar 💻	Christoffer Hamberg 💻	Dominik Gruntz 💻	Hannes 💻
Leo Gutiérrez Ramírez 💻	Zhang WH 💻	Christopher O'Connell 💻	George Mavroeidis 💻	Hemant Bothra 💻 🎨	Kevin Peters 💻
George Aristy 💻	Mahendran Mookkiah 💻	Azureyjt 💻	gans 💻	Matt 🖋	Gopinath Langote 💻
Hoswey 💻	Amit Pandey 💻	gwildor28 🖋	田浩 🖋	Stamatis Pitsios 💻	qza 💻
Rodolfo Forte 🖋	Ankur Kaushal 💻	Ovidijus Okinskas 💻	Robert Kasperczyk 💻	Tapio Rautonen 💻	Yuri Orlov 💻
Varun Upadhyay 💻	Aditya Pal 💻	grzesiekkedzior 💻 👀	Sivasubramani M 💻	Sami Airaksinen 💻	Janne Sinivirta 💻
Boris-Chengbiao Zhou 🖋	Jacob Hein 🖋	Richard Jones 🖋	Rachel M. Carmena 🖋	Zaerald Denze Lungos 🖋	Lars Kappert 🖋
Mike Liu 🌍	Matt Dolan 💻 👀	Manan 👀	Nishant Arora 💻	Peeyush 💻	Rakesh 💻 👀
Wei Seng 💻	Ashish Trivedi 💻	洪月阳 💻	xdvrx1 👀 🤔	Bethan Palmer 💻	Toxic Dreamz 💻
Edy Cu Tjong 📖	Michał Krzywański 💻	Stefan Birkner 💻	Fedor Skvorcov 💻	samilAyoub 💻	Vladislav Golubinov 💻
Swaraj 💻	Christoph Flick 📖	Ascênio 👀	Domenico Sibilio 📖	Akash Chandwani 👀	Pavlo Manannikov 💻
Eiman 💻	Rocky 📖	Ibrahim ali abdelghany 👀	Girish Kulkarni 📖	Omar Karazoun 💻	Jeff Evans 💻
Vivek Singh 💻	siavash 💻	ruchpeanuts 📖	warp125 🌍	KHADIR Tayeb 🌍	ignite1771 💻
Halil Demir 🌍	Rohit Singh 💻	byoungju94 💻	Moustafa Farhat 🌍	Martel Richard 💻	va1m 💻
Noam Greenshtain 💻	yonghong Xu 📖	jinishavora 👀 💻	Elvys Soares 💻	zWeBrain 💻	余林颖 🌍
Alain 🌍	VR 📖	JackieNim 💻	EdisonE3 💻	Tao 💻	Juan Manuel Abate 🌍
Xenilo137 💻	Samuel Souza 💻 📖	Marlo Henrique 🌍	AndriyPyzh 💻	karthikbhat13 💻	Morteza Adigozalpour 💻
Nagaraj Tantri 💻	Francesco Scuccimarri 💻	Conny Hansson 📖	Muklas Rahmanto 🌍	Vadim 🌍	Simran Keshri 💻
JCarlos 🌍	Ali Ghasemi 💻	Carl Dea 💻	Mozartus 🌍	Manvi Goel 📖	Anum Amin 📖
Reo Uehara 🌍	Fiordy 📖	Harshal 💻	Abhinav Vashisth 📖	Kevin 👀 💻	Shrirang 👀 💻
interactwithankush 💻	CharlieYu 💻	Leisterbecker 💻	DragonDreamer 💻	ShivanshCharak 💻	HattoriHenzo 💻
Arnab Sen 💻	MohanaRao SV 💻	Yonatan Karp-Rudin 💻 👀	Oliani 💻	Renjie LIU 💻	perfect guy 📖
xyllq999 💻	Mohamed Bilal 📖	Karshil sheth 💻	kongleong86 💻	Aitor Fidalgo Sánchez 🌍 📖 👀	Victor He 💻
Minh Nguyen 🌍 📖	Victor He 📖	yiichan 📖	Pan Sem 📖	zhoumengyks 💻	you 🌍
Thanks 🌍	LazyProgrammer 📖	Mohammed Faizan Ahmed 📖	Bruno Fernandes 💻	SammanPali 📖	Qixiang Chen 📖
Shourya Manekar 🌍	Alan 🌍	JanFidor 💻 📖	Anton Yakutovich 💻	steph88ss 📖	Yujan Ranjitkar 🌍
yusha-g 🌍	Robert Volkmann 💻 👀	Bipin Kumar Chaurasia 📖	KyleSong30 📖	u7281975 📖	harshalkhachane 💻
Tejas Singh 📖 🌍	Sudarsan Balaji 💻	Vaibhav Agrawal 📖	u7275858 💻	prasad-333 📖	JurenXu 💻
murphShaw 📖	XianWu99 📖	JoshuaSinglaANU 💻	Ricardo Ramos 🌍	Farid Zouheir 🌍	Vinícius A. B. 🌍
Stefanel Stan 💻	Prince bhati 🌍	WuLang 📖	Hugo Kat 💻	Shivanagouda Agasimani 💻	Aparna 💻
Girolamo Giordano 🌍	Chak-C 💻	Nakul Nambiar 💻	KarmaTashiCat 🌍	marikattt 💻	Hashvardhan Parmar 🌍
YongHwan 📖 🌍	Shogo Hida 🌍	Eugene 💻	Piyush 📖	Rahul Raj 💻	Bharath Kalyan S 💻
Saiteja Reddy 🌍	Enrique Clerici 🌍	Ramil Sayetov 🌍	东方未白 💻	Fredrik Sejr 🌍	akshatarora0013 💻
Mughees Qasim 💻	behappyleee 🌍	Ayush Thakur 🌍	Anthony Bosch 💻	trananso 📖	Giammaria Biffi 🌍
Saiful Haque 💻	JabezBrew 💻	konstantin-goldman 📖	Tien Nguyen Minh 💻 🌍	Vladimir 🌍	Surjendu 🌍 💻
bakazhou 💻	Owen Leung 💻	Stavros Barousis 📖	Syyed Ibrahim Abdullah 🌍	JiaDi Zhang 🌍	Sanchit Bansal 📖
Md Saiful Islam 📖	Antonio Addeo 📖 💻	Allagadda Sai Upendranath 📖	Matheus Braga 🌍 📖	Appari Satya Barghav 📖	Marcel Ribeiro-Dantas 📖
Muhammad Hanif Amrullah 🌍	JackH408 📖	Shubham 🌍	Nishant Jain 📖	Rhitam Chaudhury 📖	JerryZhao275 📖
Leonardo Lisanti 🌍	Yennifer Herrera 🌍 👀	jnniu-n 🌍 📖	Miguel Angel Perez Garcia 👀 🌍	Suwan Sankaja 🌍	alok 📖
Daniel Lisboa 🌍	Sam Powell 📖	João Fernandes 🌍	Hong Geon-ui 🌍	Doksanbir 💻 📖 👀	Chant3ll3 📖 🌍
YongHwan Kwon 💻	Jakub Klimek 💻	believe 🌍	egg0102030405 🌍 📖	Ved Asole 💻	NewMorning 🌍
资深老萌新 🌍	Seunghwan Jeon 🌍	sugavanesh 💻	FinnS-F 💻	jerryyummy 🌍	Manoj Chowdary 💻
Aditya 📖 💻	nooynayr 📖	CYBERCRUX2 📖	Luis Mateo Hincapié Martinez 🌍 👀	guqing 💻	Sashir Estela 💻
omahs 📖	leif e. 💻	Jun Kang 💻	Kishalay Pandey 💻	drishtii7 💻	David Medina Orozco 🌍 👀
Roman Leontev 💻	Riley 💻	k1w1dev 💻	dev-yugantar 💻	Adelya 💻	gatlanagaprasanna 📖
Avinash Shukla 💻	Mayank Choudhary 💻	romannimets 💻	Joel 💻	Walyson Moises 💻

java-design-patterns's Issues

Not have private constructor in the thread-safe Singleton class ?

hello iluwatar

when I read the Singleton pattern ,the ThreadSafeLazyLoadedIvoryTower class use the default constructor method ,you don't specify it ，should it right ?
I think must add a private constructor as the IvoryTower class.
is it right?

Practical explanations

First, I'd like to thank you for providing the examples, really great job! However, I'd like more practical explanations since currently they are rather theoretical and hard to understand, don't you think?

For example the Builder pattern, I've read the explanation and honestly do not know when to use in my daily work. Wouldn't it be better just to write that you use it if you have few required and many optional construction parameters?

What is the use of UML drawing software

Can you tell me the UML diagram is used what software to draw?

DAO Design Pattern

Hi @iluwatar ,

First of all, thank you for this comprehensive repo! I haven't seen the dao design pattern among the rest. So, I am just wondering whether it is actually part of the design solutions or not.

Monitor pattern

https://en.wikipedia.org/wiki/Monitor_(synchronization)

Reactor pattern

https://en.wikipedia.org/wiki/Reactor_pattern

Async Method Invocation pattern

https://en.wikipedia.org/wiki/Asynchronous_method_invocation

HeroBuilder NullPointerException

I was reading the code and then I wondered why was used the NullPointerException in that case, won't be more readable throw a custom exception? I mean create something like BuilderException and then this can be treated in the caller method ...
*Line 97,98 from HeroBuilder.java for reference

Repository

Great job.
How about repository?
Reference: http://martinfowler.com/eaaCatalog/repository.html

Data Mapper Pattern

Hi, I'm a new user to github and I would like to help to this project. I've been researching about a few patterns and the work you've done and I think it's so cool.

In my college I've developed an application which comunicates with a MySQL Database and I had to build a pattern to make that communication work. I'm talking about the Abstract Mapper.

I have an example here: https://github.com/jesusvazquez/java_examples/tree/master/AdvancedDatabaseSystems/src/modelo/DBMapper

I'm wondering if it would be a good idea to add this pattern to your project.

Best Regards.

Hexagonal architecture

http://www.dossier-andreas.net/software_architecture/ports_and_adapters.html

Binding Properties pattern

Description

The Binding Properties design pattern is used to synchronize state between different components or objects in a system, ensuring that changes in one part are automatically reflected in another. This pattern is particularly useful in scenarios involving UI components and their underlying data models, where maintaining consistent state across various elements is crucial.

Main Elements of Binding Properties Pattern:

1. Observable Property: A property whose changes can be observed by other objects.
2. Observer: An object that subscribes to changes in the observable property and updates itself accordingly.
3. Binding Mechanism: The infrastructure that connects the observable properties with their observers, facilitating the automatic update process.
4. Two-Way Binding: An optional feature where changes in either the observable property or the observer can propagate in both directions.

References

1. Java Design Patterns Project Contribution Guidelines
2. Binding Properties Design Pattern - Wikipedia
3. Binding Properties in WikiWikiWeb

Acceptance Criteria

1. Implementation of Observable Property: Create a class representing an observable property that allows observers to register and unregister, and notifies them of changes.
2. Observer Interface: Define an interface for observers that requires an update method, which will be called when the observable property changes.
3. Binding Mechanism: Develop the infrastructure to link observable properties with their observers, supporting at least one-way binding. Optionally, implement two-way binding functionality.

Please ensure that the implementation adheres to the project contribution guidelines and includes appropriate documentation and test cases.

Parallel Change pattern

http://martinfowler.com/bliki/ParallelChange.html

Join pattern

Description:
The Join design pattern allows multiple concurrent processes or threads to be synchronized such that they all must complete before any subsequent tasks can proceed. This pattern is particularly useful in scenarios where tasks can be executed in parallel but the subsequent tasks must wait for the completion of these parallel tasks.

Main Elements of Join Pattern:

1. Task Execution: Multiple tasks are executed concurrently.
2. Synchronization Point: A join point where all tasks must converge and synchronize.
3. Completion Handling: After all tasks reach the join point, subsequent tasks can proceed.

References:

• Join pattern on Wikipedia

Acceptance Criteria:

1. Implement a JoinPattern class demonstrating the synchronization of multiple threads using the join pattern.
2. Include a comprehensive unit test that validates the correct synchronization and execution order of threads.
3. Ensure the implementation follows the project contribution guidelines as outlined in the wiki.

StarMemento would expose the internal state of Star object in memento patterns

How about making startMemento an inner class of Start class?

Pipes And Filters (EIP)

https://code.google.com/p/pipelinepattern/

Clean architecture

http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html

Cloud design patterns

http://download.microsoft.com/download/B/B/6/BB69622C-AB5D-4D5F-9A12-B81B952C1169/CloudDesignPatternsBook-PDF.pdf

Facet pattern

Description:

The Facet design pattern is used to represent different aspects or views of an object, allowing an object to expose multiple interfaces that reflect different facets of its functionality. This pattern is useful in situations where an object needs to be interacted with in various ways depending on the context or role.

Main Elements of the Facet Design Pattern:

1. Core Object: The primary object that contains the core data and functionality.
2. Facet Interfaces: Interfaces that represent different aspects or views of the core object. Each interface provides a specific subset of the core object's functionality.
3. Facet Implementations: Concrete classes that implement the facet interfaces, often acting as wrappers around the core object to provide the necessary views or functionalities.

References:

• Project Contribution Guidelines
• Facet - A Pattern for Dynamic Interfaces

Acceptance Criteria:

1. A core object should be identified or created that contains the primary data and functionality.
2. Multiple facet interfaces should be defined, each representing a different view or aspect of the core object.
3. Concrete classes implementing the facet interfaces should be created, providing the necessary views or functionalities by interacting with the core object.
4. Unit tests should be written to ensure that the facet interfaces and their implementations correctly interact with the core object and provide the expected functionalities.

Thread local storage pattern

https://en.wikipedia.org/wiki/Thread-local_storage

Scheduler pattern

Description

The Scheduler design pattern is a behavioral pattern used to manage the execution of tasks. This pattern is particularly useful in scenarios where tasks need to be executed at specific intervals or under specific conditions. The Scheduler pattern typically involves a scheduler component that manages task execution, a task component that defines the executable units of work, and a trigger or condition that initiates task execution.

Main elements of the Scheduler pattern:

1. Scheduler: Manages the execution of tasks, determining when and how often they should run.
2. Task: Represents the work to be performed, encapsulating the logic for execution.
3. Trigger/Condition: Specifies the criteria or schedule for task execution, such as time intervals or specific events.
4. Execution Context: Provides the environment in which tasks are executed, handling necessary resources and states.

References

• Project Contribution Guidelines
• Scheduler Pattern - Wikipedia

Acceptance Criteria

1. Implement the Scheduler component to manage and execute tasks based on defined triggers or conditions.
2. Define and implement a Task interface that encapsulates the logic for various tasks.
3. Create examples demonstrating the usage of the Scheduler pattern with different types of triggers/conditions and tasks.

Intercepting Filter example needs some improvement

• FilterChain executes the filters sequentially using an array. This should be changed so that the filters form a chain and call each other instead. Like in Chain of Responsibility.
• At the same time the feedback mechanism from the filters should be improved. This should be implemented with Collecting Parameter idiom. It should be possible to return multiple errors from the filter chain. The current implementation can handle only one.
• The data passed to the filters should be transformed into value object from string array. This way we can get rid of magic numbers (array index) in filters.

Active Object concurrency pattern

https://en.wikipedia.org/wiki/Active_object

Add static code analysis

Model View ViewModel (MVVM) pattern

https://en.wikipedia.org/wiki/Model_View_ViewModel

Messaging (EIP)

https://en.wikipedia.org/wiki/Messaging_pattern

Lock pattern

https://en.wikipedia.org/wiki/Lock_(computer_science)

Front Controller pattern

https://en.wikipedia.org/wiki/Front_Controller_pattern

New patterns

Is it possible that we add web application and database patterns here as well? By web application patterns, I mean

1. Single Thread pattern
2. Synchronization pattern in MVC
3. Double checked locking
4. Service locator
5. Facade
   ..... (any more that we can think of)

and the database patterns I had the data access (DAO) pattern in mind.

Module pattern

https://en.wikipedia.org/wiki/Module_pattern

Twin design pattern

http://www.ssw.uni-linz.ac.at/Research/Papers/Moe99/Paper.pdf

Add code coverage analysis

We could use this: https://github.com/trautonen/coveralls-maven-plugin

Idea.

Add the "real" project(or link to good project) where the most of patterns will be represented.And fully documented.To see how they used in real life.For example text editor.Or something else.

Monostate pattern

http://www.objectmentor.com/resources/articles/SingletonAndMonostate.pdf
http://c2.com/cgi/wiki?MonostatePattern

not a issue,just want to know

hey,I see a file ends with ucls in some package,I open it and find it is an xml format file
and my question is what kind of soft you draw it
Thanks!

Active Record pattern

Description

The Active Record design pattern is a common architectural pattern used to manage database records. It simplifies data access by encapsulating the database logic within a model class. Each instance of the model corresponds to a row in the database, and the model class includes methods for CRUD (Create, Read, Update, Delete) operations.

Main Elements of Active Record Pattern:

1. Model Class: Represents a table in the database. Each instance represents a single row.
2. CRUD Operations: Methods for Create, Read, Update, and Delete operations are defined within the model.
3. Database Connection: The model class manages the database connection.
4. Simple Queries: Basic querying capabilities are encapsulated within the model.

References

• Active Record Pattern - Martin Fowler
• Java Design Patterns Project Contribution Guidelines
• Active Record Wikipedia

Acceptance Criteria

1. A new model class should be created, representing a database table.
2. The model class should include methods for basic CRUD operations.
3. The implementation should adhere to the project’s contribution guidelines and include relevant documentation and unit tests.

Layers architectural pattern

https://en.wikipedia.org/wiki/Multilayered_architecture

Microservices patterns

http://microservices.io/patterns/index.html

Better View/Navigation ?

Heya there,
first of all, i love this resource and use it quite often. the only thing slightly annoying is the layout. Would be really awesome to view this resource in bootstrap with categories or something like that.

If something like that is done "hardcoded" the project will probably loose on contributions, so a converter of sorts should be used.

One last point, i found this Site that looks pretty good, but i dont know if it would be suitable. I also have no idea if it even works, because here everything is one single markdown document, while those at the site are multiple.
http://phpmyadmin.readthedocs.org/en/QA_4_4/
(topic is not important)

Just an idea C:

~Markus

Documentation change in DAO pattern

Removed a redundant word and added an Acronym.

Blackboard architectural pattern

Description:

Implement the Blackboard design pattern in the project. The Blackboard pattern is an architectural pattern used in situations where multiple subsystems need to collaborate to solve a problem that is beyond the individual capabilities or knowledge of each subsystem. The main elements of the Blackboard pattern include:

• Blackboard: A shared global memory structure that holds the data or state of the solution space. All subsystems read from and write to the blackboard.
• Knowledge Sources: Independent subsystems or modules that have specialized knowledge and can operate on the data in the blackboard. They can contribute partial solutions or refine existing data.
• Control Component: Manages the flow of control among the knowledge sources. It determines which knowledge source will get access to the blackboard at any given time based on certain criteria or heuristics.

References:

• https://en.wikipedia.org/wiki/Blackboard_system
• Pattern-Oriented Software Architecture, Volume 1: A System of Patterns
• Pattern-Oriented Software Architecture: A System of Patterns

Acceptance Criteria:

1. A blackboard component that allows multiple knowledge sources to read and write data.
2. At least three independent knowledge sources that interact with the blackboard to contribute to or refine the solution.
3. A control component that manages the interaction between the knowledge sources and ensures orderly access to the blackboard.

For more details on contributing to this project, please refer to our contribution guidelines.

Add virtual field pattern

There's a new (I think) pattern called the Virtual field pattern, introduced in Java 8. https://kerflyn.wordpress.com/2012/07/09/java-8-now-you-have-mixins/ Scroll half way through till you find "Another Approach".

Bug introduced by #11

@llitfkitfk You made ALL the diagrams link to files from your FORK. The BASE readme is pointing to files from a FORK.

commit hash is 97431a62af9881fa046b69b690e72d4fb4777209

Business Delegate pattern

http://www.oracle.com/technetwork/java/businessdelegate-137562.html

Readers-writer lock

https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock

Guarded suspension pattern

https://en.wikipedia.org/wiki/Guarded_suspension

please help me , thanks !

Hello, may I ask you what software tool to draw a class diagram?

I want to get it.

Can you send it to my email ? Or tell me what its name . Thank you very much!

My email : [email protected]

Null object as a singleton

It is recommended to implement null object as a singleton.

In the example, NullNode (https://github.com/iluwatar/java-design-patterns/blob/master/null-object/src/main/java/com/iluwatar/NullNode.java) is not a singleton.

Balking pattern

https://en.wikipedia.org/wiki/Balking_pattern

Proactor pattern

Description:
The Proactor design pattern is an asynchronous programming pattern used to efficiently handle multiple concurrent operations. In this pattern, the application initiates asynchronous operations and a separate handler (the Proactor) deals with the completion of these operations. The Proactor pattern is useful in scenarios where the system needs to handle a high number of I/O operations, such as in network servers and high-performance computing applications.

Main Elements of Proactor Pattern:

1. Initiator: The component that initiates asynchronous operations.
2. Asynchronous Operation: The operations that are performed asynchronously, often related to I/O tasks.
3. Completion Handler: A callback or handler that is invoked when the asynchronous operation is complete.
4. Proactor: The dispatcher that manages the completion of asynchronous operations and invokes the appropriate handlers.
5. Operation Result: The data or result obtained after the completion of the asynchronous operation.

References:

1. Proactor Design Pattern - Wikipedia
2. Asynchronous I/O - Proactor Pattern

Acceptance Criteria:

1. The implementation should include a clear separation of the main elements: Initiator, Asynchronous Operation, Completion Handler, and Proactor.
2. A working example demonstrating the Proactor pattern in a real-world scenario, such as a network server handling multiple simultaneous connections.
3. Comprehensive unit tests to verify the correct behavior of each component in the pattern, ensuring robustness and reliability.