Interlocked Classe

Definição

public ref class Interlocked abstract sealed

public ref class Interlocked sealed

public static class Interlocked

public sealed class Interlocked

type Interlocked = class

Public Class Interlocked

Public NotInheritable Class Interlocked

Herança

Object

Interlocked

Exemplos

O seguinte exemplo de código mostra um mecanismo de bloqueio de recursos seguro para threads.

using System;
using System.Threading;

namespace InterlockedExchange_Example
{
    class MyInterlockedExchangeExampleClass
    {
        //0 for false, 1 for true.
        private static int usingResource = 0;

        private const int numThreadIterations = 5;
        private const int numThreads = 10;

        static void Main()
        {
            Thread myThread;
            Random rnd = new Random();

            for(int i = 0; i < numThreads; i++)
            {
                myThread = new Thread(new ThreadStart(MyThreadProc));
                myThread.Name = String.Format("Thread{0}", i + 1);
            
                //Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000));
                myThread.Start();
            }
        }

        private static void MyThreadProc()
        {
            for(int i = 0; i < numThreadIterations; i++)
            {
                UseResource();
            
                //Wait 1 second before next attempt.
                Thread.Sleep(1000);
            }
        }

        //A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if(0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);
            
                //Code to access a resource that is not thread safe would go here.
            
                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);
            
                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }
    }
}

Imports System.Threading

Namespace InterlockedExchange_Example
    Class MyInterlockedExchangeExampleClass
        '0 for false, 1 for true.
        Private Shared usingResource As Integer = 0

        Private Const numThreadIterations As Integer = 5
        Private Const numThreads As Integer = 10

        <MTAThread> _
        Shared Sub Main()
            Dim myThread As Thread
            Dim rnd As New Random()

            Dim i As Integer
            For i = 0 To numThreads - 1
                myThread = New Thread(AddressOf MyThreadProc)
                myThread.Name = String.Format("Thread{0}", i + 1)

                'Wait a random amount of time before starting next thread.
                Thread.Sleep(rnd.Next(0, 1000))
                myThread.Start()
            Next i
        End Sub

        Private Shared Sub MyThreadProc()
            Dim i As Integer
            For i = 0 To numThreadIterations - 1
                UseResource()

                'Wait 1 second before next attempt.
                Thread.Sleep(1000)
            Next i
        End Sub 

        'A simple method that denies reentrancy.
        Shared Function UseResource() As Boolean
            '0 indicates that the method is not in use.
            If 0 = Interlocked.Exchange(usingResource, 1) Then
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name)

                'Code to access a resource that is not thread safe would go here.
                'Simulate some work
                Thread.Sleep(500)

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name)

                'Release the lock
                Interlocked.Exchange(usingResource, 0)
                Return True
            Else
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name)
                Return False
            End If
        End Function 
    End Class 
End Namespace

Observações

Os métodos desta classe ajudam a proteger contra erros que podem ocorrer quando o escalonador muda de contexto enquanto uma thread atualiza uma variável que pode ser acedida por outras threads, ou quando duas threads estão a executar simultaneamente em processadores separados. Os membros desta turma não fazem exceções.

Os Increment métodos e Decrement incrementam ou diminuem uma variável e armazenam o valor resultante numa única operação. Na maioria dos computadores, incrementar uma variável não é uma operação atómica, exigindo os seguintes passos:

1. Carrega um valor de uma variável de instância num registo.
2. Incremente ou diminua o valor.
3. Armazene o valor na variável de instância.

Se não usar Increment e Decrement, uma thread pode ser preemptada após executar os dois primeiros passos. Outro thread pode então executar os três passos. Quando a primeira thread retoma a execução, sobreescreve o valor na variável de instância, e perde-se o efeito do incremento ou decremento realizado pela segunda thread.

O Add método soma atomicamente um valor inteiro a uma variável inteira e devolve o novo valor da variável.

O método Exchange troca atomicamente os valores das variáveis especificadas. O CompareExchange método combina duas operações: comparar dois valores e armazenar um terceiro valor numa das variáveis, com base no resultado da comparação. As operações de comparação e troca são realizadas como uma operação atómica.

Certifique-se de que qualquer acesso de escrita ou leitura a uma variável partilhada é atómico. Caso contrário, os dados podem estar corrompidos ou o valor carregado pode estar incorreto.

Segurança de Thread

Este tipo é seguro para fios.

Ver também

• de threading gerenciado
• Visão geral das primitivas de sincronização