docs: add diagrams for lazy loading, leader election, leader followers, lockable object

Author: iluwatar

Diff for: lazy-loading/README.md

@@ -35,6 +35,10 @@ Wikipedia says
 
 > Lazy loading (also known as asynchronous loading) is a technique used in computer programming, especially web design and web development, to defer initialization of an object until it is needed. It can contribute to efficiency in the program's operation if properly and appropriately used. This makes it ideal in use cases where network content is accessed and initialization times are to be kept at a minimum, such as in the case of web pages. For example, deferring loading of images on a web page until they are needed for viewing can make the initial display of the web page faster. The opposite of lazy loading is eager loading.
 
+Sequence diagram
+
+![Lazy Loading Sequence Diagram](./etc/lazy-loading-sequence-diagram.png)
+
 ## Programmatic Example of Lazy Loading Pattern in Java
 
 The Lazy Loading design pattern is a performance optimization technique that delays the initialization of an object or a costly computation until it's absolutely necessary. This pattern can significantly improve the performance of your application by avoiding unnecessary computation and reducing memory usage.

Diff for: lazy-loading/etc/lazy-loading-sequence-diagram.png

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In distributed computing, leader election is the process of designating a single process as the organizer of some task distributed among several computers (nodes). Before the task has begun, all network nodes are either unaware which node will serve as the "leader" (or coordinator) of the task, or unable to communicate with the current coordinator. After a leader election algorithm has been run, however, each node throughout the network recognizes a particular, unique node as the task leader.
 
+Sequence diagram
+
+![Leader Election Sequence Diagram](./etc/leader-election-sequence-diagram.png)
+
 ## Programmatic Example of Leader Election Pattern in Java
 
 The Leader Election pattern is a design approach that enables a distributed system to select one node as the coordinator or leader to manage tasks and maintain order, while other nodes operate as followers. This pattern is particularly useful in distributed systems where one node needs to act as a central coordinator for a specific function or decision-making process.
@@ -137,10 +141,6 @@ The `RingApp` class implements the Ring algorithm for leader election. In this a
 
 These examples demonstrate how the Leader Election pattern can be implemented in different ways to suit the specific requirements of a distributed system.
 
-## Detailed Explanation of Leader Election Pattern with Real-World Examples
-
-![Leader Election](./etc/leader-election.urm.png "Leader Election pattern class diagram")
-
 ## When to Use the Leader Election Pattern in Java
 
 Use the Leader Election pattern in Java applications where:

Diff for: leader-election/README.md

@@ -29,6 +29,10 @@ In plain words
 
 > Select one server in the cluster as a leader. The leader is responsible for taking decisions on behalf of the entire cluster and propagating the decisions to all the other servers.
 
+Sequence diagram
+
+![Leader-Followers Sequence Diagram](./etc/leader-followers-sequence-diagram.png)
+
 ## Programmatic Example of Leader-Followers Pattern in Java
 
 The Leader-Followers pattern is a concurrency design pattern where one thread (the leader) waits for work to arrive, de-multiplexes, dispatches, and processes the work, thereby enhancing CPU cache affinity and reducing event dispatching latency. Once the leader finishes processing the work, it promotes one of the follower threads to be the new leader. This pattern is useful for enhancing CPU cache affinity, minimizing locking overhead, and reducing event dispatching latency.

Diff for: leader-election/etc/leader-election-sequence-diagram.png

@@ -35,6 +35,10 @@ Wikipedia says
 
 > In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive that prevents state from being modified or accessed by multiple threads of execution at once. Locks enforce mutual exclusion concurrency control policies, and with a variety of possible methods there exist multiple unique implementations for different applications.
 
+Sequence diagram
+
+![Lockable Object Sequence Diagram](./etc/lockable-object-sequence-diagram.png)
+
 ## Programmatic Example of Lockable Object Pattern in Java
 
 The Lockable Object pattern is a concurrency control design pattern in Java that allows only one thread to access a shared resource at a time, ensuring mutual exclusion and preventing data corruption. Instead of using the `synchronized` keyword on the methods to be synchronized, the object which implements the Lockable interface handles the request.
@@ -127,10 +131,6 @@ public class App implements Runnable {
 
 This example demonstrates the Lockable Object pattern by showing how multiple threads can attempt to acquire a lock on a shared resource, with only one thread being able to acquire the lock at a time.
 
-## Detailed Explanation of Lockable Object Pattern with Real-World Examples
-
-![Lockable Object](./etc/lockable-object.urm.png "Lockable Object class diagram")
-
 ## When to Use the Lockable Object Pattern in Java
 
 * Use the Lockable Object pattern in Java when you need to prevent data corruption by multiple threads accessing a shared resource concurrently, ensuring thread safety and robust shared resource management.