`_InterlockedCompareExchange` встроенные функции

Статья
08/04/2024

Блок, относящийся только к системам Майкрософт

Выполняет переблокированное сравнение и обмен данными.

Синтаксис

long _InterlockedCompareExchange(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_acq(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_HLEAcquire(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_HLERelease(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_nf(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_np(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
long _InterlockedCompareExchange_rel(
   long volatile * Destination,
   long Exchange,
   long Comparand
);
char _InterlockedCompareExchange8(
   char volatile * Destination,
   char Exchange,
   char Comparand
);
char _InterlockedCompareExchange8_acq(
   char volatile * Destination,
   char Exchange,
   char Comparand
);
char _InterlockedCompareExchange8_nf(
   char volatile * Destination,
   char Exchange,
   char Comparand
);
char _InterlockedCompareExchange8_rel(
   char volatile * Destination,
   char Exchange,
   char Comparand
);
short _InterlockedCompareExchange16(
   short volatile * Destination,
   short Exchange,
   short Comparand
);
short _InterlockedCompareExchange16_acq(
   short volatile * Destination,
   short Exchange,
   short Comparand
);
short _InterlockedCompareExchange16_nf(
   short volatile * Destination,
   short Exchange,
   short Comparand
);
short _InterlockedCompareExchange16_np(
   short volatile * Destination,
   short Exchange,
   short Comparand
);
short _InterlockedCompareExchange16_rel(
   short volatile * Destination,
   short Exchange,
   short Comparand
);
__int64 _InterlockedCompareExchange64(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_acq(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_HLEAcquire (
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_HLERelease(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_nf(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_np(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);
__int64 _InterlockedCompareExchange64_rel(
   __int64 volatile * Destination,
   __int64 Exchange,
   __int64 Comparand
);

Параметры

Destination
[in, out] Указатель на целевое значение. Знак игнорируется

Exchange
[in] Значение Exchange. Знак игнорируется

Comparand
[in] Значение для сравнения со значением, Destinationна которое указывает значение. Знак игнорируется

Возвращаемое значение

Возвращаемое значение — это начальное значение, указываемое Destination указателем.

Требования

Intrinsic	Архитектура	Верхний колонтитул
`_InterlockedCompareExchange`, , `_InterlockedCompareExchange8_InterlockedCompareExchange16_InterlockedCompareExchange64`	x86, ARM, x64, ARM64	<intrin.h>
`_InterlockedCompareExchange_acq`, `_InterlockedCompareExchange_nf`, `_InterlockedCompareExchange_rel_InterlockedCompareExchange8_acq_InterlockedCompareExchange8_nf_InterlockedCompareExchange8_rel_InterlockedCompareExchange16_acq_InterlockedCompareExchange16_nf_InterlockedCompareExchange16_rel_InterlockedCompareExchange64_acq_InterlockedCompareExchange64_nf_InterlockedCompareExchange64_rel`	ARM, ARM64	<intrin.h>
`_InterlockedCompareExchange_np`, , `_InterlockedCompareExchange16_np_InterlockedCompareExchange64_np`	x64	<intrin.h>
`_InterlockedCompareExchange_HLEAcquire`, , `_InterlockedCompareExchange_HLERelease_InterlockedCompareExchange64_HLEAcquire_InterlockedCompareExchange64_HLERelease`	x86, x64	<immintrin.h>

Замечания

_InterlockedCompareExchange выполняет атомарное сравнение значения, Destination Comparand на которое указывает значение. Если значение Destination равно значению Comparand, значение Exchange сохранится по адресу, указанному Destination. В противном случае операция не выполняется.

_InterlockedCompareExchange предоставляет встроенную поддержку компилятора для функции Пакета SDK InterlockedCompareExchange для Windows Win32.

Существует несколько вариантов _InterlockedCompareExchange , которые зависят от типов данных, которые они включают и используются ли семантики получения или выпуска процессора.

_InterlockedCompareExchange Хотя функция работает с 32-разрядными целыми значениями, _InterlockedCompareExchange8 работает с 8-разрядными long целыми значениями, _InterlockedCompareExchange16 работает с 16-разрядными short целыми значениями и _InterlockedCompareExchange64 работает с 64-разрядными целыми значениями. Дополнительные сведения о аналогичных встроенных функциях для 128-разрядных значений см. в разделе _InterlockedCompareExchange128.

На всех платформах ARM используйте встроенные элементы с суффиксами _acq _rel для получения и выпуска семантики, например в начале и конце критического раздела. Встроенные компоненты ARM с суффиксом _nf (без ограждения) не действуют в качестве барьера памяти.

Встроенные функции с суффиксом _np («нет упреждающей выборки") запрещают возможную вставку компилятором операции упреждающей выборки.

На платформах Intel ®, поддерживающих инструкции Hardware Lock Elision (HLE), встроенные функции с суффиксами _HLEAcquire и _HLERelease включают подсказку процессору, как можно повысить производительность, устраняя шаг записи с блокировкой оборудования. Если эти встроенные компоненты вызываются на платформах, которые не поддерживают HLE, это указание игнорируется.

Эти процедуры доступны только как встроенные объекты.

Пример

В следующем примере _InterlockedCompareExchange используется для простой синхронизации потоков нижнего уровня. Подход имеет свои ограничения в качестве основы для многопоточного программирования; Он представлен для иллюстрации типичного использования интерблокируемых встроенных функций. Для получения наилучших результатов используйте Windows API. Дополнительные сведения о многопоточных программированиях см. в статье "Написание многопоточной программы Win32".

// intrinExample.cpp
// compile with: /EHsc /O2
// Simple example of using _Interlocked* intrinsics to
// do manual synchronization
//
// Add [-DSKIP_LOCKING] to the command line to disable
// the locking. This will cause the threads to execute out
// of sequence.

#define _CRT_RAND_S

#include "windows.h"

#include <iostream>
#include <queue>
#include <intrin.h>

using namespace std;

// --------------------------------------------------------------------

// if defined, will not do any locking on shared data
//#define SKIP_LOCKING

// A common way of locking using _InterlockedCompareExchange.
// Refer to other sources for a discussion of the many issues
// involved. For example, this particular locking scheme performs well
// when lock contention is low, as the while loop overhead is small and
// locks are acquired very quickly, but degrades as many callers want
// the lock and most threads are doing a lot of interlocked spinning.
// There are also no guarantees that a caller will ever acquire the
// lock.
namespace MyInterlockedIntrinsicLock
{
    typedef unsigned LOCK, *PLOCK;

#pragma intrinsic(_InterlockedCompareExchange, _InterlockedExchange)

    enum {LOCK_IS_FREE = 0, LOCK_IS_TAKEN = 1};

    void Lock(PLOCK pl)
    {
#if !defined(SKIP_LOCKING)
        // If *pl == LOCK_IS_FREE, it is set to LOCK_IS_TAKEN
        // atomically, so only 1 caller gets the lock.
        // If *pl == LOCK_IS_TAKEN,
        // the result is LOCK_IS_TAKEN, and the while loop keeps spinning.
        while (_InterlockedCompareExchange((long *)pl,
                                           LOCK_IS_TAKEN, // exchange
                                           LOCK_IS_FREE)  // comparand
               == LOCK_IS_TAKEN)
        {
            // spin!
        }
        // This will also work.
        //while (_InterlockedExchange(pl, LOCK_IS_TAKEN) ==
        //                             LOCK_IS_TAKEN)
        //{
        //    // spin!
        //}

        // At this point, the lock is acquired.
#endif
    }

    void Unlock(PLOCK pl) {
#if !defined(SKIP_LOCKING)
        _InterlockedExchange((long *)pl, LOCK_IS_FREE);
#endif
    }
}

// ------------------------------------------------------------------
// Data shared by threads

queue<int> SharedQueue;
MyInterlockedIntrinsicLock::LOCK SharedLock;
int TicketNumber;

// ------------------------------------------------------------------

DWORD WINAPI
ProducerThread(
    LPVOID unused
    )
{
    unsigned int randValue;
    while (1) {
        // Acquire shared data. Enter critical section.
        MyInterlockedIntrinsicLock::Lock(&SharedLock);

        //cout << ">" << TicketNumber << endl;
        SharedQueue.push(TicketNumber++);

        // Release shared data. Leave critical section.
        MyInterlockedIntrinsicLock::Unlock(&SharedLock);

        rand_s(&randValue);
        Sleep(randValue % 20);
    }

    return 0;
}

DWORD WINAPI
ConsumerThread(
    LPVOID unused
    )
{
    while (1) {
        // Acquire shared data. Enter critical section
        MyInterlockedIntrinsicLock::Lock(&SharedLock);

        if (!SharedQueue.empty()) {
            int x = SharedQueue.front();
            cout << "<" << x << endl;
            SharedQueue.pop();
        }

        // Release shared data. Leave critical section
        MyInterlockedIntrinsicLock::Unlock(&SharedLock);

        unsigned int randValue;
        rand_s(&randValue);
        Sleep(randValue % 20);
    }
    return 0;
}

int main(
    void
    )
{
    const int timeoutTime = 500;
    int unused1, unused2;
    HANDLE threads[4];

    // The program creates 4 threads:
    // two producer threads adding to the queue
    // and two consumers taking data out and printing it.
    threads[0] = CreateThread(NULL,
                              0,
                              ProducerThread,
                              &unused1,
                              0,
                              (LPDWORD)&unused2);

    threads[1] = CreateThread(NULL,
                              0,
                              ConsumerThread,
                              &unused1,
                              0,
                              (LPDWORD)&unused2);

    threads[2] = CreateThread(NULL,
                              0,
                              ProducerThread,
                              &unused1,
                              0,
                              (LPDWORD)&unused2);

    threads[3] = CreateThread(NULL,
                              0,
                              ConsumerThread,
                              &unused1,
                              0,
                              (LPDWORD)&unused2);

    WaitForMultipleObjects(4, threads, TRUE, timeoutTime);

    return 0;
}

<0
<1
<2
<3
<4
<5
<6
<7
<8
<9
<10
<11
<12
<13
<14
<15
<16
<17
<18
<19
<20
<21
<22
<23
<24
<25
<26
<27
<28
<29

Завершение блока, относящегося только к системам Майкрософт

См. также

_InterlockedCompareExchange128
_InterlockedCompareExchangePointer встроенные функции
Встроенные компоненты компилятора
Ключевые слова
Конфликты с 32-разрядным (x86) компилятором

Поделиться через

`_InterlockedCompareExchange` встроенные функции

Синтаксис

Параметры

Возвращаемое значение

Требования

Замечания

Пример

См. также

Обратная связь

Дополнительные ресурсы

Поделиться через

_InterlockedCompareExchange встроенные функции

Синтаксис

Параметры

Возвращаемое значение

Требования

Замечания

Пример

См. также

Обратная связь

Дополнительные ресурсы

`_InterlockedCompareExchange` встроенные функции