Comment utiliser l’instruction Lock et Unlock dans

L’utilisation des instructions `Lock` et `Unlock` est courante dans les langages de programmation qui permettent de gérer la synchronisation des threads, comme C# ou Visual Basic. Ces instructions sont utilisées pour protéger des sections critiques du code afin d’assurer que seulement un thread à la fois peut accéder à une ressource partagée.

Voici comment vous pouvez utiliser ces instructions dans un langage tel que C# :

En C#

En C#, l’instruction `lock` est utilisée pour obtenir un verrou sur un objet donné, ce qui empêche d’autres threads d’exécuter le même bloc de code tant qu’il n’a pas été libéré.

using System;
using System.Threading;

class Example
{
    private static readonly object _lockObject = new object();
    private static int _sharedResource = 0;

    static void Main()
    {
        Thread t1 = new Thread(IncrementResource);
        Thread t2 = new Thread(IncrementResource);

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();

        Console.WriteLine("Final value of shared resource: " + _sharedResource);
    }

    static void IncrementResource()
    {
        for (int i = 0; i < 1000; i++)
        {
            lock (_lockObject)
            {
                // Section critique
                _sharedResource++;
            }
        }
    }
}

En Visual Basic .NET

En Visual Basic, il existe également un mécanisme similaire pour utiliser `SyncLock` et `End SyncLock` pour gérer les sections critiques.

Imports System
Imports System.Threading

Module Example
    Dim _lockObject As New Object()
    Dim _sharedResource As Integer = 0

    Sub Main()
        Dim t1 As New Thread(AddressOf IncrementResource)
        Dim t2 As New Thread(AddressOf IncrementResource)

        t1.Start()
        t2.Start()

        t1.Join()
        t2.Join()

        Console.WriteLine("Final value of shared resource: " & _sharedResource)
    End Sub

    Sub IncrementResource()
        For i As Integer = 1 To 1000
            SyncLock _lockObject
                ' Section critique
                _sharedResource += 1
            End SyncLock
        Next
    End Sub
End Module

Points à retenir :

Objet de verrouillage : Utilisez un objet dédié (_lockObject dans les exemples ci-dessus) pour verrouiller la section critique.
Section critique : Code qui modifie ou lit des ressources partagées et qui doit être protégé.
Libération du verrou : En C#, le verrou est automatiquement libéré lorsque le bloc de code sous `lock` est terminé. En Visual Basic, c’est similaire avec `End SyncLock`.
Éviter les Deadlocks : Faites attention à ne pas créer de situations où deux threads se verrouillent mutuellement.

En utilisant correctement les instructions `Lock` et `Unlock`, vous pouvez éviter les problèmes de conditions de compétition et garantir le bon fonctionnement multithreadé de votre application.

facebooklinkedin