Dr Heinz Kabutz

Dr Heinz Kabutz is best known for his creation of The Java Specialists' Newsletter, read in 120 countries by 50000 Java experts. In his newsletter, he examines advanced aspects of Java that have helped Java developers around the world to produce better code. As someone remarked on the Sun website: "Heinz Kabutz is a hero in the Java Developer Community. His newsletters have saved companies millions by helping burgeoning and experienced programmers deliver high quality products."

In order to fund the newsletter, Heinz writes Java code on contract and runs seminars. His latest creation, Extreme Java - Advanced Topics Course, examines areas of advanced Java. It is one of the only courses specifically aimed at the seasoned Java professional.

The Concurrency Specialist Course

Java was built to be able to do many things at once. In computer lingo, we call this "concurrency". This is the main reason why Java is so useful. Your coders need to master concurrency. If they do not, your system might break on your busiest day. Concurrency bugs tend to appear when we do a lot of things at the same time, such as dealing with many clients. In this course, we combine the collective wisdom of three Java experts: Dr Heinz Kabutz, Victor Grazi and Brian Goetz. Each of these has years of experience in writing concurrent Java programs. During this 4-day course, you will learn how to write safe multi-threaded Java code that performs well on your hardware. You will learn techniques to ensure visibility of your fields, to build thread safety without explicit locking. You will learn the new fork/join constructs and explore ways to parallelize your algorithms.

The Java Concurrency Course is the only such training officially endorsed by Brian Goetz, and is based on his best-seller book Java Concurrency in Practice. The course was written by Dr Heinz Kabutz, author of The Java Specialists' Newsletter, with contributions by Victor Grazi, author of the Java Concurrent Animated Tutorial.

• 1 Introduction
• 1.1 History of concurrency
• 1.2 Benefits of threads
• 1.3 Risks of threads
• 1.4 Threads are everywhere
• 1.5 Short Java 7 Primer

• 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 containers
• 5.2 Concurrent containers
• 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
• 5.7 Summary

• 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.1.1 Interruption
• 7.1.2 Interruption policies
• 7.1.3 Responding to interruption
• 7.1.4 Example: timed run
• 7.1.5 Dealing with non-interruptible blocking
• 7.2 Stopping a thread-based service
• 7.3 Handling abnormal thread termination
• 7.4 JVM shutdown
• 8 Applying Thread Pools
• 8.1 Tasks and Execution Policies
• 8.2 Sizing thread pools
• 8.3 Configuring ThreadPoolExecutor
• 8.4 Extending ThreadPoolExecutor
• 8.5 Parallelizing recursive algorithms
• 9 SwingWorker and Fork/Join
• 9.2 Fork/Join (Java 7)

• 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.2 Amdahl's and Little's laws
• 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.2 Testing for performance

• IV Advanced Topics
• 13 Explicit Locks
• 13.2 Performance considerations
• 13.3 Fairness
• 13.4 Synchronized vs 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 AbstractQueuedSynchronizer (AQS)
• 14.5 Summary
• 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
• 15.5 Summary