docs: Explanation for guarded suspension (#2752)

* translation for step-builder and table-module and unit-of-work and update-method and value-object to Chinese * fix a translation error * Add explanation for guarded suspension * delete previous modifications

Author: egg0102030405

guarded-suspension/README.md

@@ -15,6 +15,78 @@ Use Guarded suspension pattern to handle a situation when you want to execute a
 ## Applicability
 Use Guarded Suspension pattern when the developer knows that the method execution will be blocked for a finite period of time
 
+## Explanation
+
+Real world example
+
+> When we reserve a dining room online and arrive to find it unready, the manager has it cleaned while we wait. 
+> Once ready, we're escorted to the room. This process exemplifies the Guarded Suspension pattern.
+
+In plain words
+
+> Guarded Suspension pattern is used when one thread waits for the result of another thread's execution.
+
+Wikipedia says
+
+> In concurrent programming, Guarded Suspension manages operations requiring a lock
+> and a precondition, delaying execution until the precondition is met.
+
+**Programmatic Example**
+
+The `GuardedQueue` class encapsulates a queue, and provides two synchronized methods, `get` and `put`.
+The `get` method waits if the queue is empty, and the `put` method adds an item to the queue and notifies waiting threads:
+
+```java
+public class GuardedQueue {
+private final Queue<Integer> sourceList = new LinkedList<>();
+
+ public synchronized Integer get() {
+ while (sourceList.isEmpty()) {
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ return sourceList.peek();
+ }
+
+ public synchronized void put(Integer e) {
+ sourceList.add(e);
+ notify();
+ }
+}
+
+public class App {
+public static void main(String[] args) {
+GuardedQueue guardedQueue = new GuardedQueue();
+ExecutorService executorService = Executors.newFixedThreadPool(3);
+
+ // Here we create the first thread which is supposed to get from guardedQueue
+ executorService.execute(guardedQueue::get);
+
+ try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ // Here we create the second thread which is supposed to put to guardedQueue
+ executorService.execute(() -> {
+ guardedQueue.put(20);
+ });
+
+ executorService.shutdown();
+ try {
+ executorService.awaitTermination(30, TimeUnit.SECONDS);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+}
+```
+
+
 ## Related patterns
 
 * Balking