Java Concurrency in Practice                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                         By Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, 
                                                                                                                                                                                                                                                                                                                         Doug Lea 
                                                                                                                                                                                                                                                                                                                         ............................................... 
                                                                                                                                                                                                                                                                                                                         Publisher: Addison Wesley Professional 
                                                                                                                                                                                                                                                                                                                         Pub Date: May 09, 2006 
                                                                                                                                                                                                                                                                                                                         Print ISBN-10: 0-321-34960-1 
                                                                                                                                                                                                                                                                                                                         Print ISBN-13: 978-0-321-34960-6 
                                                                                                                                                                                                                                                                                                                         Pages: 384 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                    UTable of ContentsU  | UIndexU 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
                                                                                                                                                                                                            
                                                                                                                                                                                                           UCopyrightU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UAdvance Praise for Java Concurrency in PracticeU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UListingsU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UPrefaceU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UChapter 1.  IntroductionU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 USection 1.1.  A (Very) Brief History of ConcurrencyU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 USection 1.2.  Benefits of ThreadsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 USection 1.3.  Risks of ThreadsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 USection 1.4.  Threads are EverywhereU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UPart I:  FundamentalsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 2.  Thread SafetyU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 2.1.  What is Thread Safety?U 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 2.2.  AtomicityU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 2.3.  LockingU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 2.4.  Guarding State with LocksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 2.5.  Liveness and PerformanceU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 3.  Sharing ObjectsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 3.1.  VisibilityU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 3.2.  Publication and EscapeU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 3.3.  Thread ConfinementU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 3.4.  ImmutabilityU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 3.5.  Safe PublicationU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 4.  Composing ObjectsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 4.1.  Designing a Thread-safe ClassU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 4.2.  Instance ConfinementU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 4.3.  Delegating Thread SafetyU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 4.4.  Adding Functionality to Existing Thread-safe ClassesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 4.5.  Documenting Synchronization PoliciesU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 5.  Building BlocksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.1.  Synchronized CollectionsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.2.  Concurrent CollectionsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.3.  Blocking Queues and the Producer-consumer PatternU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.4.  Blocking and Interruptible MethodsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.5.  SynchronizersU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 5.6.  Building an Efficient, Scalable Result CacheU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummary of Part IU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UPart II:  Structuring Concurrent ApplicationsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 6.  Task ExecutionU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 6.1.  Executing Tasks in ThreadsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 6.2.  The Executor FrameworkU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 6.3.  Finding Exploitable ParallelismU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 7.  Cancellation and ShutdownU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 7.1.  Task CancellationU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 7.2.  Stopping a Thread-based ServiceU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 7.3.  Handling Abnormal Thread TerminationU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 7.4.  JVM ShutdownU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 8.  Applying Thread PoolsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 8.1.  Implicit Couplings Between Tasks and Execution PoliciesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 8.2.  Sizing Thread PoolsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 8.3.  Configuring ThreadPoolExecutorU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 8.4.  Extending ThreadPoolExecutorU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 8.5.  Parallelizing Recursive AlgorithmsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 9.  GUI ApplicationsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 9.1.  Why are GUIs Single-threaded?U 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 9.2.  Short-running GUI TasksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 9.3.  Long-running GUI TasksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 9.4.  Shared Data ModelsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 9.5.  Other Forms of Single-threaded SubsystemsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UPart III:  Liveness, Performance, and TestingU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 10.  Avoiding Liveness HazardsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 10.1.  DeadlockU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 10.2.  Avoiding and Diagnosing DeadlocksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 10.3.  Other Liveness HazardsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 11.  Performance and ScalabilityU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.1.  Thinking about PerformanceU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.2.  Amdahl's LawU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.3.  Costs Introduced by ThreadsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.4.  Reducing Lock ContentionU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.5.  Example: Comparing Map PerformanceU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 11.6.  Reducing Context Switch OverheadU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 12.  Testing Concurrent ProgramsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 12.1.  Testing for CorrectnessU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 12.2.  Testing for PerformanceU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 12.3.  Avoiding Performance Testing PitfallsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 12.4.  Complementary Testing ApproachesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UPart IV:  Advanced TopicsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 13.  Explicit LocksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 13.1.  Lock and ReentrantLockU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 13.2.  Performance ConsiderationsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 13.3.  FairnessU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 13.4.  Choosing Between Synchronized and ReentrantLockU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 13.5.  Read-write LocksU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 14.  Building Custom SynchronizersU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.1.  Managing State DependenceU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.2.  Using Condition QueuesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.3.  Explicit Condition ObjectsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.4.  Anatomy of a SynchronizerU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.5.  AbstractQueuedSynchronizerU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 14.6.  AQS in Java.util.concurrent Synchronizer ClassesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 15.  Atomic Variables and Nonblocking SynchronizationU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 15.1.  Disadvantages of LockingU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 15.2.  Hardware Support for ConcurrencyU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 15.3.  Atomic Variable ClassesU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 15.4.  Nonblocking AlgorithmsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UChapter 16.  The Java Memory ModelU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 16.1.  What is a Memory Model, and Why would I Want One?U 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 16.2.  PublicationU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection 16.3.  Initialization SafetyU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USummaryU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UAppendix A.  Annotations for ConcurrencyU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection A.1.  Class AnnotationsU 
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                       USection A.2.  Field and Method AnnotationsU 
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                 UBibliographyU 
                                                                                                                                                                                                            
                                                                                                                                                                                                           UIndexU