Java Concurrency in Practice


ISBN: 9780321349606Number of Pages: 432
Publisher: Addison-Wesley ProfessionalBook Title: Java Concurrency in Practice
Publication Year: 2011Target Audience: Scholarly & Professional
Author: Brian GoetzFormat: Perfect


Java Concurrency In Practice is wirtten by Brian Goetz. This book introduces Java threads and concurrency in simple terms. It is a perfect reference manual for Java concurrency. This book is recommend by Oreillys for learning concurrent java.

Starting from the basic concepts of concurrency and thread safety, the book introduces how to use the basic concurrency building blocks provided by the class library to avoid concurrency dangers, construct thread safe classes and verify thread safety rules, how to combine small thread safe classes into larger thread safe classes, how to use threads to improve the throughput of concurrent applications, and how to identify tasks that can be executed in parallel, how to improve the responsiveness of a single program subsystem, how to ensure that concurrent programs perform the expected tasks, and how to improve the performance and scalability of concurrent code.

Finally, some advanced topics, such as explicit locks, atomic variables, non blocking algorithms, and how to develop self-defined synchronization tool classes, are introduced.

Java Concurrency In Practice is the Best Java Books for Absolulate Beginners. You can get more info about learn Java

About the Author

The authors of this book are the main members of the Java Community Process JSR 166 expert group , and have served in many other JCP expert groups.

Brian Goetz has more than 20 years of experience in the software consulting industry and has written at least 75 articles on Java.

Tim Peierls is a model of Modern Multiprocessor. He works in Boxpop Biz, record art and drama performance are also well studied.

Joseph Bowbeer is expert of a Java ME. His interest in concurrent programming began in the Apollo.

David Holmes is a co-author of The Java Programming Language and works for Sun.

Joshua Bloch is the chief Java Architect of Google, the author of Effective Java and the author of Java Puzzlers.

Doug Lea is the author of Concurrent Programming and a professor of computer science at the State University of New York at Oswego.

Java Concurrency In Practice PDF version is avaliable Later ,Please come back soon.

Table of Contents

Chapter 1: Introduction

  • 1.1 A (very) brief history of concurrency
  • 1.2 Benefits of threads
  • 1.3 Risks of threads
  • 1.4 Threads are everywhere

Part I: Fundamentals

Chapter 2: Thread Safety

  • 2.1 What is thread safety?
  • 2.2 Atomicity
  • 2.3 Locking
  • 2.4 Guarding state with locks
  • 2.5 Liveness and performance

Chapter 3: Sharing Objects

  • 3.1 Visibility
  • 3.2 Publication and escape
  • 3.3 Thread confinement
  • 3.4 Immutability
  • 3.5 Safepublication

Chapter 4: Composing Objects

  • 4.1 Designing a thread-safe class
  • 4.2 Instance confinement
  • 4.3 Delegating thread safety
  • 4.4 Adding functionality to existing thread-safe classes
  • 4.5 Documenting synchronization policies

Chapter 5: Building Blocks

  • 5.1 Synchronized collections
  • 5.2 Concurrent collections
  • 5.3 Blocking queues and the producer-consumer pattern
  • 5.4 Blocking and interruptible methods
  • 5.5 Synchronizers
  • 5.6 Building an efficient, scalable result cache
  • Part II: Structuring Concurrent Applications

Chapter 6: Task Execution

  • 6.1 Executing tasks in threads
  • 6.2 The Executor framework
  • 6.3 Finding exploitable parallelism

Chapter 7: Cancellation and Shutdown

  • 7.1 Task cancellation
  • 7.2 Stopping a thread-based service
  • 7.3 Handling abnormal thread termination
  • 7.4 JVM shutdown

Chapter 8: Applying Thread Pools

  • 8.1 Implicit couplings between tasks and execution policies
  • 8.2 Sizing thread pools
  • 8.3 Configuring ThreadPoolExecutor
  • 8.4 Extending ThreadPoolExecutor
  • 8.5 Parallelizing recursive algorithms

Chapter 9: GUI Applications

  • 9.1 Why are GUIs single-threaded?
  • 9.2 Short-running GUI tasks
  • 9.3 Long-running GUI tasks
  • 9.4 Shared data models
  • 9.5 Other forms of single-threaded subsystems

Part III: Liveness, Performance, and Testing

Chapter 10: Avoiding Liveness Hazards

  • 10.1 Deadlock
  • 10.2 Avoiding and diagnosing deadlocks
  • 10.3 Other liveness hazards

Chapter 11: Performance and Scalability

  • 11.1 Thinking about performance
  • 11.2 Amdahl”s law
  • 11.3 Costs introduced by threads
  • 11.4 Reducing lock contention
  • 11.5 Example: Comparing Map performance
  • 11.6 Reducing context switch overhead

Chapter 12: Testing Concurrent Programs

  • 12.1 Testing for correctness
  • 12.2 Testing for performance
  • 12.3 Avoiding performance testing pitfalls
  • 12.4 Complementary testing approaches

Part IV: Advanced Topics

Chapter 13: Explicit Locks

  • 13.1 Lock and ReentrantLock
  • 13.2 Performance considerations
  • 13.3 Fairness
  • 13.4 Choosing between synchronized and ReentrantLock
  • 13.5 Read-write locks

Chapter 14: Building Custom Synchronizers

  • 14.1 Managing state dependence
  • 14.2 Using condition queues
  • 14.3 Explicit condition objects
  • 14.4 Anatomy of a synchronizer
  • 14.5 AbstractQueuedSynchronizer
  • 14.6 AQS in java.util.concurrent synchronizer classes

Chapter 15: Atomic Variables and Nonblocking Synchronization

  • 15.1 Disadvantages of locking
  • 15.2 Hardware support for concurrency
  • 15.3 Atomic variable classes
  • 15.4 Nonblocking algorithms

Chapter 16: The Java Memory Model

  • 16.1 What is a memory model, and why would I want one?
  • 16.2 Publication
  • 16.3 Initialization safety

Appendix A: Annotations for Concurrency

A.1 Class annotations

A.2 Field andmethod annotations