Table Of ContentPattern-Oriented Software Architecture, Patterns for Concurrent and
Networked Objects, Volume 2
by Douglas Schmidt, Michael Stal, Hans Rohnert and Frank Buschmann
ISBN: 0471606952
John Wiley & Sons © 2000 (633 pages)
An examination of 17 essential design patterns used to build modern object-
oriented middleware systems.
1
Table of Contents
Pattern-Oriented Software Architecture—Patterns for
Concurrent and Networked Objects, Volume 2
Foreword
About this Book
Guide to the Reader
Chapter 1 - Concurrent and Networked Objects
Chapter 2 - Service Access and Configuration Patterns
Chapter 3 - Event Handling Patterns
Chapter 4 - Synchronization Patterns
Chapter 5 - Concurrency Patterns
Chapter 6 - Weaving the Patterns Together
Chapter 7 - The Past, Present, and Future of Patterns
Chapter 8 - Concluding Remarks
Glossary
Notations
References
Index of Patterns
Index
Index of Names
2
Pattern-Oriented Software
Architecture—Patterns for
Concurrent and Networked Objects,
Volume 2
Douglas Schmidt
University of California, Irvine
Michael Stal
Siemens AG, Corporate Technology
Hans Rohnert
Siemens AG, Germany
Frank Buschmann
Siemens AG, Corporate Technology
John Wiley & Sons, Ltd
Chichester · New York · Weinheim · Brisbane · Singapore · Toronto
Copyright © 2000 by John Wiley & Sons, Ltd
Baffins Lane, Chichester,
West Sussex PO19 1UD, England
National 01243 779777
International (+44) 1243 779777
e-mail (for orders and customer service enquiries):
<cs-books@wiley.co.uk>
Visit our Home Page on http://www.wiley.co.uk or http://www.wiley.com
All rights reserved. No part of this publication may be reproduced, stored in a retrieval
system, or transmitted, in any form or by any means, electronic, mechanical, photocopying,
recording, scanning or otherwise, except under the terms of the Copyright, Designs and
Patents Act 1988 or under the terms of a licence issued by the Copyright Licensing Agency,
90 Tottenham Court Road, London, UK W1P 9HE, without the permission in writing of the
publisher, with the exception of any material supplied specifically for the purpose of being
entered and executed on a computer system for exclusive use by the purchaser of the
publication.
3
Neither the author nor John Wiley & Sons, Ltd accept any responsibility or liability for loss or
damage occasioned to any person or property through using the material, instructions,
methods or ideas contained herein, or acting or refraining from acting as a result of such
use. The author and publisher expressly disclaim all implied warranties, including
merchantability or fitness for any particular purpose.
Designations used by companies to distinguish their products are often claimed as
trademarks. In all instances where John Wiley & Sons, Ltd is aware of a claim, the product
names appear in initial capital or all capital letters. Readers, however, should contact the
appropriate companies for more complete information regarding trademarks and registration.
Other Wiley Editorial Offices
John Wiley & Sons, Inc., 605 Third Avenue,
New York, NY 10158-0012, USA
Weinheim • Brisbane • Singapore • Toronto
British Library Cataloguing in Publication Data
A catalogue record for this book is available from the British Library.
ISBN 0-471-60695-2
For Sonja, Mom, and Dad
Douglas C. Schmidt
For Gisela
Michael Stal
For Regine, Anja, Sandro, and Nicolas
Hans Rohnert
For Bebé[1] and Martina
Frank Buschmann
About The Authors
Douglas C. Schmidt
Dr. Douglas Schmidt is an Associate Professor in the Electrical and Computer Engineering
department at the University of California, Irvine, USA. He is also serving as a Program
Manager in the Information Technology Office (ITO) at DARPA, leading the national
research effort on middleware. Before this he was an Associate Professor and Director of
the Center for Distributed Object Computing in the Department of Computer Science at
Washington University in St. Louis, Missouri. His research focuses on design patterns,
optimization principles, and empirical analyses of object-oriented techniques that facilitate
the development of high-performance and real-time distributed object computing middleware
running over high-speed networks and embedded system interconnects.
Doug is an internationally-recognized expert on distributed object computing patterns,
middleware frameworks, real-time CORBA, and open-source development. He has
published widely in top technical journals, conferences, and books. He was editor of the C++
4
Report magazine for several years and has co-edited several popular books on patterns
[PLoPD1] and frameworks [FJS99a] [FJS99b]. In addition to his academic research, Doug
has led the development of ACE and TAO, which are widely-used open-source middleware
frameworks that contain a rich set of reusable components implemented using the patterns
presented in this book.
In his 'spare' time, he enjoys ballroom dancing with his wife Sonja, weight-lifting, guitar
playing, world history, and Chevrolet Corvettes.
Michael Stal
Michael Stal joined the Corporate Technology department of Siemens AG in Munich,
Germany in 1991. In his previous work he gained extensive experience developing software
for compilers and computer graphics. He worked on runtime type information for C++ and
served on the C++ standardization group X3J16. Since 1992 Michael's work has focused on
the development of concurrent and distributed object-oriented systems using Sockets,
CORBA, COM, and Java. Michael is Siemens' primary contact on CORBA at the OMG and
is head of the Distributed Object Computing Group at Siemens's Corporate Technology
department. He co-authored the first POSA volume A System of Patterns.
Michael's main research interests focus on methods for developing distributed systems
efficiently and on patterns for describing the architecture of middleware platforms. In this
context he has published articles in many magazines and given talks at many conferences.
In addition, he is Editor-in-Chief of Java Spektrum, the major German magazine on the Java
platform, as well as a columnist and member of the advisory board for Objektspektrum, the
major German magazine on object technology.
In his spare time Michael attends soccer matches, supports his favorite team Bayern
München, visits Munich beer gardens, tries to prevent his cats from destroying his
apartment, watches movies, and reads books on physics, philosophy and humor. He is fan
of Douglas Adams, Scott Adams, and Terry Pratchett.
Hans Rohnert
Dr. Hans Rohnert is a Senior Software Engineer at the Communication Devices business
unit of Siemens AG in Munich, Germany. His primary aims are exploiting promising software
technologies and introducing them into new products, such as next-generation mobile
phones. His professional interests are software architecture, design patterns, and real-world
programming. He has presented numerous talks on subjects ranging from dynamic graph
algorithms to embedded Java virtual machines.
Hans is currently a member of the expert groups defining the small footprint KVM Java
virtual machine and its libraries for use in small devices. His programming projects have
included server-side modules for embedded servers, work flow in C++, base support for
ATM switching, Java GUI front-ends for CORBA clients, and HTTP clients. He is also a co-
author of the first POSA volume A System of Patterns and a co-editor of the fourth book in
the PLoPD series [PLoPD4]. As a graduate student he performed original research on
combinatorial algorithms, publishing and lecturing on them early in his career.
Hans is an ambitious tennis player, with more matches lost than won. He also enjoys
exploring the nearby mountains, rock-climbing, and cross-country skiing. His most important
'hobby', however, is his family, most notably a new baby born during the hectic final phase of
writing this book.
Frank Buschmann
5
Frank Buschmann is Principal Senior Software Engineer at Siemens Corporate Technology
in Munich, Germany. His research interests include object technology, software architecture,
frameworks, and patterns. He has published widely in all these areas, most visibly in his co-
authorship of the first POSA volume A System of Patterns. Frank was a member of the ANSI
C++ standardization committee X3J16 from 1992 to 1996. Frank initiated and organized the
first conference on patterns held in Europe, EuroPLoP 1996, and is also a co-editor of the
third book in the PLoPD series [PLoPD3]. In his development work Frank has led design and
implementation efforts for several large-scale industrial software projects, including business
information, industrial automation, and telecommunication systems.
When not at work Frank spends most of his time enjoying life with his wife Martina, watching
the time go by in Munich beer gardens, having fun biking, skiing, and horse-riding, getting
excited when watching his favorite soccer team Borussia Dortmund, dreaming when
listening to a performance at the Munich opera, and relaxing with rare Scotch single malts
before bedtime.
This book has been written by the award-winning team responsible for the first POSA
volume A System of Patterns, joined in this volume by Douglas C. Schmidt from University of
California, Irvine (UCI), USA.
[1]Bebé, July 3, 1999
6
Pattern-Oriented Software Architecture—Patterns for Concurrent and Networked
Objects, Volume 2............................................................................................................3
Foreword..........................................................................................................................10
About this Book
................................................................................................12
Intended Audience.................................................................................................13
Structure and Content...........................................................................................13
Acknowledgments..................................................................................................14
Guide to the Reader
....................................................................................17
Introduction to Patterns.........................................................................................17
Structure and Content...........................................................................................17
Pattern Form...........................................................................................................18
Background Reading.............................................................................................19
Chapter 1: Concurrent and Networked Objects
...............20
Overview....................................................................................................................20
1.1 Motivation...........................................................................................................20
1.2 Challenges of Concurrent and Networked Software.........................22
Challenge 1: Service Access and Configuration...............................................24
Challenge 2: Event Handling................................................................................27
Challenge 3: Concurrency....................................................................................29
Challenge 4: Synchronization..............................................................................31
Other Challenges for Networked Software........................................................32
1.3 A Case Study: Designing a Concurrent Web Server.........................33
Overview of the JAWS Framework.....................................................................35
Applying Patterns to Resolve Common Design Challenges in JAWS...........36
Encapsulating Low-level Operating System APIs.............................................36
Decoupling Event Demultiplexing and Connection Management from
Protocol Processing...............................................................................................37
Scaling Up Server Performance via Multi-threading........................................38
Implementing a Synchronized Request Queue.................................................40
Minimizing Server Threading Overhead.............................................................40
Leveraging Asynchronous I/O Effectively..........................................................42
Enhancing Server Configurability........................................................................44
Other Patterns Used to Implement JAWS..........................................................45
1.4 Wrapping Up.....................................................................................................46
Chapter 2: Service Access and Configuration Patterns
...........................................................................................................................................47
Overview....................................................................................................................47
Wrapper Facade.....................................................................................................48
Example...................................................................................................................48
Context.....................................................................................................................52
7
Problem....................................................................................................................52
Component Configurator.....................................................................................76
Interceptor...............................................................................................................101
Extension Interface..............................................................................................125
Chapter 3: Event Handling Patterns
..........................................153
Overview..................................................................................................................153
Reactor.....................................................................................................................154
Proactor....................................................................................................................181
Asynchronous Completion Token..................................................................218
Acceptor-Connector............................................................................................235
Chapter 4: Synchronization Patterns
........................................268
Overview..................................................................................................................268
Scoped Locking....................................................................................................268
Strategized Locking.............................................................................................276
Thread-Safe Interface.........................................................................................287
The LegacyFacade EJB Component Deployment Descriptor.............293
Deployment Descriptors for the EJB 2.0 Specification..................................294
Deployment Descriptors for the EJB 1.1 Specification..................................300
Deploying the EJB JAR into the Application Server.......................................305
Double-Checked Locking Optimization........................................................306
Chapter 5: Concurrency Patterns
.................................................317
Overview..................................................................................................................317
Active Object..........................................................................................................318
Monitor Object.......................................................................................................343
Half-Sync/Half-Async..........................................................................................363
Leader/Followers..................................................................................................379
Thread-Specific Storage....................................................................................400
Chapter 6: Weaving the Patterns Together
........................426
6.1 From Individual Patterns to Pattern Languages................................426
No Pattern is an Island........................................................................................426
Towards Pattern Languages..............................................................................427
6.2 A Pattern Language for Middleware and Applications....................428
The Pattern Language in Detail.........................................................................429
A Discussion of the Pattern Language.............................................................435
6.3 Beyond Concurrency and Networking..................................................436
Graphical User Interfaces...................................................................................436
Components..........................................................................................................437
General Programming.........................................................................................437
6.4 Pattern Languages versus Pattern Systems......................................437
Chapter 7: The Past, Present, and Future of Patterns
.........................................................................................................................................441
8
7.1 What Has Happened in the Past Four Years.....................................441
Patterns..................................................................................................................441
Pattern Systems and Pattern Languages........................................................442
Methods and Tools..............................................................................................442
Algorithms and Data Structures.........................................................................443
Formalizing Patterns............................................................................................443
7.2 Where Patterns are Now............................................................................443
7.3 Where Patterns are Going.........................................................................444
Patterns..................................................................................................................444
Pattern Languages...............................................................................................446
Experience Reports, Methods, and Tools........................................................447
Pattern Documentation........................................................................................447
Formalizing Patterns and Pattern Languages.................................................448
Software Development Processes and Organizations...................................448
Education...............................................................................................................448
Our Long-Term Vision.........................................................................................449
7.4 A Parting Thought on Predicting the Future.......................................449
Chapter 8: Concluding Remarks
...................................................451
Notations
...............................................................................................................452
Class-Responsibility-Collaborator Cards..........................................................452
UML Class Diagrams...........................................................................................452
UML Sequence Diagrams...................................................................................454
UML Statechart Diagrams...................................................................................455
References..............................................................................................................457
9
Foreword
Middleware is the set of services, protocols, and support utilities providing the 'plumbing' that
makes modern distributed systems and applications possible—the infrastructure that
underlies web services, distributed objects, collaborative applications, e-commerce systems,
and other important platforms. Not long ago, the term middleware was rarely heard, and
middleware developers were rarer still. But over the past decade, the term, the research and
practice, and its impact have become ubiquitous. Yet, until now, there has not been a book
describing how to construct networked and concurrent object-oriented (OO) middleware, so
its design has remained something of a black art. This book demystifies middleware
construction, replacing the need to have an expert looking over your shoulder with well-
reasoned, empirically-guided accounts of common design problems, forces, successful
solutions, and consequences.
As is true for most concepts, nailing down the boundaries of middleware is hard.
Conventionally, it consists of the software needed to build systems and applications, yet is
not otherwise an intrinsic part of an operating system kernel. But it is not always possible to
find middleware where you first look for it: middleware can appear in libraries and
frameworks, operating systems and their add-ons, Java virtual machines and other run-time
systems, large-grained software components, and in portions of end-products such as web
services themselves.
This book is not a textbook surveying middleware or the types of applications and distributed
system architectures you can devise using middleware. It instead presents a pattern
language that captures the design steps leading to the construction of the OO
communication support involved in most middleware. Many of the patterns described in this
book also have utility in both higher-level and lower-level systems and applications that are
not based directly upon middleware.
This book emphasizes practical solutions over theoretical formalisms. The basic ideas
behind many presented patterns are well-known to experienced system developers—for
example, dispatching, demultiplexing, callbacks, and configuration—and are sometimes
variants of more general OO patterns—for example, proxies, adapters, and facades. This
book's main contribution centers on in-depth engineering solutions based upon these ideas.
Middleware developers must resolve a wide range of forces including throughput,
responsiveness, dependability, interoperability, portability, extensibility, and accommodating
legacy software. The diversity and severity of these forces accounts for the complexity of
middleware patterns, as opposed to those seen in smaller-scale OO applications and
concurrent programming.
The multitude of such forces, combined with years of engineering experience, often lead to a
multitude of design considerations and engineering trade-offs separating an idea from its
expression in middleware frameworks. The pattern description format used in this book
helps to simplify this process by presenting solutions as series of concrete design steps.
Many of these steps in turn invoke additional patterns. Together they form a pattern
language, enabling developers to traverse from pattern to pattern while designing services
and applications.
As mentioned by the authors, some of the ideas and techniques discussed in this book are
complementary to those seen for example in W. Richard Stevens's pioneering books (e.g.,
[Ste98]) on network programming. The main point of departure is the unrelenting focus on
higher-level design issues. Rather than, for example, discussing the ins and outs of the Unix
select () call, this book explains how to build a composable and flexible framework—a
Reactor—based on select () and other operating system calls.
10
