Using Semaphores to Limit Concurrent Connections

Study Notes

Limiting Concurrent Connections using Semaphores

A server can use semaphores to limit the number of concurrent connections to a certain number (N) by only allowing new connections when an existing connection is released.
This ensures that the server does not accept more than N connections at any point in time.

Binary Semaphore Class

A BinarySemaphore class can be implemented to represent a binary semaphore, which can be used to limit the number of concurrent connections.

Using wait() with while Loops

The wait() statement should always be used within a while loop to ensure that the waiting condition is still true after the thread is awakened.
This is because the wait() method can return spuriously, causing the thread to wake up even when the waiting condition is not met.

Solving the Readers-Writers Problem

The solution to the readers-writers problem does not prevent waiting writers from starving, allowing subsequent readers to read the database before the writer can write.
To modify the solution, waiting writers can be given priority over subsequent readers to prevent starvation.

Monitor-Based Solution to the Dining-Philosophers Problem

A monitor-based solution to the dining-philosophers problem can be developed using Java synchronization and condition variables.
The solution involves using a volatile variable to ensure that the value of the variable is refreshed from main memory during every iteration.

Avoiding Starvation in the Dining-Philosophers Problem

The solution to the dining-philosophers problem can introduce starvation if, for example, two philosophers alternate eating and thinking, preventing the third philosopher from eating.
To prevent starvation, the yield() method can be invoked to keep the thread in the Runnable state and allow the JVM to select another Runnable thread to run.

Java Synchronization and Volatile Variables

The Java Language Specification allows compilers to make optimizations, such as caching the value of a variable in a machine register.
Declaring a variable as volatile prevents the compiler from making such optimizations, ensuring that the value of the variable is refreshed from main memory during every iteration.

Two-Tasks Solutions

Three different Java implementations can be used to coordinate the actions of two different threads, T0 and T1.
Each algorithm implements the MutualExclusion interface, which provides the enteringCriticalSection() and leavingCriticalSection() methods.
The algorithms use condition variables and volatile variables to ensure atomicity and prevent starvation.

Description

Learn how servers can limit the number of concurrent socket connections by using semaphores. Explore the concept of a BinarySemaphore class and the implementation of binary semaphores. Understand the necessity of using the wait() statement in a while loop in Java programs.