将 Win32 C/C++ 应用程序迁移到 POWER 上的 Linux

来源：互联网发布：iphone软件更新小红点编辑：程序博客网时间：2024/05/21 19:42

本系列文章可以帮助您将 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. 互斥
Win32LinuxCreateMutex(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_ATTRIBUTESlMutexAttributes, BOOLlInitialOwner, LPCTSTRlName)

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 executedHANDLE    mutex;int main( int argc, char **argv ){      int        hThrd;      unsigned   stacksize;      HANDLE     *threadId1;      HANDLE     *threadId2;      int        arg1;      DWORD  rc;       if( argc < 2 )arg1 = 7;elsearg1 = 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 ){       DWORDrc;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;elsearg1 = 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 ){       intnRet;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(){      HANDLEmutex;      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;      intflag;      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 的迁移行动