concurrent-programming-in-java-design-principles-and-patterns-second-edition

4星 · 超过85%的资源需积分: 48 45 浏览量更新于2023-05-21 评论收藏 2.42MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源评论

资源推荐

Concurrent Programming in Java™: Design Principles and Patterns, Second

Edition

By Doug Lea

Publishe

: Addison Wesley

Pub Date: October 01, 1999

ISBN: 0-201-31009-0

Pages: 432

In Concurrent Programming in Java, Second Edition, you will find thoroughly

updated coverage of the Java 2 platform and new or expanded coverage of:

• Memory model

• Cancellation

• Portable parallel programming

• Utility classes for concurrency control

The Java platform provides a broad and powerful set of APIs, tools, and technologies.

One of its most powerful capabilities is the built-in support for threads. This makes

concurrent programming an attractive yet challenging option for programmers using

the Java programming language.

This book shows readers how to use the Java platform's threading model more

recisely by helping them to understand the patterns and tradeoffs associated with

concurrent programming.

You will learn how to initiate, control, and coordinate concurrent activities using the

class java.lang.Thread, the keywords synchronized and volatile, and the methods wait,

notify, and notifyAll. In addition, you will find detailed coverage of all aspects of

concurrent programming, including such topics as confinement and synchronization,

deadlocks and conflicts, state-dependent action control, asynchronous message passing

and control flow, coordinated interaction, and structuring web-based and

computational services.

The book targets intermediate to advanced programmers interested in mastering the

complexities of concurrent programming. Taking a design pattern approach, the book

offers standard design techniques for creating and implementing components that

solve common concurrent programming challenges. The numerous code examples

throughout help clarify the subtleties of the concurrent programming concepts

discussed.

Acknowledgments

Chapter 1. Concurrent Object-Oriented Programming

Section 1.1. Using Concurrency Constructs

Section 1.2. Objects and Concurrency

Section 1.3. Design Forces

Section 1.4. Before/After Patterns

Chapter 2. Exclusion

Section 2.1. Immutability

Section 2.2. Synchronization

Section 2.3. Confinement

Section 2.4. Structuring and Refactoring Classes

Section 2.5. Using Lock Utilities

Chapter 3. State Dependence

Section 3.1. Dealing with Failure

Section 3.2. Guarded Methods

Section 3.3. Structuring and Refactoring Classes

Section 3.4. Using Concurrency Control Utilities

Section 3.5. Joint Actions

Section 3.6. Transactions

Section 3.7. Implementing Utilities

Chapter 4. Creating Threads

Section 4.1. Oneway Messages

Section 4.2. Composing Oneway Messages

Section 4.3. Services in Threads

Section 4.4. Parallel Decomposition

Section 4.5. Active Objects

Many of the designations used by manufacturers and sellers to distinguish their products are claimed

as trademarks. Where those designations appear in this book and Addison-Wesley was aware of a

trademark claim, the designations have been printed in initial caps or all caps.

Duke™ designed by Joe Palrang.

Sun Microsystems, Inc. has intellectual property rights relating to implementations of the technology

described in this publication. In particular, and without limitation, these intellectual property rights

may include one or more U.S. patents, foreign patents, or pending applications. Sun, Sun

Microsystems, the Sun Logo, and all Sun, Java, Jini, and Solaris based trademarks and logos are

trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other

countries. UNIX is a registered trademark in the United States and other countries, exclusively

licensed through X/Open Company, Ltd.

As used in this book, the terms "Java virtual machine" and "JVM" mean a virtual machine for the Java

platform.

THIS PUBLICATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER

EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-

INFRINGEMENT.

THIS PUBLICATION COULD INCLUDE TECHNICAL INACCURACIES OR

TYPOGRAPHICAL ERRORS. CHANGES ARE PERIODICALLY ADDED TO THE

INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS

OF THE PUBLICATION. SUN MICROSYSTEMS, INC. MAY MAKE IMPROVEMENTS

AND/OR CHANGES IN ANY TECHNOLOGY, PRODUCT, OR PROGRAM DESCRIBED IN

THIS PUBLICATION AT ANY TIME.

The author and publisher have taken care in the preparation of this document, but make no expressed

or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is

assumed for incidental or consequential damages in connection with or arising out of the use of the

information or programs contained herein.

Library of Congress Card Number 99-066823

may be reproduced, stored in a retrieval system, or transmitted, in any form, or by any means,

electronic, mechanical, photocopying, recording, or otherwise, without the prior consent of the

publisher. Printed in the United States of America. Published simultaneously in Canada.

Text printed on recycled and acid-free paper.

2 3 4 5 6 7 - MA - 02 01 00 99

Second printing, November 1999

Acknowledgments

This book began as a small set of Web pages that I put together in spring 1995, while trying to make

sense of my own early attempts to use Java concurrency features in experimental development efforts.

Then it grew; first on the World Wide Web, where I extended, expanded, and removed patterns to

reflect my and other people's increasing experience with Java concurrency; and now into this book,

which places patterns within the broader perspective of concurrent software development. The web

pages also live on, but they now serve as a supplement to the conceptual presentations best suited to

book form.

There have been many changes along the way, in a process that has benefited from commentary,

suggestions, errata reports, and exchanges with many kind and knowledgeable people. These include

Ole Agesen, Tatsuya Aoyagi, Taranov Alexander, Moti Ben-Ari, Peter Buhr, Bruce Chapman, Il-

Hyung Cho, Colin Cooper, Kelly Davis, Bruce Eckel, Yacov Eckel, Saleh Elmohamed, Ed Falis,

Randy Farmer, Glenn Goldstein, David Hanson, Jyrki Heikkinen, Alain Hsiung, Jerry James,

Johannes Johannsen, Istvan Kiss, Ross Knippel, Bil Lewis, Sheng Liang, Jonathan Locke, Steve

MacDonald, Hidehiko Masuhara, Arnulf Mester, Mike Mills, Trevor Morris, Bill Pugh, Andrew

Purshottam, Simon Roberts, John Rose, Rodney Ryan, Joel Rosi-Schwartz, Miles Sabin, Aamod Sane,

Beverly Sanders, Doug Schmidt, Kevin Shank, Yukari Shirota, David Spitz, David Stoutamire, Henry

Story, Sumana Srinivasan, Satish Subramanian, Jeff Swartz, Patrick Thompson, Volker Turau, Dennis

Ulrich, Cees Vissar, Bruce Wallace, Greg Wilson, Grant Woodside, Steve Yen, and Dave Yost, as

well as people who submitted anonymous electronic mail commentary.

The members of Ralph Johnson's patterns seminar (especially Brian Foote and Ian Chai) read through

early forms of some patterns and suggested many improvements. Raj Datta, Sterling Barrett, and

Philip Eskelin of the New York City Patterns Group, and Russ Rufer, Ming Kwok, Mustafa Ozgen,

Edward Anderson, and Don Chin of the Silicon Valley Patterns Group performed similar valuable

service for preliminary versions of the second edition.

Official and unofficial reviewers of the first- and second-edition manuscripts made helpful comments

and suggestions on tight schedules. They include Ken Arnold, Josh Bloch, Joseph Bowbeer, Patrick

Chan, Gary Craig, Desmond D'Souza, Bill Foote, Tim Harrison, David Henderson, Tim Lindholm,

Tom May, Oscar Nierstrasz, James Robins, Greg Travis, Mark Wales, Peter Welch, and Deborra

Zukowski. Very special thanks go to Tom Cargill for his many insights and corrections, as well as for

permission to include a description of his Specific Notification pattern. Very special thanks also go to

David Holmes for, among many contributions, helping to develop and extend material for tutorials

that in turn became included in the second edition.

Rosemary Simpson contributed numerous improvements in the course of creating the index. Ken

Arnold patiently helped me deal with FrameMaker. Mike Hendrickson and the editorial crew at

Addison-Wesley have been continually supportive.

This book would not have been possible without the generous support of Sun Labs. Thanks especially

to Jos Marlowe and Steve Heller for providing opportunities to work collaboratively on fun and

exciting research and development projects.

Thanks above all to Kathy, Keith, and Colin for tolerating all this.

Doug Lea, September, 1999

Chapter 1. Concurrent Object-Oriented Programming

This book discusses some ways of thinking about, designing, and implementing concurrent programs

in the Java™ programming language. Most presentations in this book assume that you are an

experienced developer familiar with object-oriented (OO) programming, but have little exposure to

concurrency. Readers with the opposite background — experience with concurrency in other

languages — may also find this book useful.

The book is organized into four coarse-grained chapters. (Perhaps parts would be a better term.) This

first chapter begins with a brief tour of some frequently used constructs and then backs up to establish

a conceptual basis for concurrent object-oriented programming: how concurrency and objects fit

together, how the resulting design forces impact construction of classes and components, and how

some common design patterns can be used to structure solutions.

The three subsequent chapters are centered around use (and evasion) of the three kinds of concurrency

constructs found in the Java programming language:

Exclusion. Maintaining consistent states of objects by preventing unwanted interference among

concurrent activities, often using

synchronized methods.

State dependence. Triggering, preventing, postponing, or recovering from actions depending on

whether objects are in states in which these actions could or did succeed, sometimes using monitor

methods

Object.wait, Object.notify, and Object.notifyAll.

Creating threads. Establishing and managing concurrency, using Thread objects.

Each chapter contains a sequence of major sections, each on an independent topic. They present high-

level design principles and strategies, technical details surrounding constructs, utilities that

encapsulate common usages, and associated design patterns that address particular concurrency

problems. Most sections conclude with an annotated set of further readings providing more

information on selected topics. The online supplement to this book contains links to additional online

resources, as well as updates, errata, and code examples. It is accessible via links from:

http://java.sun.com/Series

or http://gee.cs.oswego.edu/dl/cpj

If you are already familiar with the basics, you can read this book in the presented order to explore

each topic in more depth. But most readers will want to read this book in various different orders.

Because most concurrency concepts and techniques interact with most others, it is not always possible

to understand each section or chapter in complete isolation from all the others. However, you can still

take a breadth-first approach, briefly scanning each chapter (including this one) before proceeding

with more detailed coverage of interest. Many presentations later in the book can be approached after

selectively reading through earlier material indicated by extensive cross-references.

You can practice this now by skimming through the following preliminaries.

Terminology. This book uses standard OO terminological conventions: programs define methods

(implementing operations) and fields (representing attributes) that hold for all instances (objects) of

specified classes.

Interactions in OO programs normally revolve around the responsibilities placed upon a client object

needing an action to be performed, and a server object containing the code to perform the action. The

terms client and server are used here in their generic senses, not in the specialized sense of distributed

client/server architectures. A client is just any object that sends a request to another object, and a

server is just any object receiving such a request. Most objects play the roles of both clients and

servers. In the usual case where it doesn't matter whether an object under discussion acts as a client or

server or both, it is usually called a host; others that it may in turn interact with are often called

helpers or peers. Also, when discussing invocations of the form

obj.msg(arg), the recipient

(that is, the object bound to variable

obj) is called the target object.

This book generally avoids dealing with transient facts about particular classes and packages not

directly related to concurrency. And it does not cover details about concurrency control in specialized

frameworks such as Enterprise JavaBeans™ and Servlets. But it does sometimes refer to branded

software and trademarked products associated with the Java™ Platform. The copyright page of this

book provides more information.

Code listings. Most techniques and patterns in this book are illustrated by variants of an annoyingly

small set of toy running examples. This is not an effort to be boring, but to be clear. Concurrency

constructs are often subtle enough to get lost in otherwise meaningful examples. Reuse of running

examples makes small but critical differences more obvious by highlighting the main design and

implementation issues. Also, the presentations include code sketches and fragments of classes that

illustrate implementation techniques, but are not intended to be complete or even compilable. These

classes are indicated by leading comments in the listings.

Import statements, access qualifiers, and even methods and fields are sometimes omitted from listings

when they can be inferred from context or do not impact relevant functionality. The

protected

剩余316页未读，继续阅读

jfding

2017-04-28

good book . worth to keep

huangkaizh

粉丝: 0
资源: 8

会员权益专享

concurrent-programming-in-java-design-principles-and-patterns-se...

评论1

会员权益专享

最新资源

concurrent-programming-in-java-design-principles-and-patterns-se...

评论1

Concurrent, Real-Time and Distributed Programming in Java Threads, RTSJ 无水印原版pdf

Concurrent Programming in Java™: Design Principles and Patterns 2nd

GO语言设计模式 go-design-patterns

picked up jdk_java_options: --add-opens=java.base/java.lang=all-unnamed --add-opens=java.base/java.io=all-unnamed --add-opens=java.base/java.util=all-unnamed --add-opens=java.base/java.util.concurrent=all-unnamed --add-opens=java.rmi/sun.rmi.transport=all-unnamed

Concurrent Programming on Windows

word版本

Asynchronous Android Programming

Concurrent Programming on Windows 无水印pdf

Advanced Python Programming - Lanaro, Gabriele; Nguyen, Quan;.pdf

Functional Python Programming(PACKT,2015)

JavaScript Concurrency pdf 无水印 0分

Learning Akka(PACKT,2015)

Java Threads and the Concurrency Utilities(Apress,2015)

java.util.concurrent.executionexception: java.lang.outofmemoryerror: java he

Programming Elixir

Multithreading_Programming_-_Thread_Synchronization_c++

会员权益专享

最新资源