Interlocked.Decrement Method

Reference

Definition

Namespace:: System.Threading

Assemblies:: mscorlib.dll, System.Threading.dll

Assemblies:: netstandard.dll, System.Threading.dll

Assembly:: System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Decrements a specified variable and stores the result, as an atomic operation.

Overloads

Decrement(Int64)	Decrements the specified variable and stores the result, as an atomic operation.
Decrement(Int32)	Decrements a specified variable and stores the result, as an atomic operation.
Decrement(UInt32)	Decrements a specified variable and stores the result, as an atomic operation.
Decrement(UInt64)	Decrements a specified variable and stores the result, as an atomic operation.

Decrement(Int64)

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Decrements the specified variable and stores the result, as an atomic operation.

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

Parameters

___location: Int64

The variable whose value is to be decremented.

Returns

Int64

The value of the variable immediately after the decrement operation finished.

Exceptions

ArgumentNullException

The address of ___location is a null pointer.

NullReferenceException

The address of ___location is a null pointer.

Remarks

This method handles an overflow condition by wrapping: if ___location = Int64.MinValue, ___location - 1 = Int64.MaxValue. No exception is thrown.

Applies to

Decrement(Int32)

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Source:: Interlocked.CoreCLR.cs

Decrements a specified variable and stores the result, as an atomic operation.

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

Parameters

___location: Int32

The variable whose value is to be decremented.

Returns

Int32

The value of the variable immediately after the decrement operation finished.

Exceptions

ArgumentNullException

The address of ___location is a null pointer.

NullReferenceException

The address of ___location is a null pointer.

Examples

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. To keep track of the number of midpoint values, a variable, midpointCount, is set equal to 1,000 and decremented each time the random number generator returns a midpoint value. Because three threads generate the random numbers, the Decrement(Int32) method is called to ensure that multiple threads don't update midpointCount concurrently. 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 = 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

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

Remarks

This method handles an overflow condition by wrapping: If ___location = Int32.MinValue, ___location - 1 = Int32.MaxValue. No exception is thrown.

Applies to

Decrement(UInt32)

Source:: Interlocked.cs

Source:: Interlocked.cs

Source:: Interlocked.cs

Important

This API is not CLS-compliant.

Decrements a specified variable and stores the result, as an atomic operation.

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

Parameters

___location: UInt32

The variable whose value is to be decremented.

Returns

UInt32

The value of the variable immediately after the decrement operation finished.

Attributes: CLSCompliantAttribute

Exceptions

NullReferenceException

The address of ___location is a null pointer.

Applies to

Decrement(UInt64)

Source:: Interlocked.cs

Source:: Interlocked.cs

Source:: Interlocked.cs

Important

This API is not CLS-compliant.

Decrements a specified variable and stores the result, as an atomic operation.

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

Parameters

___location: UInt64

The variable whose value is to be decremented.

Returns

UInt64

The value of the variable immediately after the decrement operation finished.

Attributes: CLSCompliantAttribute

Exceptions

NullReferenceException

The address of ___location is a null pointer.

Applies to

Share via

Interlocked.Decrement Method

Definition

Overloads

Decrement(Int64)

Parameters

Returns

Exceptions

Remarks

See also

Applies to

Decrement(Int32)

Parameters

Returns

Exceptions

Examples

Remarks

See also

Applies to

Decrement(UInt32)

Parameters

Returns

Exceptions

Applies to

Decrement(UInt64)

Parameters

Returns

Exceptions

Applies to