Compartilhar via

Interlocked.Decrement Método

  • Referência

Definição

Namespace:
System.Threading
Assembly:
System.Threading.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.

Sobrecargas

Decrement(Int64)

Diminui uma variável especificada e armazena o resultado como uma operação atômica.
Decrement(Int32)

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.
Decrement(UInt32)

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.
Decrement(UInt64)

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.

Decrement(Int64)

Origem:
Interlocked.CoreCLR.cs
Origem:
Interlocked.CoreCLR.cs
Origem:
Interlocked.CoreCLR.cs

Diminui uma variável especificada e armazena o resultado como uma operação atômica.

public:
 static long Decrement(long % location);
public static long Decrement (ref long location);
static member Decrement : int64 -> int64
Public Shared Function Decrement (ByRef location As Long) As Long

Parâmetros

location
Int64

A variável cujo valor deve ser decrementado.

Retornos

Int64

O valor da variável imediatamente após a conclusão da operação de decremento.

Exceções

ArgumentNullException

O endereço de location é um ponteiro null.

NullReferenceException

O endereço de location é um ponteiro null.

Comentários

Esse método manipula uma condição de estouro encapsulando: se location = Int64.MinValue, location - 1 = Int64.MaxValue. Nenhuma exceção é gerada.

Confira também

Aplica-se a

Decrement(Int32)

Origem:
Interlocked.CoreCLR.cs
Origem:
Interlocked.CoreCLR.cs
Origem:
Interlocked.CoreCLR.cs

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.

public:
 static int Decrement(int % location);
public static int Decrement (ref int location);
static member Decrement : int -> int
Public Shared Function Decrement (ByRef location As Integer) As Integer

Parâmetros

location
Int32

A variável cujo valor deve ser decrementado.

Retornos

Int32

O valor da variável imediatamente após a conclusão da operação de decremento.

Exceções

ArgumentNullException

O endereço de location é um ponteiro null.

NullReferenceException

O endereço de location é um ponteiro null.

Exemplos

O exemplo a seguir determina quantos números aleatórios que variam de 0 a 1.000 são necessários para gerar 1.000 números aleatórios com um valor de ponto médio. Para acompanhar o número de valores de ponto médio, uma variável , midpointCounté definida como 1.000 e decrementada sempre que o gerador de número aleatório retorna um valor de ponto médio. Como três threads geram os números aleatórios, o Decrement(Int32) método é chamado para garantir que vários threads não sejam atualizados midpointCount simultaneamente. Observe que um bloqueio também é usado para proteger o gerador de número aleatório e que um CountdownEvent objeto é usado para garantir que o método não conclua a Main execução antes dos três threads.

using System;
using System.Threading;

public class Example
{
   const int LOWERBOUND = 0;
   const int UPPERBOUND = 1001;
   
   static Object lockObj = new Object();
   static Random rnd = new Random();
   static CountdownEvent cte;
   
   static int totalCount = 0;
   static int totalMidpoint = 0;
   static int midpointCount = 10000;

   public static void Main()
   {
      cte = new CountdownEvent(1);
      // Start three threads. 
      for (int ctr = 0; ctr <= 2; ctr++) {
         cte.AddCount();
         Thread th = new Thread(GenerateNumbers);
         th.Name = "Thread" + ctr.ToString();
         th.Start();
      }
      cte.Signal();
      cte.Wait();
      Console.WriteLine();
      Console.WriteLine("Total midpoint values:  {0,10:N0} ({1:P3})",
                        totalMidpoint, totalMidpoint/((double)totalCount));
      Console.WriteLine("Total number of values: {0,10:N0}", 
                        totalCount);                  
   }

   private static void GenerateNumbers()
   {
      int midpoint = (UPPERBOUND - LOWERBOUND) / 2;
      int value = 0;
      int total = 0;
      int midpt = 0;
      
      do {
         lock (lockObj) {
            value = rnd.Next(LOWERBOUND, UPPERBOUND);
         }
         if (value == midpoint) { 
            Interlocked.Decrement(ref midpointCount);
            midpt++;
         }
         total++;    
      } while (Volatile.Read(ref midpointCount) > 0);
      
      Interlocked.Add(ref totalCount, total);
      Interlocked.Add(ref totalMidpoint, midpt);
      
      string s = String.Format("Thread {0}:\n", Thread.CurrentThread.Name) +
                 String.Format("   Random Numbers: {0:N0}\n", total) + 
                 String.Format("   Midpoint values: {0:N0} ({1:P3})", midpt, 
                               ((double) midpt)/total);
      Console.WriteLine(s);
      cte.Signal();
   }
}
// The example displays output like the following:
//       Thread Thread2:
//          Random Numbers: 3,204,021
//          Midpoint values: 3,156 (0.099 %)
//       Thread Thread0:
//          Random Numbers: 4,073,592
//          Midpoint values: 4,015 (0.099 %)
//       Thread Thread1:
//          Random Numbers: 2,828,192
//          Midpoint values: 2,829 (0.100 %)
//       
//       Total midpoint values:      10,000 (0.099 %)
//       Total number of values: 10,105,805

Imports System.Threading

Module Example
   Const LOWERBOUND As Integer = 0
   Const UPPERBOUND As Integer = 1001
   
   Dim lockObj As New Object()
   Dim rnd As New Random()
   Dim cte As CountdownEvent
   
   Dim totalCount As Integer = 0
   Dim totalMidpoint As Integer = 0
   Dim midpointCount As Integer = 10000

   Public Sub Main()
      cte = New CountdownEvent(1)
      ' Start three threads. 
      For ctr As Integer = 0 To 2
         cte.AddCount()
         Dim th As New Thread(AddressOf GenerateNumbers)
         th.Name = "Thread" + ctr.ToString()
         th.Start()
      Next
      cte.Signal()
      cte.Wait()
      Console.WriteLine()
      Console.WriteLine("Total midpoint values:  {0,10:N0} ({1:P3})",
                        totalMidpoint, totalMidpoint/totalCount)
      Console.WriteLine("Total number of values: {0,10:N0}", 
                        totalCount)                  
   End Sub
   
   Private Sub GenerateNumbers()
      Dim midpoint As Integer = (upperBound - lowerBound) \ 2
      Dim value As Integer = 0
      Dim total As Integer = 0
      Dim midpt As Integer = 0
      Do
         SyncLock lockObj
            value = rnd.Next(lowerBound, upperBound)
         End SyncLock
         If value = midpoint Then 
            Interlocked.Decrement(midpointCount)
            midpt += 1
         End If
         total += 1    
      Loop While midpointCount > 0
      
      Interlocked.Add(totalCount, total)
      Interlocked.Add(totalMidpoint, midpt)
      
      Dim s As String = String.Format("Thread {0}:", Thread.CurrentThread.Name) + vbCrLf +
                        String.Format("   Random Numbers: {0:N0}", total) + vbCrLf +
                        String.Format("   Midpoint values: {0:N0} ({1:P3})", midpt, midpt/total)
      Console.WriteLine(s)
      cte.Signal()
   End Sub
End Module
' The example displays output like the following:
'       Thread Thread2:
'          Random Numbers: 3,204,021
'          Midpoint values: 3,156 (0.099 %)
'       Thread Thread0:
'          Random Numbers: 4,073,592
'          Midpoint values: 4,015 (0.099 %)
'       Thread Thread1:
'          Random Numbers: 2,828,192
'          Midpoint values: 2,829 (0.100 %)
'       
'       Total midpoint values:      10,000 (0.099 %)
'       Total number of values: 10,105,805

O exemplo a seguir é semelhante ao anterior, exceto que ele usa a Task classe em vez de um procedimento de thread para gerar 50.000 inteiros aleatórios de ponto médio. Neste exemplo, uma expressão lambda substitui o GenerateNumbers procedimento de thread e a chamada para o Task.WaitAll método elimina a necessidade do CountdownEvent objeto.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   const int LOWERBOUND = 0;
   const int UPPERBOUND = 1001;
   
   static Object lockObj = new Object();
   static Random rnd = new Random();
   
   static int totalCount = 0;
   static int totalMidpoint = 0;
   static int midpointCount = 50000;

   public static async Task Main()
   {
      List<Task> tasks = new List<Task>();

      // Start three tasks. 
      for (int ctr = 0; ctr <= 2; ctr++) 
         tasks.Add(Task.Run( () => { int midpoint = (UPPERBOUND - LOWERBOUND) / 2;
                                     int value = 0;
                                     int total = 0;
                                     int midpt = 0;
      
                                     do {
                                        lock (lockObj) {
                                           value = rnd.Next(LOWERBOUND, UPPERBOUND);
                                        }
                                        if (value == midpoint) { 
                                           Interlocked.Decrement(ref midpointCount);
                                           midpt++;
                                        }
                                        total++;    
                                     } while (Volatile.Read(ref midpointCount) > 0);
                                          
                                     Interlocked.Add(ref totalCount, total);
                                     Interlocked.Add(ref totalMidpoint, midpt);
                                          
                                     string s = String.Format("Task {0}:\n", Task.CurrentId) +
                                                String.Format("   Random Numbers: {0:N0}\n", total) + 
                                                String.Format("   Midpoint values: {0:N0} ({1:P3})", midpt, 
                                                              ((double) midpt)/total);
                                     Console.WriteLine(s); 
                                   } ));

      await Task.WhenAll(tasks.ToArray());

      Console.WriteLine();
      Console.WriteLine("Total midpoint values:  {0,10:N0} ({1:P3})",
                        totalMidpoint, totalMidpoint/((double)totalCount));
      Console.WriteLine("Total number of values: {0,10:N0}", 
                        totalCount);                  
   }
}
// The example displays output like the following:
//       Task 1:
//          Random Numbers: 24,530,624
//          Midpoint values: 24,675 (0.101 %)
//       Task 2:
//          Random Numbers: 7,079,718
//          Midpoint values: 7,093 (0.100 %)
//       Task 3:
//          Random Numbers: 18,284,617
//          Midpoint values: 18,232 (0.100 %)
//       
//       Total midpoint values:      50,000 (0.100 %)
//       Total number of values: 49,894,959

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Const LOWERBOUND As Integer = 0
   Const UPPERBOUND As Integer = 1001
   
   Dim lockObj As New Object()
   Dim rnd As New Random()
   
   Dim totalCount As Integer = 0
   Dim totalMidpoint As Integer = 0
   Dim midpointCount As Integer = 50000

   Public Sub Main()
      Dim tasks As New List(Of Task)()

      ' Start three tasks. 
      For ctr As Integer = 0 To 2
         tasks.Add( Task.Run(Sub() 
                                Dim midpoint As Integer = (upperBound - lowerBound) \ 2
                                Dim value As Integer = 0
                                Dim total As Integer = 0
                                Dim midpt As Integer = 0
                                Do
                                   SyncLock lockObj
                                      value = rnd.Next(lowerBound, upperBound)
                                   End SyncLock
                                   If value = midpoint Then 
                                      Interlocked.Decrement(midpointCount)
                                      midpt += 1
                                   End If
                                   total += 1    
                                Loop While midpointCount > 0
                              
                                Interlocked.Add(totalCount, total)
                                Interlocked.Add(totalMidpoint, midpt)
                              
                                Dim s As String = String.Format("Task {0}:", Task.CurrentId) + vbCrLf +
                                                  String.Format("   Random Numbers: {0:N0}", total) + vbCrLf +
                                                  String.Format("   Midpoint values: {0:N0} ({1:P3})", midpt, midpt/total)
                                Console.WriteLine(s)
                             End Sub ))
      Next
      Task.WaitAll(tasks.ToArray())
      Console.WriteLine()
      Console.WriteLine("Total midpoint values:  {0,10:N0} ({1:P3})",
                        totalMidpoint, totalMidpoint/totalCount)
      Console.WriteLine("Total number of values: {0,10:N0}", 
                        totalCount)                  
   End Sub
End Module
' The example displays output like the following:
'       Task 1:
'          Random Numbers: 24,530,624
'          Midpoint values: 24,675 (0.101 %)
'       Task 2:
'          Random Numbers: 7,079,718
'          Midpoint values: 7,093 (0.100 %)
'       Task 3:
'          Random Numbers: 18,284,617
'          Midpoint values: 18,232 (0.100 %)
'       
'       Total midpoint values:      50,000 (0.100 %)
'       Total number of values: 49,894,959

Comentários

Esse método manipula uma condição de estouro encapsulando: se location = Int32.MinValue, location - 1 = Int32.MaxValue. Nenhuma exceção é gerada.

Confira também

Aplica-se a

Decrement(UInt32)

Origem:
Interlocked.cs
Origem:
Interlocked.cs
Origem:
Interlocked.cs

Importante

Esta API não está em conformidade com CLS.

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.

public:
 static System::UInt32 Decrement(System::UInt32 % location);
[System.CLSCompliant(false)]
public static uint Decrement (ref uint location);
[<System.CLSCompliant(false)>]
static member Decrement : uint32 -> uint32
Public Shared Function Decrement (ByRef location As UInteger) As UInteger

Parâmetros

location
UInt32

A variável cujo valor deve ser decrementado.

Retornos

UInt32

O valor da variável imediatamente após a conclusão da operação de decremento.

Atributos
CLSCompliantAttribute

Exceções

NullReferenceException

O endereço de location é um ponteiro null.

Aplica-se a

Decrement(UInt64)

Origem:
Interlocked.cs
Origem:
Interlocked.cs
Origem:
Interlocked.cs

Importante

Esta API não está em conformidade com CLS.

Decrementa uma variável especificada e armazena o resultado, como uma operação atômica.

public:
 static System::UInt64 Decrement(System::UInt64 % location);
[System.CLSCompliant(false)]
public static ulong Decrement (ref ulong location);
[<System.CLSCompliant(false)>]
static member Decrement : uint64 -> uint64
Public Shared Function Decrement (ByRef location As ULong) As ULong

Parâmetros

location
UInt64

A variável cujo valor deve ser decrementado.

Retornos

UInt64

O valor da variável imediatamente após a conclusão da operação de decremento.

Atributos
CLSCompliantAttribute

Exceções

NullReferenceException

O endereço de location é um ponteiro null.

Aplica-se a