Interlocked.Increment Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique.
Surcharges
| Increment(UInt64) |
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. |
| Increment(UInt32) |
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. |
| Increment(Int32) |
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. |
| Increment(Int64) |
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique. |
Increment(UInt64)
- Source:
- Interlocked.cs
- Source:
- Interlocked.cs
- Source:
- Interlocked.cs
Important
Cette API n’est pas conforme CLS.
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique.
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 -> uint64Public Shared Function Increment (ByRef location As ULong) As ULongParamètres
- location
- UInt64
Variable dont la valeur doit être incrémentée.
Retours
Valeur de la variable immédiatement après la fin de l’opération d’incrémentation.
- Attributs
Exceptions
L’adresse de location est un pointeur null.
S’applique à
Increment(UInt32)
- Source:
- Interlocked.cs
- Source:
- Interlocked.cs
- Source:
- Interlocked.cs
Important
Cette API n’est pas conforme CLS.
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique.
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 -> uint32Public Shared Function Increment (ByRef location As UInteger) As UIntegerParamètres
- location
- UInt32
Variable dont la valeur doit être incrémentée.
Retours
Valeur de la variable immédiatement après la fin de l’opération d’incrémentation.
- Attributs
Exceptions
L’adresse de location est un pointeur null.
S’applique à
Increment(Int32)
- Source:
- Interlocked.CoreCLR.cs
- Source:
- Interlocked.CoreCLR.cs
- Source:
- Interlocked.CoreCLR.cs
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique.
public:
static int Increment(int % location);public static int Increment (ref int location);static member Increment : int -> intPublic Shared Function Increment (ByRef location As Integer) As IntegerParamètres
- location
- Int32
Variable dont la valeur doit être incrémentée.
Retours
Valeur de la variable immédiatement après la fin de l’opération d’incrémentation.
Exceptions
L’adresse de location est un pointeur null.
Exemples
L’exemple suivant détermine le nombre de nombres aléatoires compris entre 0 et 1 000 pour générer 1 000 nombres aléatoires avec une valeur de point intermédiaire. Pour suivre le nombre de valeurs médianes, une variable, midpointCount, est définie sur 0 et incrémentée chaque fois que le générateur de nombres aléatoires retourne une valeur de point intermédiaire jusqu’à ce qu’elle atteigne 10 000. Étant donné que trois threads génèrent les nombres aléatoires, la Increment(Int32) méthode est appelée pour garantir que plusieurs threads ne se mettent pas à jour midpointCount simultanément. Notez qu’un verrou est également utilisé pour protéger le générateur de nombres aléatoires et qu’un CountdownEvent objet est utilisé pour garantir que la méthode ne termine pas l’exécution Main avant les trois 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 = 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
L’exemple suivant est similaire au précédent, sauf qu’il utilise la Task classe au lieu d’une procédure thread pour générer 50 000 entiers de point moyen aléatoires. Dans cet exemple, une expression lambda remplace la GenerateNumbers procédure thread, et l’appel à la Task.WaitAll méthode élimine la nécessité de l’objet 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
Remarques
Cette méthode gère une condition de dépassement de capacité en encapsulant : si location = Int32.MaxValue, location + 1 = . Int32.MinValue Aucune exception n’est générée.
Voir aussi
S’applique à
Increment(Int64)
- Source:
- Interlocked.CoreCLR.cs
- Source:
- Interlocked.CoreCLR.cs
- Source:
- Interlocked.CoreCLR.cs
Incrémente une variable spécifiée et stocke le résultat sous la forme d'une opération atomique.
public:
static long Increment(long % location);public static long Increment (ref long location);static member Increment : int64 -> int64Public Shared Function Increment (ByRef location As Long) As LongParamètres
- location
- Int64
Variable dont la valeur doit être incrémentée.
Retours
Valeur de la variable immédiatement après la fin de l’opération d’incrémentation.
Exceptions
L’adresse de location est un pointeur null.
Remarques
Cette méthode gère une condition de dépassement de capacité en encapsulant : si location = Int64.MaxValue, location + 1 = . Int64.MinValue Aucune exception n’est générée.
Voir aussi
S’applique à
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour