Design patterns, the big picture, Part 1: Design pattern history and classification
Understanding the concept and use of design patterns in software development
By Jeff Friesen, JavaWorld.com, 11/21/12
Page 6 of 6
- Active object: Decouples method execution from method invocation for objects in which each object resides in its own thread of control.
The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests
- Balking: Only executes an action on an object when the object is in a particular state. For example, an object reads a file and provides
methods to access file content. When the file is not open and an attempt is made to call a method to access content, the object
"balks" at the request.
- Binding properties: Combines multiple observers to force properties in different objects to be synchronized or coordinated in some way.
- Double-checked locking: Reduces the overhead of acquiring a lock by first testing the locking criterion (the "lock hint") without actually acquiring
the lock. The lock is acquired only when the locking criterion check indicates that locking is required.
- Event-based asynchronous: A concurrency pattern for the asynchronous invocation of an object's potentially long-running methods.
- Guarded suspension: Manages operations that require both a lock to be acquired and a precondition to be satisfied before the operation can be
executed.
- Lock: A mechanism to temporarily make some aspect of an object unmodifiable or to suppress unneeded update notifications.
- Messaging design pattern (MDP): Allows the interchange of information (that is, messages) between components and applications.
- Monitor object: An object whose methods are subject to mutual exclusion, thus preventing multiple objects from erroneously trying to use
it at the same time.
- Reactor: An event-handling pattern for handling service requests delivered concurrently to a service handler by one or more inputs.
The service handler then demultiplexes the incoming requests and dispatches them synchronously to the associated request handlers.
- Read-write lock: A lock that allows concurrent read access to an object, but requires exclusive access for write operations.
- Scheduler: A concurrency pattern used to explicitly control when threads may execute single-threaded code; for example, multiple threads
wanting to write data to the same file.
- Thread pool: A concurrency pattern in which a number of threads are created to perform various tasks, which are usually organized in
a queue. Typically, there are many more tasks than threads. Thread Pool can be considered a special case of the Object Pool
creational pattern.
- Thread-specific storage: A concurrency pattern in which static or global memory is localized to a thread. Each thread has its own copy of this memory.
The previous lists describe many commonly used (and some less commonly used) software design patterns and are not exhaustive.
See Resources for further reading.
Conclusion to Part 1
Design Patterns: Elements of Reusable Object-Oriented Software significantly impacted the field of software design patterns. In Part 2, I'll present a helpful way to learn the foundational
design patterns presented by the Gang of Four authors, revisit the book's Visitor pattern from a Java technology perspective,
and discuss some possible downsides of the GoF patterns and of using software design patterns generally. In the meantime,
be sure to check the Resources section for a listing of design pattern tutorials on JavaWorld and elsewhere.
About the author
Jeff Friesen is a freelance tutor and software developer with an emphasis
on Java and Android. In addition to writing Java and Android books for
Apress, Jeff has written numerous articles on
Java and other technologies for JavaWorld,
informIT,
Java.net, and
DevSource. Jeff can be contacted via his
website at
TutorTutor.ca.
Read more about Core Java in JavaWorld's Core Java section.