_InterlockedDecrement systeminterne Funktionen

[Diese Dokumentation ist nur eine Vorschau und wird in späteren Versionen ggf. geändert. Blank topics are included as placeholders.]

Microsoft-spezifisch

Stellt die Unterstützung für systeminterne Funktion von Win32 Windows SDK InterlockedDecrement .

long _InterlockedDecrement(
   long * lpAddend
);
long _InterlockedDecrement_acq(
   long * lpAddend
);
long _InterlockedDecrement_acq(
   long * lpAddend
);
short _InterlockedDecrement16(
   short * lpAddend
);
short _InterlockedDecrement16_acq(
   short * lpAddend
);
short _InterlockedDecrement16_rel(
   short * lpAddend
);
__int64 _InterlockedDecrement64(
   __int64 * lpAddend
);
__int64 _InterlockedDecrement64_acq(
   __int64 * lpAddend
);
__int64 _InterlockedDecrement64_rel(
   __int64 * lpAddend
);

Parameter

• [in, out] lpAddend
  Zeiger auf die Variable dekrementiert werden soll.

Rückgabewert

Windows 98, Windows NT 4.0 und höher: Der Rückgabewert ist der resultierende dekrementierte Wert.

Windows 95, Windows NT 3.51 und früher: Wenn das Ergebnis der Operation (null) ist, ist der Rückgabewert (null). Wenn das Ergebnis des Vorgangs kleiner als null ist, ist der Rückgabewert ist negativ, aber nicht notwendigerweise mit dem Ergebnis. Wenn das Ergebnis des Vorgangs größer als null ist, ist der Rückgabewert positiv, ist jedoch nicht unbedingt mit dem Ergebnis.

Anforderungen

Headerdatei <intrin.h>

Hinweise

Es gibt mehrere Varianten _InterlockedDecrement , die auf Grundlage der Datentypen unterscheiden, die sie enthalten, und ob prozessorspezifisch abrufen, um Ihnen oder Semantik verwendet wird.

Während die _InterlockedDecrement-Funktion an 32-Bit-Ganzzahlwerte auswirkt, können _InterlockedDecrement16 an 16-Bit-Ganzzahlwerte ausgeführt werden und _InterlockedDecrement64 können an 64-Bit-Ganzzahlwerte ausgeführt werden.

_InterlockedDecrement_acq, _InterlockedDecrement16_acq und _InterlockedDecrement64_acq systeminterne Funktionen sind identisch, mit denen die entsprechenden Aufgaben ohne das Suffix _acq Ausnahme, dass der Vorgang mit abrufen Semantik wahrgenommen wird, ist nützlich, wenn Sie einen kritischen Abschnitt eintritt.

_InterlockedDecrement_rel, _InterlockedDecrement16_rel und _InterlockedDecrement64_rel systeminterne Funktion entsprechen denen, die die entsprechenden Funktionen ohne das Suffix _rel Ausnahme, dass der Vorgang mit Semantik Version ausgeführt wird, die beim Suchen eines kritischen Bereich verlässt.

Die Variable, die von dem lpAddend-Parameter dargestellt wird, muss auf eine 32-Bit-Grenze ausgerichtet sein. Andernfalls schlägt diese Funktion auf allen Systemen mit mehreren Prozessoren x86-Systemen und als x86 aus.

Diese Funktionen verhalten sich als Schreib-Lesespeicher-Barrieren. Weitere Informationen finden Sie unter _ReadWriteBarrier.

Diese Routinen sind als systeminterne Funktionen nur verfügbar.

Beispiel

// compiler_intrinsics_interlocked.cpp
// compile with: /Oi
#define _CRT_RAND_S

#include <cstdlib>
#include <cstdio>
#include <process.h>
#include <windows.h>

// To declare an interlocked function for use as an intrinsic,
// include intrin.h and put the function in a #pragma intrinsic 
// statement.
#include <intrin.h>

#pragma intrinsic (_InterlockedIncrement)

// Data to protect with the interlocked functions.
volatile LONG data = 1;

void __cdecl SimpleThread(void* pParam);

const int THREAD_COUNT = 6;

int main() {
   DWORD num;
   HANDLE threads[THREAD_COUNT];
   int args[THREAD_COUNT];
   int i;

   for (i = 0; i < THREAD_COUNT; i++) {
     args[i] = i + 1;
     threads[i] = reinterpret_cast<HANDLE>(_beginthread(SimpleThread, 0, 
                           args + i));
      if (threads[i] == reinterpret_cast<HANDLE>(-1))
         // error creating threads
         break;
   }

   WaitForMultipleObjects(i, threads, true, INFINITE);
}

// Code for our simple thread
void __cdecl SimpleThread(void* pParam) {
   int threadNum = *((int*)pParam);
   int counter;
   unsigned int randomValue;
   unsigned int time;
   errno_t err = rand_s(&randomValue);

   if (err == 0) {
      time = (unsigned int) ((double) randomValue / (double) UINT_MAX * 500);
      while (data < 100) {
         if (data < 100) {
            _InterlockedIncrement(&data);
            printf_s("Thread %d: %d\n", threadNum, data);
         }

         Sleep(time);   // wait up to half of a second
      }
   }

   printf_s("Thread %d complete: %d\n", threadNum, data);
}

Siehe auch

Referenz

Systeminterne Funktionen des Compilers

C++-Schlüsselwörter

Weitere Ressourcen

Conflicts with the x86 Compiler