Sémaphore

Sémaphore pour synchroniser les ressources

Ce site ne sera plus alimenté de contenu après août 2014. Tous les nouveaux articles seront redigés pour www.waitingforcode.com

Le mot-clé synchronized a provué son utilité lors de synchronisation des ressources en Java. Cependant, il ne garantit pas le vérouillage et le déverouillage effectués par plusieurs Threads. Cet aspect peut être garanti avec l'utilisation des sémaphores.

Qu'est-ce que c'est une sémaphore en Java ?

La sémaphore est une technique qui permet la gestion de ressources avec le mécanisme de vérouillage et déverouillage. Il permet de préciser le nombre de Threads qui peuvent accédér à une ressource à un moment donné.

En gros, on peut faire la même chose qu'avec synchronized. Cependant, l'avantage d'utiliser les sémaphores repose sur le fait de pouvoir gérer l'accès de plusieurs tâches. Regardons cela sur un exemple :

import java.util.concurrent.Semaphore;

public class SemaphoreExemple {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2, true);
        Thread t1 = new Executor("1", semaphore);
        Thread t2 = new Executor("2", semaphore);
        Thread t3 = new Executor("3", semaphore);
        Thread t4 = new Executor("4", semaphore);
  
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

class Executor extends Thread {
    private Semaphore semaphore;
    private String name;
  
    public Executor(String n, Semaphore s) {
        semaphore = s;
        name = n;
    }
  
    public void run() {
        try {
          semaphore.acquire();
          sleep(2000);
          System.out.println(name + " is running \n");
          semaphore.release();
        } catch (InterruptedException e) {
          System.out.println("An error occured " + e.getMessage());
        }
    }
}

On utilise la classe Semaphore qui permet de gérer les verrouillages et déverrouillage. Dans sont constructeur on préciser le nombre des Threads pouvant effectuer une opération au même moment (2 en occurrence) ainsi que une garantie d'acquisition des verrouillage en ordre FIFO (first in, first out; valeur true). Nos 4 Threads possèdent une méthode run() dans lequel est placé l'appel à deux méthodes de la classe Semaphore :
- acquire() : acquiert le verrouillage sur la sémaphore
- release() : relâche le verrouillage et permet au Thread suivant de le prendre

Voici le résultat correct sur l'écran (les messages s'affichent par paire, toutes les 2 secondes) :

1 is running

2 is running

3 is running

4 is running

Remarquons que sans l'appel semaphore.release(), on obtient le problème du starvation qui a été décrit sur la page de synchronisation de ressources en Java.

Bartosz KONIECZNY Concurrence

Une question ? Une remarque ?

*

*

Moi

Développeur d'applications Internet et journaliste passionné par l'adjectif français. Un aigle polonais orienté vers la progression, volant très haut et écoutant du zouk après les matches du foot français.

Vous appréciez mon travail ?

Pour contribuer au développement de ce site, ou pour remercier pour des articles rédigés, vous pouvez faire un don.

Un conseil Android

Un problème de connexion à un web service ou à l'internet.

Vérifiez dans votre AndroidManifest.xml si la balise suivante est présente :
<uses-permission android:name="android.permission.INTERNET" />