Instrução SyncLock

Adquire um bloqueio exclusivo para um bloco de instrução antes de executar o bloco.

Sintaxe

SyncLock lockobject  
    [ block ]  
End SyncLock  

Partes

lockobject
Obrigatório Expressão que é avaliada como uma referência de objeto.

block
Opcional. Bloco de instruções que devem ser executadas quando o bloqueio é adquirido.

End SyncLock
Encerra um SyncLock bloco.

Observações

A SyncLock instrução garante que vários threads não executem o bloco de instrução ao mesmo tempo. SyncLock impede que cada thread insira o bloco até que nenhum outro thread o esteja executando.

O uso SyncLock mais comum é proteger os dados de serem atualizados por mais de um thread simultaneamente. Se as instruções que manipulam os dados precisarem ir para a conclusão sem interrupção, coloque-as dentro de um SyncLock bloco.

Às vezes, um bloco de instrução protegido por um bloqueio exclusivo é chamado de seção crítica.

Regras

• Ramificação. Você não pode ramificar em um SyncLock bloco de fora do bloco.

• Valor do objeto Lock. O valor de lockobject não pode ser Nothing. Você deve criar o objeto de bloqueio antes de usá-lo em uma SyncLock instrução.

  Não é possível alterar o valor durante a execução de lockobject um SyncLock bloco. O mecanismo requer que o objeto de bloqueio permaneça inalterado.

• Você não pode usar o operador Await em um SyncLock bloco.

Comportamento

• Mecanismo. Quando um thread atinge a SyncLock instrução, ele avalia a expressão e suspende a lockobject execução até que ela adquira um bloqueio exclusivo no objeto retornado pela expressão. Quando outro thread atinge a SyncLock instrução, ele não adquire um bloqueio até que o primeiro thread execute a End SyncLock instrução.

• Dados protegidos. Se lockobject for uma Shared variável, o bloqueio exclusivo impedirá que um thread em qualquer instância da classe execute o SyncLock bloco enquanto qualquer outro thread o estiver executando. Isso protege os dados compartilhados entre todas as instâncias.

  Se lockobject for uma variável de instância (não Shared), o bloqueio impedirá que um thread em execução na instância atual execute o SyncLock bloco ao mesmo tempo que outro thread na mesma instância. Isso protege os dados mantidos pela instância individual.

• Aquisição e liberação. Um SyncLock bloco se comporta como uma Try...Finally construção na qual o Try bloco adquire um bloqueio lockobject exclusivo e o bloco o Finally libera. Por isso, o SyncLock bloco garante a liberação do bloqueio, independentemente de você sair do bloco. Isso é verdadeiro mesmo no caso de uma exceção sem tratamento.

• Chamadas de estrutura. O SyncLock bloco adquire e libera o bloqueio exclusivo chamando o e Exit os EnterMonitor métodos da classe no System.Threading namespace.

Práticas de programação

A lockobject expressão sempre deve ser avaliada como um objeto que pertence exclusivamente à sua classe. Você deve declarar uma Private variável de objeto para proteger dados pertencentes à instância atual ou uma Private Shared variável de objeto para proteger dados comuns a todas as instâncias.

Você não deve usar a Me palavra-chave para fornecer um objeto de bloqueio para dados de instância. Se o código externo à sua classe tiver uma referência a uma instância de sua classe, ele poderá usar essa referência como um objeto de bloqueio para um SyncLock bloco completamente diferente do seu, protegendo dados diferentes. Dessa forma, sua classe e a outra classe podem impedir umas às outras de executar seus blocos não relacionados SyncLock . Da mesma forma, o bloqueio em uma cadeia de caracteres pode ser problemático, pois qualquer outro código no processo que usa a mesma cadeia de caracteres compartilhará o mesmo bloqueio.

Você também não deve usar o Me.GetType método para fornecer um objeto de bloqueio para dados compartilhados. Isso ocorre porque GetType sempre retorna o mesmo Type objeto para um determinado nome de classe. O código externo pode chamar GetType sua classe e obter o mesmo objeto de bloqueio que você está usando. Isso resultaria em duas classes bloqueando umas às outras de seus SyncLock blocos.

Exemplos

Descrição

O exemplo a seguir mostra uma classe que mantém uma lista simples de mensagens. Ele contém as mensagens em uma matriz e o último elemento usado dessa matriz em uma variável. O addAnotherMessage procedimento incrementa o último elemento e armazena a nova mensagem. Essas duas operações são protegidas pelas SyncLock instruções e End SyncLock , como depois que o último elemento tiver sido incrementado, a nova mensagem deve ser armazenada antes que qualquer outro thread possa incrementar o último elemento novamente.

Se a simpleMessageList classe compartilhasse uma lista de mensagens entre todas as suas instâncias, as variáveis seriam messagesLast declaradas messagesList como Shared. Nesse caso, a variável messagesLock também deve ser Shared, para que haja um único objeto de bloqueio usado por cada instância.

Code

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

Descrição

O exemplo a seguir usa threads e SyncLock. Desde que a SyncLock instrução esteja presente, o bloco de instrução é uma seção crítica e balance nunca se torna um número negativo. Você pode comentar as instruções e End SyncLock as SyncLock instruções para ver o efeito de deixar de fora a SyncLock palavra-chave.

Code

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

Comentários

Consulte também

• System.Threading.Monitor
• System.Threading.Interlocked
• Visão geral dos primitivos de sincronização