Interlocked.Decrement Metódus

Definíció

Névtér:: System.Threading

Szerelvények:: mscorlib.dll, System.Threading.dll

Szerelvények:: netstandard.dll, System.Threading.dll

Szerelvény:: System.Threading.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.

Túlterhelések

Name	Description
Decrement(Int64)	A megadott változót dekreálja, és az eredményt atomi műveletként tárolja.
Decrement(Int32)	Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.
Decrement(UInt32)	Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.
Decrement(UInt64)	Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.

Decrement(Int64)

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

A megadott változót dekreálja, és az eredményt atomi műveletként tárolja.

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

Paraméterek

location: Int64

Az a változó, amelynek értékét meg kell decrementálni.

Válaszok

Int64

A változó értéke közvetlenül a decrement művelet befejezése után.

Kivételek

ArgumentNullException

A cím location egy null mutató.

NullReferenceException

A cím location egy null mutató.

Megjegyzések

Ez a metódus a túlcsordulási feltételt a következő körbefuttatással kezeli: ha location = Int64.MinValue, location - 1 = . Int64.MaxValue Nincs kivétel.

Lásd még

A következőre érvényes:

Decrement(Int32)

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Forrás:: Interlocked.CoreCLR.cs

Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.

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

Paraméterek

location: Int32

Az a változó, amelynek értékét meg kell decrementálni.

Válaszok

Int32

A változó értéke közvetlenül a decrement művelet befejezése után.

Kivételek

ArgumentNullException

A cím location egy null mutató.

NullReferenceException

A cím location egy null mutató.

Példák

Az alábbi példa azt határozza meg, hogy hány 0 és 1000 közötti véletlenszerű szám szükséges 1000 véletlenszerű szám létrehozásához egy középponti értékkel. A középpontértékek számának nyomon követéséhez a változó értéke 1000 lesz, midpointCountés minden alkalommal csökken, amikor a véletlenszerű számgenerátor egy középpontértéket ad vissza. Mivel három szál hozza létre a véletlenszerű számokat, a Decrement(Int32) metódus meghívásával biztosítható, hogy több szál ne frissüljön midpointCount egyszerre. Vegye figyelembe, hogy a zárolás a véletlenszerű számgenerátor védelmére is szolgál, és CountdownEvent egy objektumot használ annak biztosítására, hogy a Main metódus ne fejezze be a végrehajtást a három szál előtt.

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

Az alábbi példa az előzőhöz hasonló, azzal a kivételrel, hogy szálas eljárás helyett az Task osztályt használja 50 000 véletlenszerű középpont egész szám létrehozásához. Ebben a példában egy lambda kifejezés helyettesíti a GenerateNumbers szál eljárást, és a Task.WaitAll metódus meghívása megszünteti az CountdownEvent objektum szükségességét.

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

Megjegyzések

Ez a metódus a túlcsordulási feltételt a következő körbefuttatással kezeli: If location = Int32.MinValue, location - 1 = . Int32.MaxValue Nincs kivétel.

Lásd még

A következőre érvényes:

Decrement(UInt32)

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Fontos

Ez az API nem CLS-kompatibilis.

Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.

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

Paraméterek

location: UInt32

Az a változó, amelynek értékét meg kell decrementálni.

Válaszok

UInt32

A változó értéke közvetlenül a decrement művelet befejezése után.

Attribútumok: CLSCompliantAttribute

Kivételek

NullReferenceException

A cím location egy null mutató.

A következőre érvényes:

Decrement(UInt64)

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Forrás:: Interlocked.cs

Fontos

Ez az API nem CLS-kompatibilis.

Egy megadott változót dekreál, és az eredményt atomi műveletként tárolja.

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

Paraméterek

location: UInt64

Az a változó, amelynek értékét meg kell decrementálni.

Válaszok

UInt64

A változó értéke közvetlenül a decrement művelet befejezése után.

Attribútumok: CLSCompliantAttribute

Kivételek

NullReferenceException

A cím location egy null mutató.

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?