Java Concurrency in Practice

, by Goetz, Brian; Peierls, Tim; Bloch, Joshua; Bowbeer, Joseph; Holmes, David; Lea, Doug

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

ISBN: 9780321349606 | 0321349601
Cover: Paperback
Copyright: 5/9/2006

Rent

(Recommended)

$40.16

Term

Due

Price

Semester

May 29

$40.16

Quarter

May 19

$38.15

Short Term

Apr 19

$36.14

*This item is part of an exclusive publisher rental program and requires an additional convenience fee. This fee will be reflected in the shopping bag.
Buy Used

Usually Ships in 3-5 Business Days

$42.76
Buy New

Currently Available, Usually Ships in 24-48 Hours

$59.33
eBook

Available Instantly

Online: 1825 Days

Downloadable: Lifetime Access

*To support the delivery of the digital material to you, a digital delivery fee of $3.99 will be charged on each digital item.

$69.59*

Supplemental Materials

A how-to companion to Doug Lea's 'Concurrent Programming in Java', this book is the only authorative and practical guide to Java Concurrency.

Brian Goetz is a software consultant with twenty years industry experience, with over 75 articles on Java development. He is one of the primary members of the Java Community Process JSR 166 Expert Group (Concurrency Utilities), and has served on numerous other JCP Expert Groups.

Tim Peierls is the very model of a modern multiprocessor, with BoxPop.biz, recording arts, and goings on theatrical. He is one of the primary members of the Java Community Process JSR 166 Expert Group (Concurrency Utilities), and has served on numerous other JCP Expert Groups.

Joshua Bloch is a principal engineer at Google and a Jolt Award-winner. He was previously a distinguished engineer at Sun Microsystems and a senior systems designer at Transarc. Josh led the design and implementation of numerous Java platform features, including JDK 5.0 language enhancements and the award-winning Java Collections Framework. He holds a Ph.D. in computer science from Carnegie Mellon University.

Joseph Bowbeer is a software architect at Vizrea Corporation where he specializes in mobile application development for the Java ME platform, but his fascination with concurrent programming began in his days at Apollo Computer. He served on the JCP Expert Group for JSR-166 (Concurrency Utilities).

David Holmes is director of DLTeCH Pty Ltd, located in Brisbane, Australia. He specializes in synchronization and concurrency and was a member of the JSR-166 expert group that developed the new concurrency utilities. He is also a contributor to the update of the Real-Time Specification for Java, and has spent the past few years working on an implementation of that specification.

Doug Lea is one of the foremost experts on object-oriented technology and software reuse. He has been doing collaborative research with Sun Labs for more than five years. Lea is Professor of Computer Science at SUNY Oswego, Co-director of the Software Engineering Lab at the New York Center for Advanced Technology in Computer Applications, and Adjunct Professor of Electrical and Computer Engineering at Syracuse University. In addition, he co-authored the book, Object-Oriented System Development (Addison-Wesley, 1993). He received his B.A., M.A., and Ph.D. from the University of New Hampshire.

Listings

xii

Preface

xvii

Introduction

(12)

A (very) brief history of concurrency

(2)

Benefits of threads

(2)

Risks of threads

(4)

Threads are everywhere

(4)

I. Fundamentals

(98)

Thread Safety

(18)

What is thread safety?

(2)

Atomicity

(4)

Locking

(4)

Guarding state with locks

(2)

Liveness and performance

(4)

Sharing Objects

(22)

Visibility

(6)

Publication and escape

(3)

Thread confinement

(4)

Immutability

(3)

Safe publication

(6)

Composing Objects

(24)

Designing a thread-safe class

(3)

Instance confinement

(4)

Delegating thread safety

(9)

Adding functionality to existing thread-safe classes

(3)

Documenting synchronization policies

(5)

Building Blocks

(32)

Synchronized collections

(5)

Concurrent collections

(3)

Blocking queues and the producer-consumer pattern

(5)

Blocking and interruptible methods

(2)

Synchronizers

(7)

Building an efficient, scalable result cache

101

(10)

II. Structuring Concurrent Applications

111

(92)

Task Execution

113

(22)

Executing tasks in threads

113

(4)

The Executor framework

117

(6)

Finding exploitable parallelism

123

(12)

Cancellation and Shutdown

135

(32)

Task cancellation

135

(15)

Stopping a thread-based service

150

(11)

Handling abnormal thread termination

161

(3)

JVM shutdown

164

(3)

Applying Thread Pools

167

(22)

Implicit couplings between tasks and execution policies

167

(3)

Sizing thread pools

170

(1)

Configuring ThreadPoolExecutor

171

(8)

Extending ThreadPoolExecutor

179

(2)

Parallelizing recursive algorithms

181

(8)

GUI Applications

189

(14)

Why are GUIs single-threaded?

189

(3)

Short-running GUI tasks

192

(3)

Long-running GUI tasks

195

(3)

Shared data models

198

(4)

Other forms of single-threaded subsystems

202

(1)

III. Liveness, Performance, and Testing

203

(72)

Avoiding Liveness Hazards

205

(16)

Deadlock

205

(10)

Avoiding and diagnosing deadlocks

215

(3)

Other liveness hazards

218

(3)

Performance and Scalability

221

(26)

Thinking about performance

221

(4)

Amdahl's law

225

(4)

Costs introduced by threads

229

(3)

Reducing lock contention

232

(10)

Example: Comparing Map performance

242

(1)

Reducing context switch overhead

243

(4)

Testing Concurrent Programs

247

(28)

Testing for correctness

248

(12)

Testing for performance

260

(6)

Avoiding performance testing pitfalls

266

(4)

Complementary testing approaches

270

(5)

IV. Advanced Topics

275

(78)

Explicit Locks

277

(14)

Lock and ReentrantLock

277

(5)

Performance considerations

282

(1)

Fairness

283

(2)

Choosing between synchronized and ReentrantLock

285

(1)

Read-write locks

286

(5)

Building Custom Synchronizers

291

(28)

Managing state dependence

291

(7)

Using condition queues

298

(8)

Explicit condition objects

306

(2)

Anatomy of a synchronizer

308

(3)

AbstractQueuedSynchronizer

311

(3)

AQS in java.util.concurrent synchronizer classes

314

(5)

Atomic Variables and Nonblocking Synchronization

319

(18)

Disadvantages of locking

319

(2)

Hardware support for concurrency

321

(3)

Atomic variable classes

324

(5)

Nonblocking algorithms

329

(8)

The Java Memory Model

337

(16)

What is a memory model, and why would I want one?

337

(7)

Publication

344

(5)

Initialization safety

349

(4)

A. Annotations for Concurrency

353

(2)

Class annotations

353

(1)

Field and method annotations

353

(2)

Bibliography

355

(4)

Index

359

FREE SHIPPING

Rent More, Save More! Use code: BBRENTAL

5% off 1 book, 7% off 2 books, 10% off 3+ books

Java Concurrency in Practice

Summary

Author Biography

Table of Contents

Supplemental Materials