First Swing steps

Semaphores

A semaphore keeps a count of how many times a limited resource is being used. When a component needs a shared specific resource, it tries to acquire it from the semaphore which manages it. If the resource is not available, the requesting thread is automatically blocked. As soon as another component releases the resource, one of the waiting threads is awaken and regains control.

Semaphore.java

public class Semaphore {
private int count;
public Semaphore(int n) {
this.count = n;
}
public synchronized void acquire() {
while (count == 0) {
try {
wait();
}
catch (InterruptedException e) {
}
}
count--;
}
public synchronized void release() {
count++;
notify();
}
}

An instance of Semaphore is always initialized with the total number of available units of the resource it manages. The method acquire blocks the execution thread while the counter of the resource is at zero. If the resource is available, the counter is decremented of one and the execution continues normally. The method release increments the counter of one and awakes all the waiting threads of execution with a call to notify. One of them will regain control in the loop of the method acquire and will be able to continue its execution after having reserved the resource.

Note that acquire and release are synchronized in order to prevent any interferences with the counter.

To test Semaphore, we'll create a series of threads of execution which will all try at the same time to use the same limited resource for a given time.

SemaphoreTest.java

public class SemaphoreTest {
private Semaphore sema = new Semaphore(2);
public void go() {
for (int i = 0; i < 7; i++)
(new Thread(new Consumer(i + 1, sema))).start();
}
private class Consumer implements Runnable {
private Semaphore sema;
private int id;
Consumer(int id, Semaphore sema) {
this.sema = sema;
this.id = id;
}
public void run() {
System.out.println(id + " - " + "Acquiring resource");
sema.acquire();
System.out.println(id + " - " + "Resource is locked");
try {
Thread.sleep((long) (Math.random() * 1000));
}
catch (InterruptedException e) {
}
System.out.println(id + " - " + "Releasing resource");
sema.release();
}
}
public static void main(String args[]) {
(new SemaphoreTest()).go();
}
}

The program creates a Semaphore which allows the simultaneous use of two units of a resource, then it starts the parallel execution of seven instances of Consumer which all have acces to the semaphore. A Consumer prints a message before it tries to acquire the resource, calls acquire, prints a message if the resource is available, does something for a while, prints a last message before it releases the resource and calls release.

Note that the program doesn't decide when it can take the resource and continue its execution. All the logic is in Semaphore.

$ javac SemaphoreTest.java
$ java SemaphoreTest
1 - Acquiring resource
1 - Resource is locked
2 - Acquiring resource
2 - Resource is locked
3 - Acquiring resource
4 - Acquiring resource
...
2 - Releasing resource
3 - Resource is locked
3 - Releasing resource
4 - Resource is locked
4 - Releasing resource
1 - Releasing resource
5 - Resource is locked
...

The execution order of the concurrent instances of Consumer can vary.

frasq.org

Semaphores

Comments

Your comment: