 |
級別： 初級
Nam Keung (mailto:namkeung@us.ibm.com), 高級程序員, IBM
Chakarat Skawratananond (mailto:chakarat@us.ibm.com), pSeries Linux 技術顧問, IBM
2005 年 2 月 10 日
2005 年 4 月 21 日 更新
本系列文章可以幫助您將 Win32 C/C++ 應用程序移植到 POWER 上的 Linux。高級程序員 Nam Keung 和 pSeries® Linux 技術顧問 Chakarat Skawratananond 從互斥（mutex）應用程序接口（application program interface，API）的角度闡述了從 Win32 到 Linux 的映射。本系列的 第 1 部分 集中關注的是 Win32 API 的映射。
介紹
本文關注的是互斥原語（primitives）。建議您在繼續閱讀之前先回顧本系列 第 1 部分 中的下列章節：
互斥
如下面的 表 1 所示，互斥提供線程間資源的獨占訪問控制。它是一個簡單的鎖，只有持有它的線程才可以釋放那個互斥。它確保了它們正在訪問的共享資源的完整性（最常見的是共享數據），因為在同一時刻只允許一個線程訪問它。
表 1. 互斥
| Win32 |
Linux |
CreateMutex(0, FALSE, 0); |
pthread_mutex_init(&mutex, NULL)) |
CloseHandle(mutex); |
pthread_mutex_destroy(&mutex) |
WaitForSingleObject(mutex, INFINITE)) |
pthread_mutex_lock(&mutex) |
ReleaseMutex(mutex); |
pthread_mutex_unlock(&mutex) |
創建互斥
在 Win NT/Win2K 中，所有互斥都是遞歸的。
在 Win32 中，CreateMutex() 為當前進程中的線程提供資料的獨占訪問控制。此方法讓線程可以串行化對進程內資源的訪問。創建了互斥句柄（mutual exclusion handle）后，當前進程中的所有線程都可以使用它（見下面的 清單 1）。
清單 1. 創建互斥
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lMutexAttributes,
BOOL lInitialOwner,
LPCTSTR lName
)
|
Linux 使用 pthread 庫調用 pthread_mutex_init() 來創建互斥，如下面的 清單 2 所示。
清單 2. pthread
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
|
Linux 有三種類型的互斥。互斥類型決定了在 pthread_mutex_lock 中線程嘗試鎖定一個它已經持有的互斥時所發生的情形：
- Fast mutex：
- 當嘗試使用
pthread_mutex_lock() 去鎖定互斥時，進行調用的線程會永遠掛起。
- Recursive mutex：
pthread_mutex_lock() 立即返回成功返回代碼。
- Error check mutex：
pthread_mutex_lock() 立即返回錯誤代碼 EDEADLK。
可以以兩種方式設置互斥的類型。清單 3 介紹了設置互斥的靜態方法。
清單 3. 設置互斥的靜態方法
/* For Fast mutexes */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
/* For recursive mutexes */
|
您可以使用這個函數來鎖定互斥：pthread_mutex_lock(pthread_mutex_t *mutex)。這個函數會獲得一個指向它正在嘗試鎖定的互斥的指針。當互斥被鎖定或者發生錯誤時，函數返回。那個錯誤不是歸咎于被鎖定的互斥。函數會等待互斥被解鎖。
設置互斥的另一種方式是使用互斥屬性對象。為此，要調用 pthread_mutexattr_init() 來初始化對象，然后調用 pthread_mutexattr_settype() 來設置互斥的類型，如下面的 清單 4 所示。
清單 4. 通過屬性設置互斥
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
|
使用下面的函數解開對互斥的鎖定（見 清單 5）：
這里是創建互斥的示例代碼（見下面的 6 和 7）。
清單 5. 解鎖函數
pthread_mutex_unlock(pthread_mutex_t *mutex))
|
清單 6. Win32 示例代碼
HANDLE mutex;
mutex = CreateMutex(0, FALSE, 0);
if (!(mutex))
{
return RC_OBJECT_NOT_CREATED;
}
|
清單 7. 相應的 Linux 代碼
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
pthread_mutexattr_init (&attr);
if (rc = pthread_mutex_init(&mutex, &attr))
{
return RC_OBJECT_NOT_CREATED;
}
|
銷毀互斥
在 Win32 中，CloseHandle() 方法（見 清單 8）可以刪除為當前進程中資源提供獨占訪問控制的對象。刪除那個對象后，那個互斥對象就會無效，直到 CloseHandle() 方法通過調用 CreateMutex 重新初始化它。
當不再對資源進行獨占訪問后，您應該調用這個方法銷毀它。如果您需要放棄那個對象的所有權，那么應該調用 ReleaseMutex() 方法。
在 Linux 中，pthread_mutex_destroy() 會銷毀互斥對象，這會釋放它可能會持有的資源。它還會檢查互斥在那個時刻是不是解除鎖定的（見清單 9）。
清單 8. Win32 示例代碼
if(WaitForSingleObject(mutex, (DWORD)0) == WAIT_TIMEOUT )
return RC_NOT_OWNER;
CloseHandle(mutex);
|
清單 9. Linux 代碼
if (pthread_mutex_destroy(&mutex) == EBUSY)
return RC_NOT_OWNER;
|
鎖定互斥
在 Win32 中，WaitForSingleObject()（見 清單 10）會阻塞對當前進程內資源的獨占訪問的請求。進程可以通過下面的方式阻塞請求：
- 如果獨占訪問請求的資源沒有被鎖定，則這個方法鎖定它。
- 如果獨占訪問的資源已經被鎖定，則此方法阻塞那個調用線程，直到那個資源被解除鎖定。
Linux 使用 pthread_mutex_lock()（見 清單 11）。
您還可以使用 pthread_mutex_trylock() 來測試某個互斥是否已經被鎖定，而不需要真正地去鎖定它。如果另一個線程鎖定了那個互斥，則 pthread_mutex_trylock 將不會阻塞。它會立即返回錯誤代碼 EBUSY。
清單 10. Win32 示例代碼
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR;
|
清單 11. Linux 代碼
if (rc = pthread_mutex_lock(&mutex))
return RC_LOCK_ERROR;
|
釋放或者解鎖互斥
Win32 使用 ReleaseMutex()（見 清單 12）來釋放對資源的獨占訪問。如果進行調用的線程并不擁有那個互斥對象，則這個調用可能會失敗。
Linux 使用 pthread_mutex_unlock() 來釋放或者解鎖互斥（見清單 13）。
清單 12. Win32 示例代碼
If (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
|
清單 13. Linux 示例代碼
if (rc = pthread_mutex_unlock(&mutex))
return RC_UNLOCK_ERROR;
|
Mutex 示例代碼
這里是獲得進程內互斥的 Win32 示例代碼（見 Listing 14）：
清單 14. Win32 示例代碼
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void thrdproc (void *data); //the thread procedure (function) to be executed
HANDLE mutex;
int main( int argc, char **argv )
{
int hThrd;
unsigned stacksize;
HANDLE *threadId1;
HANDLE *threadId2;
int arg1;
DWORD rc;
if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );
printf( "Intra Process Mutex test.\n" );
printf( "Start.\n" );
mutex = CreateMutex(0, FALSE, 0);
if (mutex==NULL)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR ;
printf( "Mutex blocked.\n" );
if( stacksize < 8192 )
stacksize = 8192;
else
stacksize = (stacksize/4096+1)*4096;
hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
"Thread 1");
if (hThrd == -1)
return RC_THREAD_NOT_CREATED);
*threadId1 = (HANDLE) hThrd;
hThrd = _beginthread( thrdproc, // Definition of a thread entry
NULL,
stacksize,
Thread 2");
if (hThrd == -1)
return RC_THREAD_NOT_CREATED);
*threadId2 = (HANDLE) hThrd;
printf( "Main thread sleeps 5 sec.\n" );
Sleep( 5*1000 );
if (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
Sleep( arg1 * 1000 );
if( WaitForSingleObject(mutex, (DWORD)0) == WAIT_TIMEOUT )
return RC_NOT_OWNER;
CloseHandle(mutex);
printf( "Mutex deleted. (%lx)\n", rc );
printf( "Main thread sleeps 5 sec.\n" );
Sleep( 5*1000 );
printf( "Stop.\n" );
return 0;
}
void thread_proc( void *pParam )
{
DWORD rc;
printf( "\t%s created.\n", pParam );
if ((rc = WaitForSingleObject(mutex, INFINITE)) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "\tMutex blocked by %s. (%lx)\n", pParam, rc );
printf( "\t%s sleeps for 5 sec.\n", pParam );
Sleep( 5* 1000 );
if (! ReleaseMutex(mutex))
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "\tMutex released by %s. (%lx)\n", pParam, rc );
}
|
相應的獲得進程內互斥的 Linux 示例代碼（見 清單 15）：
清單 15. 相應的 Linux 示例代碼
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
void thread_proc (void * data);
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
int main( int argc, char **argv )
{
pthread_attr_t pthread_attr;
pthread_attr_t pthread_attr2;
pthread_t threadId1;
pthread_t threadId2;
int arg1;
int rc = 0;
if( argc < 2 )
arg1 = 7;
else
arg1 = atoi( argv[1] );
printf( "Intra Process Mutex test.\n" );
printf( "Start.\n" );
pthread_mutexattr_init( &attr );
if ( rc = pthread_mutex_init( &mutex, NULL))
{
printf( "Mutex NOT created.\n" );
return RC_OBJECT_NOT_CREATED;
}
printf( "Mutex created.\n" );
if (rc = pthread_mutex_lock (&mutex))
{
printf( "Mutex LOCK ERROR.\n" );
return RC_LOCK_ERROR;
}
printf( "Mutex blocked.\n" );
if (rc = pthread_attr_init(&pthread_attr))
{
printf( "pthread_attr_init ERROR.\n" );
return RC_THREAD_ATTR_ERROR;
}
if (rc = pthread_attr_setstacksize(&pthread_attr, 120*1024))
{
printf( "pthread_attr_setstacksize ERROR.\n" );
return RC_STACKSIZE_ERROR;
}
if (rc = pthread_create(&threadId1,
&pthread_attr,
(void*(*)(void*))thread_proc,
"Thread 1" ))
{
printf( "pthread_create ERROR.\n" );
return RC_THREAD_NOT_CREATED;
}
if (rc = pthread_attr_init(&pthread_attr2))
{
printf( "pthread_attr_init2 ERROR.\n" );
return RC_THREAD_ATTR_ERROR;
}
if (rc = pthread_attr_setstacksize(&pthread_attr2, 120*1024))
{
printf( "pthread_attr_setstacksize2 ERROR.\n" );
return RC_STACKSIZE_ERROR;
}
if (rc = pthread_create(&threadId2,
&pthread_attr2,
(void*(*)(void*))thread_proc,
"Thread 2" ))
{
printf( "pthread_CREATE ERROR2.\n" );
return RC_THREAD_NOT_CREATED;
}
printf( "Main thread sleeps 5 sec.\n" );
sleep (5);
if (rc = pthread_mutex_unlock(&mutex))
{
printf( "pthread_mutex_unlock ERROR.\n" );
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
printf( "Main thread sleeps %d sec.\n", arg1 );
sleep(arg1);
pthread_mutex_destroy(&mutex);
printf( "Main thread sleeps 5 sec.\n" );
sleep( 5 );
printf( "Stop.\n" );
return 0;
}
void thread_proc( void *pParam )
{
int nRet;
printf( "\t%s created.\n", pParam );
if (nRet = pthread_mutex_lock(&mutex))
{
printf( "thread_proc Mutex LOCK ERROR.\n" );
return RC_LOCK_ERROR;
}
printf( "\tMutex blocked by %s. (%lx)\n", pParam, nRet );
printf( "\t%s sleeps for 5 sec.\n", pParam );
sleep(5);
if (nRet = pthread_mutex_unlock(&mutex))
{
printf( " thread_proc :pthread_mutex_unlock ERROR.\n" );
return RC_UNLOCK_ERROR;
}
printf( "\tMutex released by %s. (%lx)\n", pParam, nRet );
}
|
這里是獲得進程間互斥的另一 Win32 示例代碼。
互斥是系統范圍內對象，可以由多個進程使用。如果程序 A 創建一個互斥，則程序 B 可以使用同一個互斥。互斥有名稱，并且，一個給定名稱的互斥在同一機器上同一時刻只能存在一個。如果您創建了一個名為“My Mutex” 的互斥，則任何其他程序都不能使用這個名稱創建互斥，如下面的清單 16 和 18 所示。
清單 16. Win32 進程間互斥示例代碼 Process 1
#include <stdio.h>
#include <windows.h>
#define WAIT_FOR_ENTER printf( "Press ENTER\n" );getchar()
int main()
{
HANDLE mutex;
DWORD rc;
printf( "Inter Process Mutex test - Process 1.\n" );
printf( "Start.\n" );
SECURITY_ATTRIBUTES sec_attr;
sec_attr.nLength = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle = TRUE;
mutex = CreateMutex(&sec_attr, FALSE, "My Mutex");
if( mutex == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
WAIT_FOR_ENTER;
if ( WaitForSingleObject(mutex, INFINITE) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "Mutex blocked.\n" );
WAIT_FOR_ENTER;
if( ! ReleaseMutex(mutex) )
{
rc = GetLastError();
return RC_UNLOCK_ERROR;
}
printf( "Mutex released.\n" );
WAIT_FOR_ENTER;
CloseHandle (mutex);
printf( "Mutex deleted.\n" );
printf( "Stop.\n" );
return OK;
}
|
在此，Linux 實現使用的是 System V Interprocess Communications（IPC）函數，如清單 17 和 19 所示。
清單 17. 相應的 Linux 示例代碼 Process 1
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#define WAIT_FOR_ENTER printf( "Press ENTER\n" );getchar()
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
struct seminfo __buf; /* buffer for IPC info */
};
main()
{
int shr_sem;
key_t semKey;
struct sembuf semBuf;
int flag;
union semun arg;
printf( "Inter Process Mutex test - Process 1.\n" );
printf( "Start.\n" );
flag = IPC_CREAT;
if( ( semKey = (key_t) atol( "My Mutex" ) ) == 0 )
return RC_INVALID_PARAM;
flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
shr_sem = (int) semget( semKey, 1, flag );
if (shr_sem < 0)
return RC_OBJECT_NOT_CREATED;
arg.val = 1;
if (semctl(shr_sem, 0, SETVAL, arg) == -1)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex created.\n" );
WAIT_FOR_ENTER;
semBuf.sem_num = 0;
semBuf.sem_op = -1;
semBuf.sem_flg = SEM_UNDO;
if (semop(shr_sem, &semBuf, 1) != 0)
return RC_LOCK_ERROR;
printf( "Mutex blocked.\n" );
WAIT_FOR_ENTER;
semBuf.sem_num = 0;
semBuf.sem_op = 1;
semBuf.sem_flg = SEM_UNDO;
if (semop(shr_sem, &semBuf, 1) != 0)
return RC_UNLOCK_ERROR;
printf( "Mutex released.\n" );
WAIT_FOR_ENTER;
semctl( shr_sem, 0, IPC_RMID );
printf( "Mutex deleted.\n" );
printf( "Stop.\n" );
return 0;
|
清單 18. Win32 進程間示例代碼 Process 2
#include <stdio.h>
#include <windows.h>
int main()
{
HANDLE mutex;
printf( "Inter Process Mutex test - Process 2.\n" );
printf( "Start.\n" );
SECURITY_ATTRIBUTES sec_attr;
sec_attr.nLength = sizeof( SECURITY_ATTRIBUTES );
sec_attr.lpSecurityDescriptor = NULL;
sec_attr.bInheritHandle = TRUE;
mutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, “My Mutex");
if( mutex == (HANDLE) NULL )
return RC_OBJECT_NOT_CREATED;
printf( "Mutex opened. \n");
printf( "Try to block mutex.\n" );
if ( WaitForSingleObject(mutex, INFINITE) == WAIT_FAILED)
return RC_LOCK_ERROR;
printf( "Mutex blocked. \n" );
printf( "Try to release mutex.\n" );
if( ! ReleaseMutex(mutex) )
return RC_UNLOCK_ERROR;
printf( "Mutex released.\n" );
CloseHandle (mutex);
printf( "Mutex closed. \n");
printf( "Stop.\n" );
return OK;
}
|
清單 19. 相應的 Linux 示例代碼 Process 2
#include <stdio.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <unistd.h>
int main()
{
int mutex;
key_t semKey;
struct sembuf semBuf;
int flag;
int nRet=0;
printf( "Inter Process Mutex test - Process 2.\n" );
printf( "Start.\n" );
flag = 0;
if( ( semKey = (key_t) atol( "My Mutex" ) ) == 0 )
return RC_INVALID_PARAM;
flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
mutex = (int) semget( semKey, 1, flag );
if (mutex == -1)
return RC_OBJECT_NOT_CREATED;
printf( "Mutex opened \n");
printf( "Try to block mutex.\n" );
semBuf.sem_num = 0;
semBuf.sem_op = -1;
semBuf.sem_flg = SEM_UNDO;
if (semop(mutex, &semBuf, 1) != 0)
return RC_LOCK_ERROR;
printf( "Mutex blocked. \n");
printf( "Try to release mutex.\n" );
semBuf.sem_num = 0;
semBuf.sem_op = 1;
semBuf.sem_flg = SEM_UNDO;
if (semop(mutex, &semBuf, 1) != 0)
return RC_UNLOCK_ERROR;
printf( "Mutex released. \n");
printf( "Mutex closed. \n");
printf( "Stop.\n" );
return 0;
}
|
結束語
在本文中，我們介紹了互斥 API 從 Win32 到 Linux 的映射。我們還引用了一系列互斥示例代碼來幫助您進行從 Win32 到 Linux 的遷移行動。本系列的下一篇文章將闡述信號量。
補充聲明
IBM Corporation 1994-2005。保留所有權利。
本文檔中對 IBM 產品或服務的引用并不表示 IBM 想要讓它們在所有國家都可用。
IBM、eServer 和 pSeries 是 IBM Corporation 在美國和／或其他國家或地區的商標。
Microsoft、Windows、Windows NT 和 Windows 徽標是 Microsoft Corporation 在美國和／或其他國家或地區的商標或注冊商標。
Intel、Intel Inside（logos）、MMX 和 Pentium 是 Intel 公司在美國和／或其他國家或地區的商標。
UNIX 是 The Open Group 在美國和其他國家或地區的注冊商標。
Linux 是 Linus Torvalds 在美國和／或其他國家或地區的商標。
其他公司、產品或服務名稱可能是其他公司的商標或服務標記。
信息都是“按原樣”發布，沒有任何類型的保證。
所描述的所有的客戶示例只是為了說明那些客戶如何使用 IBM 產品，以及它們可能獲得的結果。不同客戶所得到的實際環境代價和性能特性可能會不同。
涉及非 IBM 產品的信息可從這些產品的供應商、其出版說明或其他可公開獲得的資料中獲取，并不構成 IBM 對此產品的認可。非 IBM 價目及性能數字資源取自可公開獲得的信息，包括供應商的聲明和供應商的全球主頁。 IBM 沒有對這些產品進行測試，也無法確認其性能的精確性、兼容性或任何其他關于非 IBM 產品的聲明。有關非 IBM 產品性能的問題應當向這些產品的供應商提出。
所有關于 IBM 未來方向或意向的聲明都可隨時更改或收回，而不另行通知，它們僅僅表示了目標和意愿而已。聯系您本地的 IBM 辦公人員或者 IBM 授權的轉銷商，以獲得特定的 Statement of General Direction 的全文。
這里所包含的信息可能陳述了預期的未來功能。上述信息并不打算作為對任何未來產品的特定性能級別、功能或交付時間表的明確承諾。這樣的承諾只會在 IBM 產品中作出。這里出現的信息用于表明 IBM 當前的投資和發展活動，作為一種信任，來幫助我們的客戶規劃未來。
性能是在受控環境中使用標準的 IBM 基準程序測試和估算的。任何用戶實際的吞吐量或性能可能各不相同，這取決于需要考慮的事項，例如用戶作業流中的多道程序設計總量、I/O 配置、存儲器配置和處理的工作負載。因此，我們不能擔保，個別用戶所獲得的吞吐量或性能改善等同于這里所列的值。
參考資料
作者簡介
|
|
|
|
Nam Keung 是 IBM 的一名高級程序員，他曾致力于 AIX 通信開發、AIX 多媒體、SOM/DSOM 開發和 Java 性能方面的工作。他目前的工作包括幫助獨立軟件提供商（Independent Software Vendors，ISV）進行應用程序設計、部署應用程序、性能調優和關于 pSeries 平臺的教育。您可以通過 namkeung@us.ibm.com 與 Nam 聯系。
|
|
|
|
|
Chakarat Skawratananond 是 IBM eServer Solutions Enablement 組織的一名技術顧問，在那里，他幫助獨立軟件開發商在 IBM pSeries 平臺上使用他們的用于 AIX 和 Linux 的應用程序。您可以通過 chakarat@us.ibm.com 與 Chakarat 聯系。
|
|