Balking Pattern is used to prevent an object from executing certain code if it is an

incomplete or inappropriate state

Balking Pattern is used to prevent an object from executing a certain code if it is in an incomplete

or inappropriate state.

Real world example

In plain words

Wikipedia says

**Programmatic Example**

In this example implementation,`WashingMachine` is an object that has two states in which it can

be: ENABLED and WASHING. If the machine is ENABLED, the state changes to WASHING using a thread-safe

method. On the other hand, if it already has been washing and any other thread executes`wash()`

it won't do that and returns without doing anything.

Here are the relevant parts of the`WashingMachine` class.

publicclassWashingMachine {

privatefinalDelayProvider delayProvider;

privateWashingMachineState washingMachineState;

publicWashingMachine(DelayProviderdelayProvider) {

this.delayProvider= delayProvider;

this.washingMachineState=WashingMachineState.ENABLED;

}

publicWashingMachineStategetWashingMachineState() {

return washingMachineState;

}

publicvoidwash() {

synchronized (this) {

var machineState= getWashingMachineState();

LOGGER.info("{}: Actual machine state: {}",Thread.currentThread().getName(), machineState);

if (this.washingMachineState==WashingMachineState.WASHING) {

LOGGER.error("Cannot wash if the machine has been already washing!");

return;

}

this.washingMachineState=WashingMachineState.WASHING;

}

LOGGER.info("{}: Doing the washing",Thread.currentThread().getName());

this.delayProvider.executeAfterDelay(50,TimeUnit.MILLISECONDS,this::endOfWashing);

}

publicsynchronizedvoidendOfWashing() {

washingMachineState=WashingMachineState.ENABLED;

LOGGER.info("{}: Washing completed.",Thread.currentThread().getId());

}

}

Here's the simple`DelayProvider` interface used by the`WashingMachine`.

publicinterfaceDelayProvider {

voidexecuteAfterDelay(longinterval,TimeUnittimeUnit,Runnabletask);

}

Now we introduce the application using the`WashingMachine`.

publicstaticvoid main(String... args) {

finalvar washingMachine=newWashingMachine();

var executorService=Executors.newFixedThreadPool(3);

for (int i=0; i<3; i++) {

executorService.execute(washingMachine::wash);

}

executorService.shutdown();

try {

executorService.awaitTermination(10,TimeUnit.SECONDS);

}catch (InterruptedException ie) {

LOGGER.error("ERROR: Waiting on executor service shutdown!");

Thread.currentThread().interrupt();

}

}

Here is the console output of the program.

![alt text](./etc/balking.png"Balking")

Use the Balking pattern when

*you want to invoke an action on an object only when it is in a particular state

*objects are generally only in a state that is prone to balking temporarily

but for an unknown amount of time

*You want to invoke an action on an object only when it is in a particular state

*Objects are generally only in a state that is prone to balking temporarily but for an unknown

amount of time

* Guarded Suspension Pattern

* Double Checked Locking Pattern

*[Guarded Suspension Pattern](https://java-design-patterns.com/patterns/guarded-suspension/)

*[Double Checked Locking Pattern](https://java-design-patterns.com/patterns/double-checked-locking/)

*[Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML, 2nd Edition, Volume 1](https://www.amazon.com/gp/product/0471227293/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0471227293&linkId=0e39a59ffaab93fb476036fecb637b99)

publicclassApp {

}

executorService.shutdown();

try {

executorService.awaitTermination(10,TimeUnit.SECONDS);

if (!executorService.awaitTermination(10,TimeUnit.SECONDS)) {

executorService.shutdownNow();

}

}catch (InterruptedExceptionie) {

LOGGER.error("ERROR: Waiting on executor service shutdown!");

Thread.currentThread().interrupt();

}

}

}