Java Concurrency in Practice 1st Edition by Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea ISBN 0132702258 9780132702256

Java Concurrency in Practice 1st Edition by Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea – Ebook PDF Instant Download/Delivery. 0132702258, 9780132702256
Full download Java Concurrency in Practice 1st Edition after payment

Product details:

ISBN 10: 0132702258
ISBN 13: 9780132702256
Author: Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea

Threads are a fundamental part of the Java platform. As multicore processors become the norm, using concurrency effectively becomes essential for building high-performance applications. Java SE 5 and 6 are a huge step forward for the development of concurrent applications, with improvements to the Java Virtual Machine to support high-performance, highly scalable concurrent classes and a rich set of new concurrency building blocks. In Java Concurrency in Practice, the creators of these new facilities explain not only how they work and how to use them, but also the motivation and design patterns behind them. However, developing, testing, and debugging multithreaded programs can still be very difficult; it is all too easy to create concurrent programs that appear to work, but fail when it matters most: in production, under heavy load. Java Concurrency in Practice arms readers with both the theoretical underpinnings and concrete techniques for building reliable, scalable, maintainable concurrent applications. Rather than simply offering an inventory of concurrency APIs and mechanisms, it provides design rules, patterns, and mental models that make it easier to build concurrent programs that are both correct and performant.   This book covers: Basic concepts of concurrency and thread safety Techniques for building and composing thread-safe classes Using the concurrency building blocks in java.util.concurrent Performance optimization dos and don’ts Testing concurrent programs Advanced topics such as atomic variables, nonblocking algorithms, and the Java Memory Model.

Java Concurrency in Practice 1st Table of contents:

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
I Fundamentals
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
3 Sharing Objects
3.1 Visibility
3.2 Publication and escape
3.3 Thread confinement
3.4 Immutability
3.5 Safe publication
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
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
II Structuring Concurrent Applications
6 Task Execution
6.1 Executing tasks in threads
6.2 The Executor framework
6.3 Finding exploitable parallelism
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
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
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
III Liveness, Performance, and Testing
10 Avoiding Liveness Hazards
10.1 Deadlock.
10.2 Avoiding and diagnosing deadlocks
10.3 Other liveness hazards
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
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
IV Advanced Topics
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
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
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
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

People also search for Java Concurrency in Practice 1st:

java concurrency in practice
    
is java concurrency in practice still valid
    
java concurrency in practice 2nd edition
    
java concurrency in practice 3rd edition
    
java concurrency in practice 1e