Interlocked.Increment Método

Referencia

Definición

Espacio de nombres:: System.Threading

Ensamblado:: System.Threading.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

Sobrecargas

Increment(UInt64)	Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.
Increment(UInt32)	Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.
Increment(Int32)	Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.
Increment(Int64)	Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

Increment(UInt64)

Source:: Interlocked.cs

Source:: Interlocked.cs

Source:: Interlocked.cs

Importante

Esta API no es conforme a CLS.

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

public:
 static System::UInt64 Increment(System::UInt64 % location);

[System.CLSCompliant(false)]
public static ulong Increment (ref ulong location);

[<System.CLSCompliant(false)>]
static member Increment : uint64 -> uint64

Public Shared Function Increment (ByRef location As ULong) As ULong

Parámetros

location: UInt64

Variable cuyo valor se va a incrementar.

Devoluciones

UInt64

Valor de la variable inmediatamente después de que finalice la operación de incremento.

Atributos: CLSCompliantAttribute

Excepciones

NullReferenceException

La dirección de location es un puntero null.

Se aplica a

Increment(UInt32)

Source:: Interlocked.cs

Source:: Interlocked.cs

Source:: Interlocked.cs

Importante

Esta API no es conforme a CLS.

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

public:
 static System::UInt32 Increment(System::UInt32 % location);

[System.CLSCompliant(false)]
public static uint Increment (ref uint location);

[<System.CLSCompliant(false)>]
static member Increment : uint32 -> uint32

Public Shared Function Increment (ByRef location As UInteger) As UInteger

Parámetros

location: UInt32

Variable cuyo valor se va a incrementar.

Devoluciones

UInt32

Valor de la variable inmediatamente después de que finalice la operación de incremento.

Atributos: CLSCompliantAttribute

Excepciones

NullReferenceException

La dirección de location es un puntero null.

Se aplica a

Increment(Int32)

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

public:
 static int Increment(int % location);

public static int Increment (ref int location);

static member Increment : int -> int

Public Shared Function Increment (ByRef location As Integer) As Integer

Parámetros

location: Int32

Variable cuyo valor se va a incrementar.

Devoluciones

Int32

Valor de la variable inmediatamente después de que finalice la operación de incremento.

Excepciones

NullReferenceException

La dirección de location es un puntero null.

Ejemplos

En el ejemplo siguiente se determina cuántos números aleatorios van de 0 a 1000 para generar 1000 números aleatorios con un valor de punto medio. Para realizar un seguimiento del número de valores de punto medio, una variable, midpointCount, se establece igual a 0 e incrementa cada vez que el generador de números aleatorios devuelve un valor de punto medio hasta que alcanza 10 000. Dado que tres subprocesos generan los números aleatorios, Increment(Int32) se llama al método para asegurarse de que varios subprocesos no se actualizan midpointCount simultáneamente. Tenga en cuenta que también se usa un bloqueo para proteger el generador de números aleatorios y que se usa un CountdownEvent objeto para asegurarse de que el método no finaliza la Main ejecución antes de los tres subprocesos.

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 = 0;

   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.Increment(ref midpointCount);
            midpt++;
         }
         total++;    
      } while (Volatile.Read(ref midpointCount) < 10000);
      
      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: 2,776,674
//          Midpoint values: 2,773 (0.100 %)
//       Thread Thread1:
//          Random Numbers: 4,876,100
//          Midpoint values: 4,873 (0.100 %)
//       Thread Thread0:
//          Random Numbers: 2,312,310
//          Midpoint values: 2,354 (0.102 %)
//       
//       Total midpoint values:      10,000 (0.100 %)
//       Total number of values:  9,965,084

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 = 0

   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.Increment(midpointCount)
            midpt += 1
         End If
         total += 1    
      Loop While midpointCount < 10000
      
      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: 2,776,674
'          Midpoint values: 2,773 (0.100 %)
'       Thread Thread1:
'          Random Numbers: 4,876,100
'          Midpoint values: 4,873 (0.100 %)
'       Thread Thread0:
'          Random Numbers: 2,312,310
'          Midpoint values: 2,354 (0.102 %)
'       
'       Total midpoint values:      10,000 (0.100 %)
'       Total number of values:  9,965,084

El ejemplo siguiente es similar al anterior, salvo que usa la Task clase en lugar de un procedimiento de subproceso para generar 50 000 enteros de punto medio aleatorios. En este ejemplo, una expresión lambda reemplaza el procedimiento de GenerateNumbers subproceso y la llamada al Task.WaitAll método elimina la necesidad del 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 = 0;

   public static void 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.Increment(ref midpointCount);
                                           midpt++;
                                        }
                                        total++;    
                                     } while (Volatile.Read(ref midpointCount) < 50000);
                                    
                                     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); } ));
      
      Task.WaitAll(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 3:
//          Random Numbers: 10,855,250
//          Midpoint values: 10,823 (0.100 %)
//       Task 1:
//          Random Numbers: 15,243,703
//          Midpoint values: 15,110 (0.099 %)
//       Task 2:
//          Random Numbers: 24,107,425
//          Midpoint values: 24,067 (0.100 %)
//       
//       Total midpoint values:      50,000 (0.100 %)
//       Total number of values: 50,206,378

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 = 0

   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.Increment(midpointCount)
                                      midpt += 1
                                   End If
                                   total += 1    
                                Loop While midpointCount < 50000
                              
                                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 3:
'          Random Numbers: 10,855,250
'          Midpoint values: 10,823 (0.100 %)
'       Task 1:
'          Random Numbers: 15,243,703
'          Midpoint values: 15,110 (0.099 %)
'       Task 2:
'          Random Numbers: 24,107,425
'          Midpoint values: 24,067 (0.100 %)
'       
'       Total midpoint values:      50,000 (0.100 %)
'       Total number of values: 50,206,378

Comentarios

Este método controla una condición de desbordamiento ajustando: si location = Int32.MaxValue, location + 1 = Int32.MinValue. No se inicia ninguna excepción.

Consulte también

Se aplica a

Increment(Int64)

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.

public:
 static long Increment(long % location);

public static long Increment (ref long location);

static member Increment : int64 -> int64

Public Shared Function Increment (ByRef location As Long) As Long

Parámetros

location: Int64

Variable cuyo valor se va a incrementar.

Devoluciones

Int64

Valor de la variable inmediatamente después de que finalice la operación de incremento.

Excepciones

NullReferenceException

La dirección de location es un puntero null.

Comentarios

Este método controla una condición de desbordamiento ajustando: si location = Int64.MaxValue, location + 1 = Int64.MinValue. No se inicia ninguna excepción.

Consulte también

Se aplica a

Interlocked.Increment Método

Definición

Sobrecargas

Increment(UInt64)

Parámetros

Devoluciones

Excepciones

Se aplica a

Increment(UInt32)

Parámetros

Devoluciones

Excepciones

Se aplica a

Increment(Int32)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Increment(Int64)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

Comentarios

Recursos adicionales