InterlockedIncrement 用處 和用法

轉自：InterlockedIncrement和InterlockedDecrement的妙用

一般來說，在多用戶線程環境中，我們使用臨界區、事件對象甚至互斥量來進行同步，尤其是臨界區，可以很方便地對某些變量甚至代碼塊進行鎖定執行，防止多線程之間資源惡性搶奪。

既然如此，為啥微軟又單獨提供了專用於一個數值鎖定計算的API函數InterlockedIncrement和InterlockedDecrement呢？他們又有什么特殊作用呢？     

恰好近段時間寫了一個這方面的應用，幫我加深了對這類API函數的理解。 
    首先描述一下需求，在應用中，有這樣一個類，它可能只被實例化一次，也可能會被實例化多次，但不管被實例化了幾次，它必須在構造函數里執行一項初始化計算，

假設初始化計算的函數為WSAStartup，同時還需要在析構函數里執行一下注銷計算，假設注銷計算的函數為WSACleanup，現在有一個要求，就是它們的初始化和注銷計算只能被執行一次，

就如同在一個項目中，只能運行一次WSAStartup和WSACleanup一樣。當然，大家可能會想到直接在工程的開始和結尾處實現這樣的功能，但是，如果把這個類的文件包括在其它測試工程里進行測試，

同時不改變其它工程的代碼，又該如何實現呢？ 
    其實，我們可以充分利用InterlockedIncrement和InterlockedDecrement，就如同COM的CoInitialize()和CoUninitialize()一樣，描述代碼如下： 

class A { 
protected: 
 static long  m_nRef; 
public: 
 //類A的構造函數  A()  { 
  if(1 == InterlockedIncrement(&m_nRef))   { 
   //以下代碼只執行一次    WSADATA wsaData; 
   WSAStartup(MAKEWORD(2,2), &wsaData);   }  
  }; 
 //類A的虛析構函數  virtual ~A()  { 
  if(0 == InterlockedDecrement(&m_nRef))   { 
   //以下代碼只執行一次    WSACleanup();   } 
 } 
}; 
long A::m_nRef = 0; 

這樣，無論我們創建了類A的多少個實例，在類的構造函數和析構函數里，WSAStartup和WSACleanup均只被執行一次，有效地保證了單元代碼的封裝性。

 

InterLockedIncrement 和 InterLockedDecrement處理線程訪問

當我們在處理多線程或者模擬一個類似COM的引用計數時，我們為了防止多個線程同時訪問一個變量，導致不可預料的結果時。我們便可以方便的使用InterLockedIncrement  和 InterLockedDecrement 來對這個變量進行鎖定訪問：

long volatile lReference;

InterlockedIncrement( &lReference );  // 對這個引用計數進行鎖定並ADD 1

InterlockedDecrement( &lReference ); // 對這個引用計數進行鎖定並SUB 1

這樣就可以方便的操作這個變量，而不需要自己處理同步。當然還有其他方法。。這里不暫時一一說明。

 

秒殺多線程第三篇 原子操作 Interlocked系列函數

上一篇《多線程第一次親密接觸 CreateThread與_beginthreadex本質區別》中講到一個多線程報數功能。為了描述方便和代碼簡潔起見，我們可以只輸出最后的報數結果來觀察程序是否運行出錯。這也非常類似於統計一個網站每天有多少用戶登錄，每個用戶登錄用一個線程模擬，線程運行時會將一個表示計數的變量遞增。程序在最后輸出計數的值表示有今天多少個用戶登錄，如果這個值不等於我們啟動的線程個數，那顯然說明這個程序是有問題的。整個程序代碼如下：

#include <stdio.h>
#include <process.h>
#include <windows.h>
volatile long g_nLoginCount; //登錄次數
unsigned int __stdcall Fun(void *pPM); //線程函數
const int THREAD_NUM = 10; //啟動線程數
unsigned int __stdcall ThreadFun(void *pPM)
{
    Sleep(100); //some work should to do
    g_nLoginCount++;
    Sleep(50); 
    return 0;
}
int main()
{
    g_nLoginCount = 0;

    HANDLE  handle[THREAD_NUM];
    for (int i = 0; i < THREAD_NUM; i++)
        handle[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadFun, NULL, 0, NULL);
    
    WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); 
    printf("有%d個用戶登錄后記錄結果是%d\n", THREAD_NUM, g_nLoginCount);
    return 0;
}

 

程序中模擬的是10個用戶登錄，程序將輸出結果：

 

和上一篇的線程報數程序一樣，程序輸出的結果好象並沒什么問題。下面我們增加點用戶來試試，現在模擬50個用戶登錄，為了便於觀察結果，在程序中將50個用戶登錄過程重復20次，代碼如下：

 

#include <stdio.h>
#include <windows.h>
volatile long g_nLoginCount; //登錄次數
unsigned int __stdcall Fun(void *pPM); //線程函數
const DWORD THREAD_NUM = 50;//啟動線程數
DWORD WINAPI ThreadFun(void *pPM)
{
    Sleep(100); //some work should to do
    g_nLoginCount++;
    Sleep(50);
    return 0;
}
int main()
{
    printf("     原子操作 Interlocked系列函數的使用\n");
    printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
    
    //重復20次以便觀察多線程訪問同一資源時導致的沖突
    int num= 20;
    while (num--)
    {    
        g_nLoginCount = 0;
        int i;
        HANDLE  handle[THREAD_NUM];
        for (i = 0; i < THREAD_NUM; i++)
            handle[i] = CreateThread(NULL, 0, ThreadFun, NULL, 0, NULL);
        WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);
        printf("有%d個用戶登錄后記錄結果是%d\n", THREAD_NUM, g_nLoginCount);
    }
    return 0;
}

 

運行結果如下圖：

 

現在結果水落石出，明明有50個線程執行了g_nLoginCount++;操作，但結果輸出是不確定的，有可能為50，但也有可能小於50。

       要解決這個問題，我們就分析下g_nLoginCount++;操作。在VC6.0編譯器對g_nLoginCount++;這一語句打個斷點，再按F5進入調試狀態，然后按下Debug工具欄的Disassembly按鈕，這樣就出現了匯編代碼窗口。可以發現在C/C++語言中一條簡單的自增語句其實是由三條匯編代碼組成的，如下圖所示。

 

講解下這三條匯編意思：

第一條匯編將g_nLoginCount的值從內存中讀取到寄存器eax中。

第二條匯編將寄存器eax中的值與1相加，計算結果仍存入寄存器eax中。

第三條匯編將寄存器eax中的值寫回內存中。

       這樣由於線程執行的並發性，很可能線程A執行到第二句時，線程B開始執行，線程B將原來的值又寫入寄存器eax中，這樣線程A所主要計算的值就被線程B修改了。這樣執行下來，結果是不可預知的——可能會出現50，可能小於50。

       因此在多線程環境中對一個變量進行讀寫時，我們需要有一種方法能夠保證對一個值的遞增操作是原子操作——即不可打斷性，一個線程在執行原子操作時，其它線程必須等待它完成之后才能開始執行該原子操作。這種涉及到硬件的操作會不會很復雜了，幸運的是，Windows系統為我們提供了一些以Interlocked開頭的函數來完成這一任務（下文將這些函數稱為Interlocked系列函數）。

下面列出一些常用的Interlocked系列函數：

1.增減操作

LONG__cdeclInterlockedIncrement(LONG volatile* Addend);

LONG__cdeclInterlockedDecrement(LONG volatile* Addend);

返回變量執行增減操作之后的值。

LONG__cdec InterlockedExchangeAdd(LONG volatile* Addend, LONGValue);

返回運算后的值，注意！加個負數就是減。

 

2.賦值操作

LONG__cdeclInterlockedExchange(LONG volatile* Target, LONGValue);

Value就是新值，函數會返回原先的值。

 

在本例中只要使用InterlockedIncrement()函數就可以了。將線程函數代碼改成：

DWORD WINAPI ThreadFun(void *pPM)
{
    Sleep(100);//some work should to do
    //g_nLoginCount++;
    InterlockedIncrement((LPLONG)&g_nLoginCount);
    Sleep(50);
    return 0;
}

 

再次運行，可以發現結果會是唯一的。

       因此，在多線程環境下，我們對變量的自增自減這些簡單的語句也要慎重思考，防止多個線程導致的數據訪問出錯。更多介紹，請訪問MSDN上Synchronization Functions這一章節，地址為 http://msdn.microsoft.com/zh-cn/library/aa909196.aspx

看到這里，相信本系列首篇《秒殺多線程第一篇 多線程筆試面試題匯總》中選擇題第一題（百度筆試題）應該可以秒殺掉了吧（知其然也知其所以然），正確答案是D。另外給個附加問題，程序中是用50個線程模擬用戶登錄，有興趣的同學可以試下用100個線程來模擬一下（上機試試絕對會有意外發現^_^）。

下一篇《秒殺多線程第四篇 一個經典多線程同步問題》將提出一個稍為復雜點但卻非常經典的多線程同步互斥問題，這個問題會采用不同的方法來解答，從而讓你充分熟練多線程同步互斥的“招式”。更多精彩，歡迎繼續參閱。

 

轉載請標明出處，原文地址：http://blog.csdn.net/morewindows/article/details/7429155

如果覺得本文對您有幫助，請點擊‘頂’支持一下，您的支持是我寫作最大的動力，謝謝。