Interlocked.Increment Método

Definición

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

Sobrecargas

Increment(Int32)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

Increment(Int64)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

Increment(UInt32)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

Increment(UInt64)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

Increment(Int32)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

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.The variable whose value is to be incremented.

Devoluciones

Int32

Valor incrementado.The incremented value.

Excepciones

La dirección de location es un puntero null.The address of location is a null pointer.

Ejemplos

En el ejemplo siguiente se determina cuántos números aleatorios comprendidos entre 0 y 1.000 son necesarios para generar 1.000 números aleatorios con un valor de punto medio.The following example determines how many random numbers that range from 0 to 1,000 are required to generate 1,000 random numbers with a midpoint value. Para realizar un seguimiento del número de valores de punto medio, una variable, midpointCount , se establece en 0 y se incrementa cada vez que el generador de números aleatorios devuelve un valor de punto medio hasta que alcanza 10.000.To keep track of the number of midpoint values, a variable, midpointCount, is set equal to 0 and incremented each time the random number generator returns a midpoint value until it reaches 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.Because three threads generate the random numbers, the Increment(Int32) method is called to ensure that multiple threads don't update midpointCount concurrently. Tenga en cuenta que también se usa un bloqueo para proteger el generador de números aleatorios y que CountdownEvent se usa un objeto para asegurarse de que el Main método no finaliza la ejecución antes de los tres subprocesos.Note that a lock is also used to protect the random number generator, and that a CountdownEvent object is used to ensure that the Main method doesn't finish execution before the three 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 = 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.The following example is similar to the previous one, except that it uses the Task class instead of a thread procedure to generate 50,000 random midpoint integers. En este ejemplo, una expresión lambda reemplaza el GenerateNumbers procedimiento del subproceso y la llamada al Task.WaitAll método elimina la necesidad del CountdownEvent objeto.In this example, a lambda expression replaces the GenerateNumbers thread procedure, and the call to the Task.WaitAll method eliminates the need for the CountdownEvent object.

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 mediante el encapsulado: if location = Int32.MaxValue , location + 1 = Int32.MinValue .This method handles an overflow condition by wrapping: if location = Int32.MaxValue, location + 1 = Int32.MinValue. No se inicia ninguna excepción.No exception is thrown.

Se aplica a

Increment(Int64)

Aumenta el valor de una variable especificada y almacena el resultado, como una operación atómica.Increments a specified variable and stores the result, as an atomic operation.

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.The variable whose value is to be incremented.

Devoluciones

Int64

Valor incrementado.The incremented value.

Excepciones

La dirección de location es un puntero null.The address of location is a null pointer.

Comentarios

Este método controla una condición de desbordamiento mediante el encapsulado: if location = Int64.MaxValue , location + 1 = Int64.MinValue .This method handles an overflow condition by wrapping: if location = Int64.MaxValue, location + 1 = Int64.MinValue. No se inicia ninguna excepción.No exception is thrown.

Consulte también

Se aplica a

Increment(UInt32)

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.Increments a specified variable and stores the result, as an atomic operation.

public:
 static System::UInt32 Increment(System::UInt32 % location);
[System.CLSCompliant(false)]
public static uint Increment (ref uint location);
public static uint Increment (ref uint location);
[<System.CLSCompliant(false)>]
static member Increment : uint32 -> uint32
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.The variable whose value is to be incremented.

Devoluciones

UInt32

Valor incrementado.The incremented value.

Atributos

Excepciones

La dirección de location es un puntero null.The address of location is a null pointer.

Se aplica a

Increment(UInt64)

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.Increments a specified variable and stores the result, as an atomic operation.

public:
 static System::UInt64 Increment(System::UInt64 % location);
[System.CLSCompliant(false)]
public static ulong Increment (ref ulong location);
public static ulong Increment (ref ulong location);
[<System.CLSCompliant(false)>]
static member Increment : uint64 -> uint64
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.The variable whose value is to be incremented.

Devoluciones

UInt64

Valor incrementado.The incremented value.

Atributos

Excepciones

La dirección de location es un puntero null.The address of location is a null pointer.

Se aplica a