Balking pattern
Software design pattern
The balking pattern is a software design pattern that only executes an action on an object when the object is in a particular state. For example, if an object reads ZIP files and a calling method invokes a get method on the object when the ZIP file is not open, the object would "balk" at the request. In the Java programming language, for example, an IllegalStateException might be thrown under these circumstances. In C# it would be InvalidOperationException.
There are some specialists in this field who consider balking more of an anti-pattern than a design pattern. If an object cannot support its API, it should either limit the API so that the offending call is not available, or so that the call can be made without limitation. It should:
- Be created in a "sane state";
- not make itself available until it is in a sane state;
- become a facade and answer back an object that is in a sane state.
01Usage
Objects that use this pattern are generally only in a state that is prone to balking temporarily but for an unknown amount of time. If objects are to remain in a state which is prone to balking for a known, finite period of time, then the guarded suspension pattern may be preferred.
02Implementation
Below is a general, simple example for an implementation of the balking pattern. As demonstrated by the definition above, notice how the "synchronized" line is utilized. If there are multiple calls to the job method, only one will proceed while the other calls will return with nothing. Another thing to note is the jobCompleted() method. The reason it is synchronized is because the only way to guarantee another thread will see a change to a field is to synchronize all access to it. Actually, since it is a Boolean variable, it could be left not explicitly synchronized, only declared volatile - to guarantee that the other thread will not read an obsolete cached value.
public class Example { private boolean jobInProgress = false; public void job() { synchronized (this) { if (jobInProgress) { return; } jobInProgress = true; } // Code to execute job goes here // ... jobCompleted(); } void jobCompleted() { synchronized (this) { jobInProgress = false; } } }Sources and credits
This article is adapted from the Wikipedia article “Balking pattern”, written by its contributors and licensed under CC BY-SA 4.0. Fathomly has changed the layout, removed citation markers, navigation and maintenance notices, and adjusted punctuation. This adapted version is shared under the same license. For references, see the original article.
Fathomly is not affiliated with or endorsed by the Wikimedia Foundation. Spotted a problem? Tell us.