Condividi tramite


Interlocked.Decrement Metodo

Definizione

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

Overload

Decrement(Int64)

Consente di diminuire la variabile specificata e di memorizzare il risultato, come operazione atomica.

Decrement(Int32)

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

Decrement(UInt32)

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

Decrement(UInt64)

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

Decrement(Int64)

Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs

Consente di diminuire la variabile specificata e di memorizzare il risultato, come operazione atomica.

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

Parametri

location
Int64

Variabile il cui valore deve essere diminuito.

Restituisce

Valore della variabile immediatamente dopo il completamento dell'operazione di decremento.

Eccezioni

L'indirizzo di location è un puntatore null.

L'indirizzo di location è un puntatore null.

Commenti

Questo metodo gestisce una condizione di overflow eseguendo il wrapping: se location = Int64.MinValue, location - 1 = . Int64.MaxValue Non viene generata alcuna eccezione.

Vedi anche

Si applica a

Decrement(Int32)

Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs
Origine:
Interlocked.CoreCLR.cs

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

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

Parametri

location
Int32

Variabile il cui valore deve essere diminuito.

Restituisce

Valore della variabile immediatamente dopo il completamento dell'operazione di decremento.

Eccezioni

L'indirizzo di location è un puntatore null.

L'indirizzo di location è un puntatore null.

Esempio

L'esempio seguente determina il numero di numeri casuali compresi tra 0 e 1.000 per generare 1.000 numeri casuali con un valore di punto medio. Per tenere traccia del numero di valori di punto intermedio, una variabile, midpointCount, è impostata su 1.000 e decrementata ogni volta che il generatore di numeri casuali restituisce un valore di punto intermedio. Poiché tre thread generano i numeri casuali, il Decrement(Int32) metodo viene chiamato per garantire che più thread non vengano aggiornati midpointCount contemporaneamente. Si noti che viene usato anche un blocco per proteggere il generatore di numeri casuali e che viene usato un CountdownEvent oggetto per assicurarsi che il Main metodo non finisca l'esecuzione prima dei tre thread.

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

L'esempio seguente è simile a quello precedente, ad eccezione del fatto che usa la Task classe anziché una routine thread per generare 50.000 interi casuali a metà punto. In questo esempio, un'espressione lambda sostituisce la GenerateNumbers routine thread e la chiamata al Task.WaitAll metodo elimina la necessità dell'oggetto CountdownEvent .

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

Commenti

Questo metodo gestisce una condizione di overflow eseguendo il wrapping: se location = Int32.MinValue, location - 1 = . Int32.MaxValue Non viene generata alcuna eccezione.

Vedi anche

Si applica a

Decrement(UInt32)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Importante

Questa API non è conforme a CLS.

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

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

Parametri

location
UInt32

Variabile il cui valore deve essere diminuito.

Restituisce

Valore della variabile immediatamente dopo il completamento dell'operazione di decremento.

Attributi

Eccezioni

L'indirizzo di location è un puntatore null.

Si applica a

Decrement(UInt64)

Origine:
Interlocked.cs
Origine:
Interlocked.cs
Origine:
Interlocked.cs

Importante

Questa API non è conforme a CLS.

Consente di diminuire una variabile specificata e di memorizzarne il risultato, come operazione atomica.

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

Parametri

location
UInt64

Variabile il cui valore deve essere diminuito.

Restituisce

Valore della variabile immediatamente dopo il completamento dell'operazione di decremento.

Attributi

Eccezioni

L'indirizzo di location è un puntatore null.

Si applica a