Listings xii
Preface xvii
Chapter 1: Introduction 1
1.1 A (very) brief history of concurrency
1
1.2 Benefits of threads
3
1.3 Risks of threads
5
1.4 Threads are everywhere
9
2.1 What is thread
safety? 17
2.2 Atomicity 19
2.3 Locking 23
2.4 Guarding state with locks
27
2.5 Liveness and performance
29
3.1 Visibility 33
3.2 Publication and escape
39
3.3 Thread confinement
42
3.4 Immutability 46
3.5 Safepublication
49
4.1 Designing a thread-safe
class 55
4.2 Instance confinement
58
4.3 Delegating thread safety
62
4.4 Adding functionality to existing thread-safe classes
71
4.5 Documenting synchronization policies
74
5.1 Synchronized collections
79
5.2 Concurrent
collections 84
5.3 Blocking queues and the producer-consumer
pattern 87
5.4 Blocking and interruptible
methods 92
5.5 Synchronizers 94
5.6 Building an efficient, scalable result
cache 101
6.1 Executing tasks in
threads 113
6.2 The Executor
framework 117
6.3 Finding exploitable
parallelism 123
7.1 Task cancellation
135
7.2 Stopping a thread-based service
150
7.3 Handling abnormal thread termination
161
7.4 JVM shutdown 164
8.1 Implicit couplings between tasks and execution
policies 167
8.2 Sizing thread pools
170
8.3 Configuring
ThreadPoolExecutor 171
8.4 Extending
ThreadPoolExecutor 179
8.5 Parallelizing recursive
algorithms 181
9.1 Why are GUIs
single-threaded? 189
9.2 Short-running GUI
tasks 192
9.3 Long-running GUI
tasks 195
9.4 Shared data
models 198
9.5 Other forms of single-threaded
subsystems 202
10.1 Deadlock 205
10.2 Avoiding and diagnosing
deadlocks 215
10.3 Other liveness
hazards 218
11.1 Thinking about
performance 221
11.2 Amdahl's law 225
11.3 Costs introduced by
threads 229
11.4 Reducing lock contention
232
11.5 Example: Comparing Map
performance 242
11.6 Reducing context switch overhead
243
12.1 Testing for
correctness 248
12.2 Testing for performance
260
12.3 Avoiding performance testing pitfalls
266
12.4 Complementary testing
approaches 270
13.1 Lock and
ReentrantLock 277
13.2 Performance
considerations 282
13.3 Fairness 283
13.4 Choosing between synchronized and ReentrantLock
285
13.5 Read-write
locks 286
14.1 Managing state
dependence 291
14.2 Using condition
queues 298
14.3 Explicit condition
objects 306
14.4 Anatomy of a
synchronizer 308
14.5 AbstractQueuedSynchronizer
311
14.6 AQS in java.util.concurrent synchronizer classes
314
15.1 Disadvantages of
locking 319
15.2 Hardware support for concurrency
321
15.3 Atomic variable classes
324
15.4 Nonblocking algorithms
329
16.1 What is a memory model, and why would I want
one? 337
16.2 Publication 344
16.3 Initialization
safety 349
A.1 Class
annotations 353
A.2 Field andmethod
annotations 353
As processors become faster and multiprocessor systems become cheaper, the need to take advantage of multithreading in order to achieve full hardware resource utilization only increases the importance of being able to incorporate concurrency in a wide variety of application categories. For many developers, concurrency remains a mystery. Developing, testing, and debugging multithreaded programs is extremely difficult because concurrency hazards do not manifest themselves uniformly or reliably. This book is intended to be neither an introduction to concurrency (any threading chapter in an "intro" book does that) nor is it an encyclopedic reference of All Things Concurrency (that would be Doug Lea's Concurrent Programming in Java). Instead, this title is a combination of concepts, guidelines, and examples intended to assist developers in the difficult process of understanding concurrency and its new tools in J2SE 5.0. Filled with contributions from Java gurus such as Josh Bloch, David Holmes, and Doug Lea, this book provides any Java programmers with the basic building blocks they need to gain a basic understanding of concurrency and its benefits.
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.
 |
Ask a Question About this Product More... |
|
