Guarded suspension
In concurrent programming, guarded suspension[1] is a software design pattern for managing operations that require both a lock to be acquired and a precondition to be satisfied before the operation can be executed. The guarded suspension pattern is typically applied to method calls in object-oriented programs, and involves suspending the method call, and the calling thread, until the precondition (acting as a guard) is satisfied.
Usage
Because it is blocking, the guarded suspension pattern is generally only used when the developer knows that a method call will be suspended for a finite and reasonable period of time. If a method call is suspended for too long, then the overall program will slow down or stop, waiting for the precondition to be satisfied. If the developer knows that the method call suspension will be indefinite or for an unacceptably long period, then the balking pattern may be preferred.
Implementation
In Java, the Object class provides the wait()
and notify()
methods to assist with guarded suspension. In the implementation below, originally found in Kuchana (2004), if there is no precondition satisfied for the method call to be successful, then the method will wait until it finally enters a valid state.
public class Example { synchronized void guardedMethod() { while (!preCondition()) { try { // Continue to wait wait(); // … } catch (InterruptedException e) { // … } } // Actual task implementation } synchronized void alterObjectStateMethod() { // Change the object state // … // Inform waiting threads notify(); } }
An example of an actual implementation would be a queue object with a get
method that has a guard to detect when there are no items in the queue. Once the put
method notifies the other methods (for example, a get
method), then the get
method can exit its guarded state and proceed with a call. Once the queue is empty, then the get
method will enter a guarded state once again.
See also
- Balking pattern is an alternative pattern for dealing with a precondition
- Guarded Command Language includes a similar language construct
- Readers–writer lock
Notes
- ^ Lea, Doug (2000). Concurrent Programming in Java Second Edition. Reading, MA: Addison-Wesley. ISBN 0-201-31009-0.
References
- Kuchana, Partha (2004). "Software Architecture Design Patterns in Java" (Document). Boca Raton, Florida: Auerbach Publications..
- v
- t
- e
patterns
Creational |
|
---|---|
Structural | |
Behavioral |
patterns
- Active object
- Balking
- Binding properties
- Double-checked locking
- Event-based asynchronous
- Guarded suspension
- Join
- Lock
- Monitor
- Proactor
- Reactor
- Read–write lock
- Scheduler
- Scheduled-task pattern
- Semaphore
- Thread pool
- Thread-local storage
patterns
patterns
- Christopher Alexander
- Erich Gamma
- Ralph Johnson
- John Vlissides
- Grady Booch
- Kent Beck
- Ward Cunningham
- Martin Fowler
- Robert Martin
- Jim Coplien
- Douglas Schmidt
- Linda Rising
![]() | This computer-programming-related article is a stub. You can help Wikipedia by expanding it. |
- v
- t
- e