Lets say I have critical section code written in method A
public void A(){
//Critical Section
}
I can make it synchronized so as to allow exclusive access to it
synchronized public void A(){ }
Or alternatively I can also use a Semaphore class in java
How these two approaches differ in working ?
When using semaphore, you have to remeber to acquire it before critical section and release it after, but you can give access for more threads. Therefore it is commonly used to limit access to resources such as connection pools. You can also gain access to Semaphore object and all it's methods such as tryAcquire which lets you write more flexible code - nevertheless in case of critical sections it is better to use Lock class (just due to it's purpose) - if not synchronized block.
synchronized block is simple "lower level" (than Semaphores) synchronization, it just gives access to section for one thread. You can also limit synchronized block to code which is indeed critical section by using construction:
synchronized(? extends Object) {
// critical section
}
I have gathered a list of interesting links that will shed some light on the differences.
First, be aware that the nomenclature concerning locks/synchronized/monitors is messed up and people (sometimes) use these terms interchangeably.
Second, the links below are not ordered by importance/relevance/clarity
