Interlocked.Increment Methode

Definition

Namespace:

System.Threading

Assembly:

System.Threading.dll

Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.

Überlädt

Increment(UInt64)	Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.
Increment(UInt32)	Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.
Increment(Int32)	Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.
Increment(Int64)	Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.

Increment(UInt64)

Quelle:

Interlocked.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.

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

Parameter

location

UInt64

Die Variable, deren Wert inkrementiert werden soll.

Gibt zurück

UInt64

Der Wert der Variablen unmittelbar nach Abschluss des Inkrementvorgangs.

Attribute

CLSCompliantAttribute

Ausnahmen

NullReferenceException

Die Adresse von location ist ein null-Zeiger.

Increment(UInt32)

Quelle:

Interlocked.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren Operation.

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

Parameter

location

UInt32

Die Variable, deren Wert inkrementiert werden soll.

Gibt zurück

UInt32

Der Wert der Variablen unmittelbar nach Abschluss des Inkrementvorgangs.

Attribute

CLSCompliantAttribute

Ausnahmen

NullReferenceException

Die Adresse von location ist ein null-Zeiger.

Increment(Int32)

Quelle:

Interlocked.CoreCLR.cs

Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren 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

Parameter

location

Int32

Die Variable, deren Wert inkrementiert werden soll.

Gibt zurück

Int32

Der Wert der Variablen unmittelbar nach Abschluss des Inkrementvorgangs.

Ausnahmen

NullReferenceException

Die Adresse von location ist ein null-Zeiger.

Beispiele

Das folgende Beispiel bestimmt, wie viele Zufallszahlen zwischen 0 und 1.000 erforderlich sind, um 1.000 Zufallszahlen mit einem Mittelwert zu generieren. Um die Anzahl der Mittelpunktwerte nachzuverfolgen, wird eine Variable , midpointCount, gleich 0 festgelegt und jedes Mal inkrementiert, wenn der Zufallszahlengenerator einen Mittelwert zurückgibt, bis er 10.000 erreicht. Da drei Threads die Zufallszahlen generieren, wird die Increment(Int32) Methode aufgerufen, um sicherzustellen, dass mehrere Threads nicht gleichzeitig aktualisiert werden midpointCount . Beachten Sie, dass eine Sperre auch zum Schutz des Zufallszahlengenerators verwendet wird und dass ein CountdownEvent Objekt verwendet wird, um sicherzustellen, dass die -Methode die Main Ausführung nicht vor den drei Threads beendet.

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

Das folgende Beispiel ähnelt dem vorherigen, mit dem Unterschied, dass es die Task -Klasse anstelle einer Threadprozedur verwendet, um 50.000 zufällige ganzzahlige Mittelpunkte zu generieren. In diesem Beispiel ersetzt ein Lambdaausdruck die GenerateNumbers Threadprozedur, und der Aufruf der Task.WaitAll -Methode beseitigt die Notwendigkeit des CountdownEvent Objekts.

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

Hinweise

Diese Methode behandelt eine Überlaufbedingung durch Umbruch: if location = Int32.MaxValue, location + 1 = Int32.MinValue. Es wird keine Ausnahme ausgelöst.

Weitere Informationen

• Verwaltetes Threading
• Übersicht über Synchronisierungsprimitiven

Increment(Int64)

Quelle:

Interlocked.CoreCLR.cs

Inkrementiert den Wert einer angegebenen Variablen und speichert das Ergebnis in einer atomaren 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

Parameter

location

Int64

Die Variable, deren Wert inkrementiert werden soll.

Gibt zurück

Int64

Der Wert der Variablen unmittelbar nach Abschluss des Inkrementvorgangs.

Ausnahmen

NullReferenceException

Die Adresse von location ist ein null-Zeiger.

Hinweise

Diese Methode behandelt eine Überlaufbedingung durch Umbruch: if location = Int64.MaxValue, location + 1 = Int64.MinValue. Es wird keine Ausnahme ausgelöst.

Weitere Informationen

• Decrement
• Add
• Read(Int64)
• Verwaltetes Threading
• Übersicht über Synchronisierungsprimitiven