Interlocked.Increment 方法

參考

定義

命名空間:: System.Threading

組件:: System.Threading.dll

組件:: mscorlib.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

多載

Increment(UInt64)	遞增特定變數並將結果儲存起來，成為不可部分完成的作業。
Increment(UInt32)	遞增特定變數並將結果儲存起來，成為不可部分完成的作業。
Increment(Int32)	遞增特定變數並將結果儲存起來，成為不可部分完成的作業。
Increment(Int64)	遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

Increment(UInt64)

來源:: Interlocked.cs

來源:: Interlocked.cs

來源:: Interlocked.cs

重要

此 API 不符合 CLS 規範。

遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

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

參數

location: UInt64

值會被遞增的變數。

傳回

UInt64

在遞增作業完成之後，變數的值。

屬性: CLSCompliantAttribute

例外狀況

NullReferenceException

location 的位址為 null 指標。

適用於

Increment(UInt32)

來源:: Interlocked.cs

來源:: Interlocked.cs

來源:: Interlocked.cs

重要

此 API 不符合 CLS 規範。

遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

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

參數

location: UInt32

值會被遞增的變數。

傳回

UInt32

在遞增作業完成之後，變數的值。

屬性: CLSCompliantAttribute

例外狀況

NullReferenceException

location 的位址為 null 指標。

適用於

Increment(Int32)

來源:: Interlocked.CoreCLR.cs

來源:: Interlocked.CoreCLR.cs

來源:: Interlocked.CoreCLR.cs

遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

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

參數

location: Int32

值會被遞增的變數。

傳回

Int32

在遞增作業完成之後，變數的值。

例外狀況

NullReferenceException

location 的位址為 null 指標。

範例

下列範例會決定從 0 到 1,000 的亂數數目，才能產生 1,000 個具有中間點值的亂數。若要追蹤中間點值的數目，變數 midpointCount 會設定為等於 0，並在每次亂數產生器傳回中間點值時遞增，直到達到 10,000 為止。由於三個執行緒會產生亂數，因此 Increment(Int32) 會呼叫方法來確保多個執行緒不會同時更新 midpointCount 。請注意，鎖定也用來保護亂數產生器，而且物件用來確保 Main 方法不會在三個 CountdownEvent 執行緒之前完成執行。

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

下列範例與上一個範例類似，不同之處在于它會使用 Task 類別而非執行緒程式來產生 50,000 個隨機中間點整數。在此範例中，Lambda 運算式會 GenerateNumbers 取代執行緒程式，而對方法的呼叫 Task.WaitAll 會消除物件的需求 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 = 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

備註

這個方法會包裝處理溢位條件：如果 location = Int32.MaxValue 為，則為 + location 1 = 。 Int32.MinValue 不會擲回任何例外狀況。

另請參閱

適用於

Increment(Int64)

來源:: Interlocked.CoreCLR.cs

來源:: Interlocked.CoreCLR.cs

來源:: Interlocked.CoreCLR.cs

遞增特定變數並將結果儲存起來，成為不可部分完成的作業。

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

參數

location: Int64

值會被遞增的變數。

傳回

Int64

在遞增作業完成之後，變數的值。

例外狀況

NullReferenceException

location 的位址為 null 指標。

備註

這個方法會包裝處理溢位條件：如果 location = Int64.MaxValue 為，則為 + location 1 = 。 Int64.MinValue 不會擲回任何例外狀況。

另請參閱

適用於

共用方式為

Interlocked.Increment 方法

定義

多載

Increment(UInt64)

參數

傳回

例外狀況

適用於

Increment(UInt32)

參數

傳回

例外狀況

適用於

Increment(Int32)

參數

傳回

例外狀況

範例

備註

另請參閱

適用於

Increment(Int64)

參數

傳回

例外狀況

備註

另請參閱

適用於

其他資源