1

在 WinAPI 下有 WaitForSingleObject() 和 ReleaseMutex() 函数对。还有 Interlocked*() 函数系列。我决定检查捕获单个互斥锁和交换互锁变量之间的性能。

HANDLE mutex;
WaitForSingleObject(mutex, INFINITE);
// ..
ReleaseMutex(mutex);

// 0 unlocked, 1 locked
LONG lock = 0;
while(InterlockedCompareExchange(&lock, 1, 0))
  SwitchToThread();
// ..
InterlockedExchange(&lock, 0);
SwitchToThread();

我测量了这两种方法之间的性能，发现使用 Interlocked*() 大约快 38%。为什么会这样？

这是我的性能测试：

#include <windows.h>
#include <iostream>
#include <conio.h>
using namespace std;

LONG interlocked_variable   = 0; // 0 unlocked, 1 locked
int run                     = 1;

DWORD WINAPI thread(LPVOID lpParam)
{
    while(run)
    {
        while(InterlockedCompareExchange(&interlocked_variable, 1, 0))
            SwitchToThread();
        ++(*((unsigned int*)lpParam));
        InterlockedExchange(&interlocked_variable, 0);
        SwitchToThread();
    }

    return 0;
}

int main()
{
    unsigned int num_threads;
    cout << "number of threads: ";
    cin >> num_threads;
    unsigned int* num_cycles = new unsigned int[num_threads];
    DWORD s_time, e_time;

    s_time = GetTickCount();
    for(unsigned int i = 0; i < num_threads; ++i)
    {
        num_cycles[i] = 0;
        HANDLE handle = CreateThread(NULL, NULL, thread, &num_cycles[i], NULL, NULL);
        CloseHandle(handle);
    }
    _getch();
    run = 0;
    e_time = GetTickCount();

    unsigned long long total = 0;
    for(unsigned int i = 0; i < num_threads; ++i)
        total += num_cycles[i];
    for(unsigned int i = 0; i < num_threads; ++i)
        cout << "\nthread " << i << ":\t" << num_cycles[i] << " cyc\t" << ((double)num_cycles[i] / (double)total) * 100 << "%";
    cout << "\n----------------\n"
        << "cycles total:\t" << total
        << "\ntime elapsed:\t" << e_time - s_time << " ms"
        << "\n----------------"
        << '\n' << (double)(e_time - s_time) / (double)(total) << " ms\\op\n";

    delete[] num_cycles;
    _getch();
    return 0;
}
4

2 回答 2

4

WaitForSingleObject不必更快。它涵盖了更广泛的同步场景，特别是您可以等待不“属于”您的进程的句柄，从而实现进程间同步。考虑到所有这些，根据您的测试，它只慢了 38%。

如果您的流程中包含所有内容并且每一纳秒都很重要，InterlockedXxx那么这可能是一个更好的选择，但它绝对不是绝对优越的选择。

此外，您可能想查看Slim Reader/Writer (SRW) Locks API。您也许可以完全基于InterlockedXxx稍微更好的性能构建一个类似的类/函数，但是关键是，使用 SRW，您可以立即使用它，具有记录的行为，稳定且无论如何都具有不错的性能。

于 2013-12-13T10:42:40.787 回答
3

您没有比较等效的锁，因此性能如此不同也就不足为奇了。

互斥锁允许跨进程锁定，由于它提供的灵活性，它可能是最昂贵的锁定方法之一。当您阻塞锁时，它通常会使您的线程进入睡眠状态，并且在您醒来获得锁之前不使用 CPU。这允许其他代码使用 cpu。

您的 InterlockedCompareExchange() 代码是一个简单的自旋锁。您将烧毁 CPU 等待您的锁定。

您可能还想研究关键部分（比互斥锁更少的开销）和Slim 读取器/写入器锁（如果您始终获得独占锁，则可用于互斥，并且它提供的性能比非竞争的关键部分快一点根据我的测试使用）。

您可能还想在此处和此处阅读 Kenny Kerr 的“Windows 和 C++ 中同步的演变”和 Preshing 的与锁相关的内容。

于 2013-12-13T10:48:39.590 回答