Locks and Synchronisation

Lock Fundamentals

• Provide blocking mechanisms for thread coordination

• Threads block when lock unavailable

• Enables independent coordination of threads.

java.util.concurrent.locks.ReentrantLock

• Java 5+ lock class

• TryLock() for non-blocking attempts

• LockInterruptibly() for interruptible blocking

• GetQueuedThreads() displays waiting threads

• Client explicitly acquires/releases.

Deadlock Definition

• Situation with multiple threads

• Each holds resources while waiting

• Causes all threads to halt

• Requires circular wait condition.

Dining Philosophers Problem

• Classic example of deadlock

• 5 philosophers need 2 forks to eat

• Simultaneous grab leads to deadlock

• Changing order can prevent deadlock.

Lock Overhead

• Computation cycles from lock activities

• Increased overhead with frequent locking

• Small code regions see higher overhead.

Lock Contention

• Occurs when one thread acquires while another holds lock

• Larger code blocks heighten contention risk.

Lock Granularity Trade-off

• Fine-grained concurrency: more locks, higher overhead
• Coarse-grained: fewer locks, lower overhead, higher contention.

Lock Composability Problem

• Operations with multiple locks may not be thread-safe
• Increases deadlock/contention risk.

Intrinsic Locking (synchronized)

• Automatically acquires lock at block entry
• Releases on exit
• Prevents lock release oversight
• Deadlocks still possible.

Producer/Consumer Problem

• Classic concurrency challenge
• Producer writes to shared buffer
• Consumer reads from it
• Coordination needed for empty buffer.

Monitor Definition

• High-level concurrency primitive
• Provides wait() and notify()/notifyAll()
• Built into Java via synchronized blocks.

wait() Method

• Called on monitor object
• Blocks thread in monitor's wait queue
• Releases monitor lock
• Throws InterruptedException.

notify() Method

• Called on monitor object
• Wakes one thread from wait queue
• Does not run immediately, must reacquire lock.

Circular Buffer with Monitors

• Fixed-size buffer
• Synchronized put() and take()
• Uses wait() and notify() correctly.

java.util.concurrent Recommendation

• Prefer built-in concurrent implementations
• Library offers efficient solutions to common patterns.

BlockingQueue/BlockingDeque

• Thread-safe queue/deque implementations
• Allow threads to block on empty/full
• Provide safe shared buffer.

CountDownLatch

• Allows threads to wait until operations complete
• Initialized with count
• Single-use and cannot reset.

CyclicBarrier

• Reusable barrier for threading
• Threads wait until specified number arrive
• Optionally executes Runnable on trip.

Phaser

• Generalized form of CyclicBarrier
• Supports dynamic thread registration
• Allows arrival without waiting.