Condividi tramite

Istruzione SyncLock

  • Articolo

Acquisisce un blocco esclusivo per un blocco di istruzioni prima di eseguire il blocco.

Sintassi

SyncLock lockobject  
    [ block ]  
End SyncLock

Parti

lockobject
Obbligatorio. Espressione che restituisce un riferimento a un oggetto.

block
Facoltativo. Blocco di istruzioni da eseguire quando viene acquisito il blocco.

End SyncLock
Termina un blocco SyncLock.

Osservazioni:

L'istruzione SyncLock garantisce che più thread non eseguono contemporaneamente il blocco di istruzioni. SyncLock impedisce a ogni thread di immettere il blocco fino a quando nessun altro thread lo sta eseguendo.

L'uso più comune di SyncLock consiste nel proteggere i dati dall'aggiornamento simultaneo di più thread. Se le istruzioni che modificano i dati devono andare al completamento senza interruzioni, inserirle all'interno di un blocco SyncLock.

Un blocco di istruzioni protetto da un blocco esclusivo viene talvolta definito sezione critica.

Regole

  • Ramificazione. Non è possibile creare un ramo in un blocco SyncLock dall'esterno del blocco.

  • Valore dell'oggetto Lock. Il valore di lockobject non può essere Nothing. È necessario creare l'oggetto lock prima di usarlo in un'istruzione SyncLock.

    Non è possibile modificare il valore di lockobject durante l'esecuzione di un blocco di SyncLock. Il meccanismo richiede che l'oggetto lock rimanga invariato.

  • Non è possibile usare l'operatore Await in un blocco SyncLock.

Comportamento

  • Meccanismo. Quando un thread raggiunge l'istruzione SyncLock, valuta l'espressione e sospende l'esecuzione lockobject finché non acquisisce un blocco esclusivo sull'oggetto restituito dall'espressione. Quando un altro thread raggiunge l'istruzione SyncLock, non acquisisce un blocco finché il primo thread non esegue l'istruzione End SyncLock.

  • Dati protetti. Se lockobject è una variabile Shared, il blocco esclusivo impedisce a un thread in qualsiasi istanza della classe di eseguire il blocco SyncLock mentre è in esecuzione qualsiasi altro thread. In questo modo vengono protetti i dati condivisi tra tutte le istanze.

    Se lockobject è una variabile di istanza (non Shared), il blocco impedisce a un thread in esecuzione nell'istanza corrente di eseguire il blocco SyncLock contemporaneamente a un altro thread nella stessa istanza. In questo modo vengono protetti i dati gestiti dalla singola istanza.

  • Acquisizione e rilascio. Un blocco SyncLock si comporta come una costruzione di Try...Finally in cui il blocco Try acquisisce un blocco esclusivo su lockobject e il blocco Finally lo rilascia. Per questo motivo, il blocco SyncLock garantisce il rilascio del blocco, indipendentemente dalla modalità di uscita del blocco. Questo vale anche nel caso di un'eccezione non gestita.

  • Chiamate al framework. Il blocco SyncLock acquisisce e rilascia il blocco esclusivo chiamando i metodi Enter e Exit della classe Monitor nello spazio dei nomi System.Threading.

Procedure di programmazione

L'espressione lockobject deve sempre restituire un oggetto che appartiene esclusivamente alla classe. È necessario dichiarare una variabile oggetto Private per proteggere i dati appartenenti all'istanza corrente o una variabile oggetto Private Shared per proteggere i dati comuni a tutte le istanze.

Non usare la parola chiave Me per fornire un oggetto lock per i dati dell'istanza. Se il codice esterno alla classe ha un riferimento a un'istanza della classe, può usare tale riferimento come oggetto lock per un blocco SyncLock completamente diverso da quello dell'utente, proteggendo dati diversi. In questo modo, la classe e l'altra classe potrebbero impedire l'esecuzione dei blocchi SyncLock non correlati. Analogamente, il blocco su una stringa può essere problematico perché qualsiasi altro codice nel processo che usa la stessa stringa condividerà lo stesso blocco.

Non è inoltre consigliabile utilizzare il metodo Me.GetType per fornire un oggetto lock per i dati condivisi. Ciò è dovuto al fatto che GetType restituisce sempre lo stesso oggetto Type per un determinato nome di classe. Il codice esterno può chiamare GetType nella classe e ottenere lo stesso oggetto di blocco in uso. In questo modo le due classi si bloccano tra loro dai blocchi SyncLock.

Esempi

Descrizione

Nell'esempio seguente viene illustrata una classe che gestisce un elenco semplice di messaggi. Contiene i messaggi in una matrice e l'ultimo elemento usato di tale matrice in una variabile. La routine addAnotherMessage incrementa l'ultimo elemento e archivia il nuovo messaggio. Queste due operazioni sono protette dalle istruzioni SyncLock e End SyncLock, perché una volta incrementato l'ultimo elemento, il nuovo messaggio deve essere archiviato prima che qualsiasi altro thread possa incrementare nuovamente l'ultimo elemento.

Se la classe simpleMessageList ha condiviso un elenco di messaggi tra tutte le relative istanze, le variabili messagesList e messagesLast verranno dichiarate come Shared. In questo caso, la variabile messagesLock deve anche essere Shared, in modo che ci sia un singolo oggetto lock usato da ogni istanza.

Codice

Class simpleMessageList
    Public messagesList() As String = New String(50) {}
    Public messagesLast As Integer = -1
    Private messagesLock As New Object
    Public Sub addAnotherMessage(ByVal newMessage As String)
        SyncLock messagesLock
            messagesLast += 1
            If messagesLast < messagesList.Length Then
                messagesList(messagesLast) = newMessage
            End If
        End SyncLock
    End Sub
End Class

Descrizione

Nell'esempio seguente vengono usati thread e SyncLock. Finché è presente l'istruzione SyncLock, il blocco di istruzioni rimarrà una sezione critica e balance non diventa mai un numero negativo. È possibile impostare come commento le istruzioni SyncLock e End SyncLock per visualizzare l'effetto di uscire dalla parola chiave SyncLock.

Codice

Imports System.Threading

Module Module1

    Class Account
        Dim thisLock As New Object
        Dim balance As Integer

        Dim r As New Random()

        Public Sub New(ByVal initial As Integer)
            balance = initial
        End Sub

        Public Function Withdraw(ByVal amount As Integer) As Integer
            ' This condition will never be true unless the SyncLock statement
            ' is commented out:
            If balance < 0 Then
                Throw New Exception("Negative Balance")
            End If

            ' Comment out the SyncLock and End SyncLock lines to see
            ' the effect of leaving out the SyncLock keyword.
            SyncLock thisLock
                If balance >= amount Then
                    Console.WriteLine("Balance before Withdrawal :  " & balance)
                    Console.WriteLine("Amount to Withdraw        : -" & amount)
                    balance = balance - amount
                    Console.WriteLine("Balance after Withdrawal  :  " & balance)
                    Return amount
                Else
                    ' Transaction rejected.
                    Return 0
                End If
            End SyncLock
        End Function

        Public Sub DoTransactions()
            For i As Integer = 0 To 99
                Withdraw(r.Next(1, 100))
            Next
        End Sub
    End Class

    Sub Main()
        Dim threads(10) As Thread
        Dim acc As New Account(1000)

        For i As Integer = 0 To 9
            Dim t As New Thread(New ThreadStart(AddressOf acc.DoTransactions))
            threads(i) = t
        Next

        For i As Integer = 0 To 9
            threads(i).Start()
        Next
    End Sub

End Module

Commenti

Vedi anche