Skip to content

Java Concurrency in Practice

Best in textbook rentals since 2012!

ISBN-10: 0321349601

ISBN-13: 9780321349606

Edition: 2006

Authors: Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes

List price: $59.99
Shipping box This item qualifies for FREE shipping.
Blue ribbon 30 day, 100% satisfaction guarantee!

Rental notice: supplementary materials (access codes, CDs, etc.) are not guaranteed with rental orders.

what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!

Description:

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…    
Customers also bought

Book details

List price: $59.99
Copyright year: 2006
Publisher: Addison Wesley Professional
Publication date: 5/9/2006
Binding: Paperback
Pages: 432
Size: 7.00" wide x 9.20" long x 1.20" tall
Weight: 1.694
Language: English

Listings
Preface
Introduction
A (very) brief history of concurrency
Benefits of threads
Risks of threads
Threads are everywhere
Fundamentals
Thread Safety
What is thread safety?
Atomicity
Locking
Guarding state with locks
Liveness and performance
Sharing Objects
Visibility
Publication and escape
Thread confinement
Immutability
Safe publication
Composing Objects
Designing a thread-safe class
Instance confinement
Delegating thread safety
Adding functionality to existing thread-safe classes
Documenting synchronization policies
Building Blocks
Synchronized collections
Concurrent collections
Blocking queues and the producer-consumer pattern
Blocking and interruptible methods
Synchronizers
Building an efficient, scalable result cache
Structuring Concurrent Applications
Task Execution
Executing tasks in threads
The Executor framework
Finding exploitable parallelism
Cancellation and Shutdown
Task cancellation
Stopping a thread-based service
Handling abnormal thread termination
JVM shutdown
Applying Thread Pools
Implicit couplings between tasks and execution policies
Sizing thread pools
Configuring ThreadPoolExecutor
Extending ThreadPoolExecutor
Parallelizing recursive algorithms
GUI Applications
Why are GUIs single-threaded?
Short-running GUI tasks
Long-running GUI tasks
Shared data models
Other forms of single-threaded subsystems
Liveness, Performance, and Testing
Avoiding Liveness Hazards
Deadlock
Avoiding and diagnosing deadlocks
Other liveness hazards
Performance and Scalability
Thinking about performance
Amdahl's law
Costs introduced by threads
Reducing lock contention
Example: Comparing Map performance
Reducing context switch overhead
Testing Concurrent Programs
Testing for correctness
Testing for performance
Avoiding performance testing pitfalls
Complementary testing approaches
Advanced Topics
Explicit Locks
Lock and ReentrantLock
Performance considerations
Fairness
Choosing between synchronized and ReentrantLock
Read-write locks
Building Custom Synchronizers
Managing state dependence
Using condition queues
Explicit condition objects
Anatomy of a synchronizer
AbstractQueuedSynchronizer
AQS in java.util.concurrent synchronizer classes
Atomic Variables and Nonblocking Synchronization
Disadvantages of locking
Hardware support for concurrency
Atomic variable classes
Nonblocking algorithms
The Java Memory Model
What is a memory model, and why would I want one?
Publication
Initialization safety
Annotations for Concurrency
Class annotations
Field and method annotations
Bibliography
Index