Guarded Suspension Design Pattern and Balking Design Pattern

These patterns have something to do with Concurrency Control. When we got to use a resource it needs to be available for use. There happens to be scenarios when a resource being accessed by one person might not be available for another person. Here comes two different scenarios which lead to these two design patterns.

• First scenario may be the second person can afford to wait to access the resource (Guarded Suspension Design Pattern).
• Second scenario may be the person cannot afford to wait until the previous person has finished his transaction(Balking Design Pattern).

OK so what is Guarded Design pattern?

Consider a scenario where only one out of hundred souls are allowed to enter into heaven. So whenever the method opendoor is called on the heaven object it has to check a condition say the person who is standing in front of the door is one in hundred that is in multiples of hundred else the hell's door's should be opened. So here the Heaven.opendoor() method is guarded by the condition as mentioned above. the door has to wait until the condition isHundredthPerson==true is satisfied. So we have suspended the call to the Heaven.opendoor() method and gaurded it by a condition isHundredthPerson==true.

Also consider the situation where in ancient times when there was only one telephone connection for the whole village. People got to wait untill the telephone is free and available (ie. satisfy the condition isPhoneAvailable==true). So the sage of phone is suspended by the guardians (current user of the telephone because he has made the condition isPhoneAvailable==false).Guarded Suspension seems top be the design pattern of ancient times (lol).

Now Comes Balking Design pattern...

If we do not have a choice to wait then we got to use Balking Design Pattern. A Simple scenario to visualize this scenario will be the load balancing mechanisms of the web servers. They have no choice of waiting till the load has gone down to some level and then give access to the new requests. Every millisecond delay in loading a website is equivalent to loosing 100 customers which i believe no one in this world will afford to loose. So we got to make use of the balking design pattern to retain customers and increase them exponentially. We can solve the issue of not waiting by starting the process in parallel.

There is no need to wait. Whenever we want to access a resource we can just go ahead use it. Resources are always available. This drives us towards providing infinite resources which is almost impossible. So we got to create an illusion as if resources are always available by replicating the existing resources. Balking is referred as a anti pattern by few technologists. And is also similar to double checked Locking Pattern.

This makes the Balking the Next Generation Design pattern by showcasing unlimited capability by any given service. (lol).