构建网络化并发对象的中间件设计模式

需积分: 10 128 浏览量更新于2024-07-22 收藏 3.88MB PDF 举报

"Pattern-Oriented Software Architecture, Volume 2" 是一本专注于构建并发和网络化对象中间件设计模式的书籍，由Douglas Schmidt、Michael Stal、Hans Rohnert和Frank Buschmann合著，由John Wiley & Sons于2000年出版。这本书揭示了构建网络化和并发面向对象（OO）中间件的设计原则，通过17个关键设计模式，为读者提供了现代分布式系统和应用基础设施建设的指导。书中的内容包括以下几个核心章节： 1. **并发和网络化对象**：这部分介绍了在并发和网络环境中处理对象的基本概念和挑战。 2. **服务访问和配置模式**：讨论如何设计和实现服务的访问接口以及如何管理配置信息，以支持动态和灵活的系统。 3. **事件处理模式**：涵盖了处理分布式系统中事件传播和响应的策略，如发布/订阅模型、事件队列等。 4. **同步模式**：阐述了在并发环境下确保数据一致性、避免竞态条件的同步机制，如锁、信号量和条件变量等。 5. **并发模式**：关注线程管理和并发控制，如工作窃取、线程池和任务调度等策略。 6. **模式的交织**：讲解如何将上述模式结合在一起，构建出健壮和高效的分布式系统架构。 7. **模式的过去、现在与未来**：回顾了设计模式的历史，讨论了当前的应用，并展望了未来的发展趋势。 8. **结论性评论**：总结了全书内容，并对设计模式在软件工程中的重要性和影响进行了反思。此外，书中还包含术语表、符号说明、参考文献、模式索引和人物索引，为读者提供了全面的学习资源。这本书是针对那些希望深入理解并实践并发和网络对象中间件设计的专业人士的宝贵指南。它不仅提供了解决常见问题的经过验证的解决方案，而且帮助开发者在设计分布式系统时做出明智的决策，从而避免中间件设计中的“黑艺术”现象。通过学习这些模式，开发者可以更好地构建稳定、可扩展和易于维护的系统，适应不断变化的网络和并发需求。

We are also grateful for the support from colleagues and sponsors of our research on

patterns and the ACE and TAO middleware frameworks, notably the contributions of Ron

Akers (Motorola), Al Aho (Lucent), Steve Bachinsky (SAIC), Detlef Becker (Siemens), Jim

Blaine (Washington University), John Buttitto (Motorola), Becky Callison (Boeing), Wei

Chiang (Nokia), Russ Claus (NASA), Joe Cross (Lockheed Martin), Bryan Doerr (Boeing),

Karlheinz Dorn (Siemens), Sylvester Fernandez (Lockheed Martin), Andreas Geisler

(Siemens), Helen Gill (DARPA), Trey Grubbs (Raytheon), Jody Hagins (ATD), Andy Harvey

(Cisco), Thomas Heimke (Siemens), Kalai Kalaichelvan (Nortel), Arvind Kaushal (Motorola),

Steve Kay (Tellabs), Chandra Kintala (Lucent), Gary Koob (DARPA), Sean Landis

(Motorola), Rick Lett (Sprint), Joe Loyall (BBN), Mike Masters (NSWC), Ed Mays (US Marine

Corps), John Mellby (Raytheon), Dave Meyer (Virtual Technology), Eileen Miller (Lucent),

Stan Moyer (Telcordia), Russ Noseworthy (Object Sciences), Guru Parulkar (Cisco), Dan

Paulish (Siemens), James Plamondon (Microsoft), Dieter Quehl (Siemens), Lucie Robillard

(US Air Force), Allyn Romanow (Cisco), Rick Schantz (BBN), Steve Shaffer (Kodak), Dave

Sharp (Boeing), Naval Sodha (Ericsson), Brian Stacey (Nortel), Paul Stephenson (Ericsson),

Umar Syyid (Hughes), Dave Thomas (OTI), Lothar Werzinger (Krones), Shalini Yajnik

(Lucent), and Tom Ziomek (Motorola).

Very special thanks go to Steve Rickaby, our copy editor, for enhancing our written material.

In addition, we thank our editor, Gaynor Redvers-Mutton, and everyone else at John Wiley &

Sons who made it possible to publish this book. This is the second book fostered by Gaynor

and Steve. Their support has been superb and we look forward to working with them on

forthcoming POSA volumes.

Finally, we would like to express our deepest gratitude to the late Richard Stevens, whose

seminal books inspired us to explore the wonders of network programming so many years

ago. His spirit pervades this book.

Guide to the Reader

"Cheshire-Puss will you tell me, please, which way I ought to go from here?"

"That depends a good deal on where you want to get to," said the Cat.

"I don't much care where—," said Alice.

"Then it doesn't matter which way you go," said that cat.

"—so long as I get somewhere" Alice added as an explanation.

"Oh, you're sure to do that," said the Cat, "if you only walk long enough."

Louis Carroll, "Alice in Wonderland"

This book is structured so you can read it cover-to-cover. If you know where you want to get

to, however, you may want to choose your own route through the book. In this case, the

following hints can help you decide which topics to focus upon and the order in which to read

them.

Introduction to Patterns

If this book is your initial exposure to patterns, we suggest you first read the introduction to

patterns in [POSA1] and [GoF95], which explore the concepts and terminology related to

patterns for software architectures and designs. In particular, all the patterns presented in

this book build upon the conceptual foundation for patterns specified in [POSA1]:

§ The definition of patterns for software architectures

§ The categorization of these patterns into architectural patterns, design patterns, and

idioms

[1]

and

§ The pattern description format

Moreover, the implementations of many patterns in this book are enhanced by using

patterns from [POSA1] and [GoF95]. To guide the application of the patterns in production

software development projects we therefore suggest you keep all three books handy.

[1]

See the Glossary for a definition of these pattern categories.

Structure and Content

The first chapter in this book, Concurrent and Networked Objects, describes the key

challenges of designing concurrent and networked systems. It also outlines the scope and

context for the patterns we present. Finally, it presents a case study that applies eight

patterns in this book to develop a concurrent Web server.

Sixteen pattern descriptions and one idiom form the main part of this book. We group them

into four chapters, corresponding to key problem areas—service access and configuration,

event handling, synchronization and concurrency—in the development of concurrent and

networked middleware and applications. The order in which you read this material is up to

you. One approach is to read important core patterns first:

§ The Wrapper Facade design pattern (47)

[2]

§ The Reactor architectural pattern (179)

§ The Acceptor-Connector design pattern (285)

§ The Active Object design pattern (369)

The other twelve patterns and one idiom in the book are arranged to minimize forward

references. You can read them in any order of course, and we provide page numbers for

following references to other patterns within the book. This material completes and

complements the concepts defined by the four patterns listed above and covers a range of

issues relevant to designing and implementing concurrent and networked objects effectively.

You can also use this book to find solutions to problems you encounter in your projects. Use

the overview of our patterns in Chapter 6, Weaving the Patterns Together, to guide your

search, then locate in Chapters 2 through 5 the detailed descriptions of the patterns you

select as potential solutions.

No pattern is an island, completely separated from other patterns. Therefore, Chapter 6,

Weaving the Patterns Together, also describes how all the patterns in this book can be

woven together to form a pattern language for building networked applications and

middleware. If you want an overall perspective of the patterns in this book before delving into

the individual patterns, we recommend you skim the pattern language presentation in

Chapter 6 before reading the patterns in Chapters 2 through 5 in depth.

Chapter 7, The Past, Present, and Future of Patterns and Chapter 8, Concluding Remarks

complete the main content of this book. The remainder of the book consists of a glossary of

technical terms, an overview of the notations used in the figures, references to related work,

and an index of patterns, topics, and names.

[2]

We adopt the page number notation introduced by [GoF95]. (47) means that the

corresponding pattern description starts on page 47.

Pattern Form

All patterns presented in this book are self-contained, following the [POSA1] pattern form.

This form allows us to present both the essence and the key details of a pattern. Our goal is

to serve readers who simply want an overview of the pattern's fundamental ideas, as well as

those who want to know how the patterns work in depth.

Each section in our pattern form sets the stage for the subsequent section. For instance, the

Example section introduces the Context, Problem, and Solution sections, which summarize

a pattern's essence. The Solution section foreshadows the Structure and Dynamics section,

which then present more detailed information about how a pattern works, preparing readers

for the Implementation section.

The Example Resolved, Variants, Known Uses, Consequences and See Also sections

complete each pattern description. We include extensive cross-references to help you to

understand the relationships between the patterns in this book and other published patterns.

To anchor the presentation of a pattern's implementation activities to production software

systems, much of the sample code is influenced by components provided in the ACE

framework [Sch97]. If you first want to get an overview of all the patterns you may therefore

want to skip over the Implementation sections on your initial pass through the book and

come back to them when you need to know a particular pattern's implementation details.

Although the pattern form we use in this book incurs some repetition within the pattern

descriptions, we have found that this repetition helps readers navigate through the

descriptions more effectively by minimizing 'back-tracking'.

Chapter 1: Concurrent and Networked Objects

Overview

"With the exception of music, we have been trained to think of patterns as

fixed affairs. It's easier and lazier that way, but, of course, all nonsense. The

right way to begin to think of the pattern which connects is to think of a

dance of interacting parts, pegged down by various sorts of limits."

Gregory Bateson — Cultural Anthropologist

This chapter introduces topics related to concurrent and networked objects. We first motivate

the need for advanced software development techniques in this area. Next, we present an

overview of key design challenges faced by developers of concurrent and networked object-

oriented applications and middleware. To illustrate how patterns can be applied to resolve

these problems, we examine a case study of an object-oriented framework and a high-

performance Web server implemented using this framework. In the case study we focus on

key patterns presented in this book that help to simplify four important aspects of concurrent

and networked applications:

§ Service access and configuration

§ Event handling

§ Synchronization and

§ Concurrency

1.1 Motivation

During the past decade advances in VLSI technology and fiber-optics have increased

computer processing power by 3–4 orders of magnitude and network link speeds by 6–7

orders of magnitude. Assuming that these trends continue, by the end of this decade

§ Desktop computer clock speeds will run at ~100 Gigahertz

§ Local area network link speeds will run at ~100 Gigabits/second

§ Wireless link speeds will run at ~100 Megabits/second and

§ The Internet backbone link speeds will run at ~10 Terabits/second

Moreover, there will be billions of interactive and embedded computing and communication

devices in operation throughout the world. These powerful computers and networks will be

available largely at commodity prices, built mostly with robust common-off-the-shelf (COTS)

components, and will inter-operate over an increasingly convergent and pervasive Internet

infrastructure.

To maximize the benefit from these advances in hardware technology, the quality and

productivity of technologies for developing concurrent and networked middleware and

application software must also increase. Historically, hardware has tended to become

smaller, faster, and more reliable. It has also become cheaper and more predictable to

develop and innovate, as evidenced by 'Moore's Law'. In contrast, concurrent and networked

software has often grown larger, slower, and more error-prone. It has also become very

expensive and time-consuming to develop, validate, maintain, and enhance.

Although hardware improvements have alleviated the need for some low-level software

optimizations, the lifecycle cost [Boe81] and effort required to develop software—particularly

mission-critical concurrent and networked applications—continues to rise. The disparity

between the rapid rate of hardware advances versus the slower software progress stems

from a number of factors, including:

剩余481页未读，继续阅读

阿利518

粉丝: 29
资源: 10

构建网络化并发对象的中间件设计模式

Pattern-Oriented Software Architecture Volume 1.pdf

Pattern-Oriented Software Architecture 全集（vol1到vol5）

嵌入式设计模式有推荐的书籍吗

Why is Pattern-Fusion Efficient中文解释

Pattern-Fusion算法的具体步骤，算法概念和有效性

FPGrowth: A Frequent Pattern-Growth Approach翻译解释成中文

C++ TINY扩充正则表达式的语法

C++设计模式有哪几种

java中有那些设计模式

c++设计模式有哪些

最新资源