AI ART 037

 

Voici un exemple détaillé en C# utilisant le multithreading avec un Semaphore pour contrôler l'accès à une ressource partagée :

```csharp

using System;

using System.Threading;

class Program

{

static Semaphore semaphore = new Semaphore(2, 2); // Création d'un Semaphore avec une limite de 2

static void Main(string[] args)

{

// Création de plusieurs threads pour accéder à la ressource partagée

Thread[] threads = new Thread[5];

for (int i = 0; i < threads.Length; i++)

{

threads[i] = new Thread(DoWork);

threads[i].Start(i + 1); // Passer un identifiant de thread unique

}

foreach (Thread thread in threads)

{

thread.Join(); // Attente de la fin de chaque thread

}

Console.WriteLine("Travail terminé.");

Console.ReadKey();

}

static void DoWork(object threadId)

{

int id = (int)threadId;

semaphore.WaitOne(); // Demande d'accès au Semaphore

try

{

// Section critique : accès à la ressource partagée

Console.WriteLine("Thread {0} est en train de travailler.", id);

Thread.Sleep(1000); // Simule un travail en cours

}

finally

{

semaphore.Release(); // Libération du Semaphore

Console.WriteLine("Thread {0} a libéré le Semaphore.", id);

}

}

}

```

Dans cet exemple, nous avons une classe `Program` avec une méthode `Main` qui crée cinq threads qui exécutent la méthode `DoWork`. La méthode `DoWork` est la méthode exécutée par chaque thread.

Nous avons initialisé un Semaphore avec une limite de 2. Cela signifie que seulement deux threads peuvent accéder simultanément à la ressource partagée.

Avant d'entrer dans la section critique (partie où la ressource partagée est utilisée), chaque thread appelle `WaitOne` sur le Semaphore pour demander l'accès. Si le Semaphore est déjà au maximum de sa capacité, le thread attendra jusqu'à ce qu'un autre thread libère une place en appelant `Release` sur le Semaphore.

Une fois le travail terminé dans la section critique, le thread appelle `Release` pour libérer le Semaphore et permettre à d'autres threads d'y accéder.