`
cuiyadll
  • 浏览: 208913 次
文章分类
社区版块
存档分类
最新评论

将 Win32 C/C++ 应用程序迁移到 POWER 上的 Linux，第 3 部分: 信号

LINUX进程 
阅读更多

 

http://blog.csdn.net/j6915819/article/details/17220029

信号

信号是包含有一个正数的资源。信号允许进程通过一个单一的原子操作来测试和设置那个整数的值，以此实现同步。通常，信号的主要用途是同步某个线程与其他线程的动作。在多个进程竞争访问同一操作系统资源时，这也是协调或者同步那些行为的一种实用技术。

Linux 支持 Portable Operating System Interface（POSIX）信号以及 pthread 条件变量，以此来映射 Win32 信号 API。它们各有其优缺点。您应该基于应用程序的逻辑来判断使用哪种方法。在映射事件信号的过程中需要考虑的方面包括：

  • 信号的类型：Win32 既支持有名称的事件信号，也支持无名称的事件信号。有名称的信号是在多个进程间共享的。Linux 不支持这种方案。本文中列出的一个进程间通信（Inter-Process Communication，IPC）消息队列示例代码将向您展示如何来解决此问题。
  • 初始状态：在 Win32 中，信号可能会有初始值。在 Linux 中，POSIX 信号支持此功能，但 pthreads 不支持。在使用 pthreads 时您需要考虑到这一点。
  • 超时：Win32 事件信号支持定时等待。在 Linux 中，POSIX 信号实现只支持不确定的等待（阻塞）。pthreads 实现既支持阻塞也支持超时。pthread_cond_timedwait() 调用能给出等待期间的超时的值，pthread_cond_wait() 则用于不确定的等待。
  • 发信号：在 Win32 中，发出信号会唤醒等待那个信号的所有线程。在 Linux 中，POSIX 线程实现一次只唤醒一个线程。pthreads 实现的 pthread_cond_signal() 调用会唤醒一个线程，pthread_cond_broadcast() 调用会向所有等待那个信号的线程发出信号。

表 1. 信号映射表
Win32 pthread Linux POSIX
CreateSemaphore pthread_mutex_init(&(token)->mutex, NULL))
pthread_cond_init(&(token)->condition, NULL))		 sem_init
CloseHandle (semHandle) pthread_mutex_destroy(&(token->mutex))
pthread_cond_destroy(&(token->condition))		 sem_destroy
ReleaseSemaphore(semHandle, 1, NULL) pthread_cond_signal(&(token->condition)) sem_post
WaitForSingleObject(semHandle, 
INFINITE)
WaitForSingleObject(semHandle, 
timelimit)		 pthread_cond_wait(&(token->condition), 
&(token->mutex))
pthread_cond_timedwait(&(token
->condition), &(token->mutex))		 sem_wait
sem_trywait
 

回页首

条件变量

条件变量让开发者能够实现一个条件，在这个条件下线程执行然后被阻塞。Microsoft® Win32 接口本身不支持条件变量。为解决此缺憾，我使用 POSIX 条件变量模拟同步原语，并在一系列文章中对此进行了概述。在 Linux 中，它可以确保因某条件被阻塞的线程，当那个条件改变时，会被解除阻塞。它还允许您原子地（atomically）解除互斥的锁定，并等待条件变量，而不 会有干涉其他线程的可能。不过，每个条件变量都应该伴有一个互斥。前面的表 1 给出了用于线程间同步的 pthread 条件变量。

 

回页首

创建信号

在 Win32 中，CreateSemaphore 函数可以创建一个有名称的或者无名称的信号对象。Linux 不支持有名称的信号。


清单 1. 创建信号
HANDLE CreateSemaphore (
	LPSECURITY_ATTRIBUTES	lpSemaphoreAttributes,
	LONG			lInitialCount,
	LONG			lMaximunCount,
	LPCTSTR			lpName
);

在 Linux 中，sem_init() 调用会创建一个 POSIX 信号：


清单 2. POSIX 信号
                    
int sem_init(sem_t *sem, int pshared, unsigned int value

Linux 使用 pthread_condition_init 调用在当前进程内创建信号对象，在其中维持一个在零与最大值之间的计数值。每次有某个线程完成对信号的等待，这个计数值会减小，而每次当某个线程释放这个信号时，计数值增加。当计数值成为零时，信号对象的状态成为 non-signaled。


清单 3. 创建信号对象的 pthread_condition_init 调用
                    
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);


清单 4. Win32 示例代码
                
HANDLE semHandle;
semHandle = CreateSemaphore(NULL, 0, 256000, NULL); 
     /* Default security descriptor     */
if( semHandle == (HANDLE) NULL)                     
     /* Semaphore object without a name */
{
     return RC_OBJECT_NOT_CREATED;
}



清单 5. 相应的 Linux 代码
                
typedef struct 
{
	pthread_mutex_t	mutex;
	pthread_cond_t		condition;
	int			semCount;	
}sem_private_struct, *sem_private;
sem_private    token;
token = (sem_private) malloc(sizeof(sem_private_struct));
if(rc = pthread_mutex_init(&(token->mutex), NULL))
{
	free(token);
	return RC_OBJECT_NOT_CREATED;
}
if(rc = pthread_cond_init(&(token->condition), NULL))
{
	pthread_mutex_destroy( &(token->mutex) );
	free(token);
	return RC_OBJECT_NOT_CREATED;
}
token->semCount = 0;

 

回页首

销毁事件信号

Win32 使用 CloseHandle 来删除由 CreateSemaphore 所创建的信号对象。


清单 6. 销毁事件信号
BOOL CloseHandle (HANDLE hObject);

Linux POSIX 信号使用 sem_destroy() 来销毁无名称的信号。


清单 7. sem_destroy() 
                
int sem_destroy(sem_t *sem);

在 Linux pthreads 中，使用 pthread_cond_destroy() 来销毁条件变量。


清单 8. pthread_cond_destroy() 
                    
int pthread_cond_destroy(pthread_cond_t *cond);


清单 9. Win32 代码和相应的 Linux 代码
Win32 代码 相应的 Linux 代码
CloseHandle(semHandle); pthread_mutex_destroy(&(token->mutex));

pthread_cond_destroy(&(token->condition));

free (token);
 

回页首

发布事件信号

在 Win32 中，ReleaseSemaphore 函数会令指定的信号对象的计数值增加指定数量。


清单 10. ReleaseSemaphore 函数
                    
BOOL ReleaseSemaphore(
	HANDLE hSemaphore,
	LONG 	lReleaseCount,
	LPLONG	lpPreviousCount
);

Linux POSIX 信号使用 sem_post() 来发布事件信号。这将唤醒阻塞于此信号的所有线程。


清单 11. sem_post() 
                    
int sem_post(sem_t * sem);

在 Linux 中，pthread_cond_signal 会唤醒等待某个条件变更的某个线程。Linux 调用这个函数来为此对象所标识的信号发布一个事件完成信号。调用的线程增加那个信号的值。如果信号的值从零开始增加，而且 pthread_cond 中有任何线程被阻塞，那么请等待这个信号，因为其中一个会被唤醒。默认情况下，实现可以选择任意的正在等待的线程。


清单 12. pthread_cond_signal 
                    
int pthread_cond_signal(pthread_cond_t *cond);


清单 13. Win32 代码和相应的 Linux 代码
Win32 代码 相应的 Linux 代码
ReleaseSemaphore(semHandle, 1, NULL) if (rc = pthread_mutex_lock(&(token->mutex)))
return RC_SEM_POST_ERROR;

token->semCount ++;

if (rc = pthread_mutex_unlock(&(token->mutex)))
return RC_SEM_POST_ERROR;

if (rc = pthread_cond_signal(&(token->condition)))
return RC_SEM_POST_ERROR;
 

回页首

等待事件信号

Win32 调用 WaitForSingleObject 函数来等待所需要的信号上事件的完成。当等待单一线程同步对象时，可以使用此方法。当对象被设置发出信号或者超时时间段结束时，这个方法会得到通知。如果时间间隔是 INFINITE，那么它就会无止境地等待下去。


清单 14. WaitForSingleObject 函数
                    
DWORD WaitForSingleObject(
	HANDLE hHANDLE,
	DWORD	dwMilliseconds
);

使用 WaitForMultipleObjects 函数来等待多个被通知的对象。在信号线程同步对象中，当计数器变为零时，对象是 non-signaled。


清单 15. WaitForMultipleObjects 函数
                    
DWORD WaitForMultipleObjects(
	DWORD	nCount,
	Const	HANDLE* lpHandles,
	BOOL	bWaitAll,
	DWORD	dwMilliseconds
);

Linux POSIX 信号使用 sem_wait() 来挂起发出调用的线程，直到信号拥有了非零的计数值。然后它自动地减少信号的计数值。


清单 16. sem_wait() 函数
                    
int sem_wait(sem_t * sem);

在 POSIX 信号中不能使用超时选项。不过，您可以通过在某个循环中执行非阻塞的 sem_trywait() 来完成此功能，它会计算超时的值。


清单 17. sem_trywait() 函数
                    
int sem_trywait(sem_t  * sem);

在 Linux 中，pthread_cond_wait() 会阻塞发出调用的线程。发出调用的线程会减小那个信号。如果当 pthread_cond_wait 被调用时信号是零，则 pthread_cond_wait() 就会阻塞，直到另一个线程增加了那个信号的值。


清单 18. pthread_cond_wait() 函数
                    
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t  *mutex);

pthread_cond_wait 函数首先释放相关联的 external_mutex of type pthread_mutex_t，当调用者检查条件表达式时必须持有它。


清单 19. Win32 代码和相应的 Linux 代码
Win32 代码 相应的 Linux 代码
DWORD retVal;

retVal = WaitForSingleObject(semHandle, INFINITE);

if (retVal == WAIT_FAILED) return RC_SEM_WAIT_ERROR		 if (rc = pthread_mutex_lock(&(token->mutex)))
return RC_SEM_WAIT_ERROR;

while (token->semCount <= 0)
{
rc = pthread_cond_wait(&(token->condition), &(token->mutex));
if (rc &&errno != EINTR )
break;
}
token->semCount--;

if (rc = pthread_mutex_unlock(&(token->mutex)))
return RC_SEM_WAIT_ERROR;

如果您需要在指定的一段时间内阻塞发出调用的线程，那么请使用 pthread_cond_timewait 来阻塞它。调用这个方法来等待所需要信号上某个事件的完成，等待指定的一段时间。


清单 20. pthread_cond_timewait
                
	int pthread_cond_timewait(
	pthread_cond_t		*cond,
	pthread_mutex_t		*mutex,
	timespec		*tm
);




清单 21. Win32 代码和相应的 Linux 代码
Win32 代码 相应的 Linux 代码
retVal = WaitForSingleObject(SemHandle, timelimit);

if (retVal == WAIT_FAILED)
return RC_SEM_WAIT_ERROR;

if (retVal == WAIT_TIMEOUT)
return RC_TIMEOUT;		 int rc;
struct timespec tm;
struct timeb tp;
long sec, millisec;

if (rc = pthread_mutex_lock(&(token->mutex)))
return RC_SEM_WAIT_ERROR;

sec = timelimit / 1000;
millisec = timelimit % 1000;
ftime( &tp );
tp.time += sec;
tp.millitm += millisec;
if( tp.millitm > 999 )
{
tp.millitm -= 1000;
tp.time++;
}
tm.tv_sec = tp.time;
tm.tv_nsec = tp.millitm * 1000000 ;

while (token->semCount <= 0)
{
rc = pthread_cond_timedwait(&(token->condition), &(token->mutex), &tm);
if (rc && (errno != EINTR) )
break;
}
if ( rc ) 
{
if ( pthread_mutex_unlock(&(token->mutex)) )
return RC_SEM_WAIT_ERROR );

if ( rc == ETIMEDOUT) /* we have a time out */
return RC_TIMEOUT );

return RC_SEM_WAIT_ERROR );

} 
token->semCount--;

if (rc = pthread_mutex_unlock(&(token->mutex)))
return RC_SEM_WAIT_ERROR;
 

回页首

POSIX 信号示例代码

清单 22 使用 POSIX 信号来实现线程 A 和 B 之间的同步：


清单 22. POSIX 信号示例代码
                    
sem_t sem; /* semaphore object */
int irc;   /* return code */
/* Initialize the semaphore - count is set to 1*/
irc = sem_init (sem, 0,1)
...
/* In Thread A */
/* Wait for event to be posted */
sem_wait (&sem);
/* Unblocks immediately as semaphore initial count was set to 1 */
 .......
/* Wait again for event to be posted */
sem_wait (&sem);
/* Blocks till event is posted */
/* In Thread B */
/* Post the semaphore */
...
irc = sem_post (&sem);
/* Destroy the semaphore */
irc = sem_destroy(&sem);

 

回页首

进程内信号示例代码


清单 23. Win32 进程内信号示例代码
                
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
void thrdproc      (void   *data);  // the thread procedure (function) 
     to be executed
HANDLE   semHandle;
int
main( int argc, char **argv )
{
        HANDLE    *threadId1;
        HANDLE    *threadId2;
        int        hThrd;
        unsigned   stacksize;
        int	    arg1;
	if( argc < 2 )
		arg1 = 7;
	else
		arg1 = atoi( argv[1] );
	printf( "Intra Process Semaphor test.\n" );
	printf( "Start.\n" );
	semHandle = CreateSemaphore(NULL, 1, 65536, NULL);
        if( semHandle == (HANDLE) NULL)
	{
		printf("CreateSemaphore error: %d\n", GetLastError());
	}
	printf( "Semaphor created.\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);
         if( ! ReleaseSemaphore(semHandle, 1, NULL) )
		printf("ReleaseSemaphore error: %d\n", GetLastError());
         printf( "Semaphor released.\n" );
         printf( "Main thread sleeps %d sec.\n", arg1 );
	
         sleep (arg1);
       if( ! ReleaseSemaphore(semHandle, 1, NULL) )
		printf("ReleaseSemaphore error: %d\n", GetLastError());
 
	printf( "Semaphor released.\n" );
	printf( "Main thread sleeps %d sec.\n", arg1 );
	sleep (arg1);
        CloseHandle(semHandle);
	
	printf( "Semaphor deleted.\n" );
	printf( "Main thread sleeps 5 sec.\n" );
        
        sleep (5);
        printf( "Stop.\n" );
	return OK;
}
void
thread_proc( void *pParam )
{
 
 DWORD  retVal;
	printf( "\t%s created.\n", pParam );
	       
        retVal = WaitForSingleObject(semHandle, INFINITE);
        if (retVal == WAIT_FAILED)
               return RC_SEM_WAIT_ERROR;
	printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, retVal);
	printf( "\t%s sleeps for 5 sec.\n", pParam );
	sleep(5);
	if( ! ReleaseSemaphore(semHandle, 1, NULL) )
                printf("ReleaseSemaphore error: %d\n", GetLastError());
	printf( "\tSemaphor released by %s.)\n", pParam);
}




清单 24. 相应的 Linux 进程内信号示例代码
                
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
void  thread_proc (void * data);
pthread_mutexattr_t     attr;
pthread_mutex_t         mutex;
typedef struct
{
        pthread_mutex_t         mutex;
        pthread_cond_t          condition;
        int                     semCount;
}sem_private_struct, *sem_private;
sem_private     token;
int main( int argc, char **argv )
{
        pthread_t             threadId1;
        pthread_t             threadId2;
        pthread_attr_t        pthread_attr;
        pthread_attr_t        pthread_attr2;
        int			arg1;
        int                   rc;
	if( argc < 2 )
		arg1 = 7;
	else
		arg1 = atoi( argv[1] );
      printf( "Intra Process Semaphor test.\n" );
      printf( "Start.\n" );
      token =(sem_private)  malloc (sizeof (sem_private_struct));        
     
      if(rc = pthread_mutex_init( &(token->mutex), NULL))
      {
                free(token);
                return 1;
      }
      if(rc = pthread_cond_init(&(token->condition), NULL))
      {
           printf( "pthread_condition ERROR.\n" );
           pthread_mutex_destroy( &(token->mutex) );
           free(token);
           return 1;
      }
      token->semCount = 0;
      printf( "Semaphor created.\n" );
      if (rc = pthread_attr_init(&pthread_attr))
      {
           printf( "pthread_attr_init ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_setstacksize(&pthread_attr, 120*1024))
      {
           printf( "pthread_attr_setstacksize ERROR.\n" );
           exit;
      }
      if (rc = pthread_create(&threadId1,
                           &pthread_attr,
            (void*(*)(void*))thread_proc, 
                               "Thread 1" ))
      {
           printf( "pthread_create ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_init(&pthread_attr2))
      {
           printf( "pthread_attr_init2 ERROR.\n" );
           exit;
      }
      if (rc = pthread_attr_setstacksize(&pthread_attr2, 120*1024))
      {
           printf( "pthread_attr_setstacksize2 ERROR.\n" );
           exit;
      }
      if (rc = pthread_create(&threadId2, 
                          &pthread_attr2,
            (void*(*)(void*))thread_proc,
                               "Thread 2" ))
      {
           printf( "pthread_CREATE ERROR2.\n" );
           exit ;  // EINVAL, ENOMEM
      }
	
      printf( "Main thread sleeps 5 sec.\n" );
      sleep( 5 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR 1.\n" );
           return 1; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock&(token->mutex)))
      {
           printf( "pthread_mutex_unlock ERROR 1.\n" );
           return 1; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR1.\n" );
           return 1; 
      }
      printf( "Semaphor released.\n" );
      printf( "Main thread sleeps %d sec.\n", arg1 );
      sleep( arg1 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return 1; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return 1; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR.\n" );
           return 1; 
      }
	
      printf( "Semaphor released.\n" );
      printf( "Main thread sleeps %d sec.\n", arg1 );
      sleep( arg1 );
      pthread_mutex_destroy(&(token->mutex));
      pthread_cond_destroy(&(token->condition));	
      printf( "Semaphor deleted.\n" );
      printf( "Main thread sleeps 5 sec.\n" );
      sleep( 5 );
      printf( "Stop.\n" );
      return 0;
}
void
thread_proc( void *pParam )
{
 int	rc;
      printf( "\t%s created.\n", pParam );
      if (token == (sem_private) NULL)
          return ;
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR2.\n" );
           return ; 
      }
      while (token->semCount <= 0)
      {
                rc = pthread_cond_wait(&(token->condition), &(token->mutex));
                if (rc && errno != EINTR )
                        break;
      }
      if( rc )
      {
                pthread_mutex_unlock(&(token->mutex));
                printf( "pthread_mutex_unlock ERROR3.\n" );
                return; 
      }
      token->semCount--;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return ; 
      }
      printf( "\tSemaphor blocked by %s. (%lx)\n", pParam, rc );
      printf( "\t%s sleeps for 5 sec.\n", pParam );
      sleep( 5 );
      if (rc =  pthread_mutex_lock(&(token->mutex)))
      {
           printf( "pthread_mutex_lock ERROR.\n" );
           return ; 
      }
      token->semCount ++;
      if (rc = pthread_mutex_unlock(&(token->mutex)))
      {
           printf( "pthread_mutex_unlock ERROR.\n" );
           return ; 
      }
      if (rc = pthread_cond_signal(&(token->condition)))
      {
           printf( "pthread_cond_signal ERROR.\n" );
           return ; 
      }
      printf( "\tSemaphor released by %s. (%lx)\n", pParam, rc );

 

回页首

进程间信号示例代码


清单 25. Win32 进程间信号示例代码，进程 1
                
#include <stdio.h>
#include <windows.h>
#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()
int main()
{
       HANDLE		semaphore;
       int		nRet;
       DWORD          retVal;
       SECURITY_ATTRIBUTES		sec_attr;
	printf( "Inter Process Semaphore test - Process 1.\n" );
	printf( "Start.\n" );
	
	sec_attr.nLength              = sizeof( SECURITY_ATTRIBUTES );
	sec_attr.lpSecurityDescriptor = NULL;
	sec_attr.bInheritHandle       = TRUE;
	semaphore = CreateSemaphore( &sec_attr, 1, 65536, “456789" );
	if( semaphore == (HANDLE) NULL )
		return RC_OBJECT_NOT_CREATED;
       printf( "Semaphore created. (%lx)\n", nRet );
	
	WAIT_FOR_ENTER;
	
	if( ! ReleaseSemaphore(semaphore, 1, NULL) )
		return SEM_POST_ERROR;
      
       printf( "Semaphore Posted. \n");
	
	WAIT_FOR_ENTER;
	retVal = WaitForSingleObject (semaphore, INFINITE );
        if (retVal == WAIT_FAILED)
              return SEM_WAIT_ERROR;
  
	printf( "Wait for Semaphore. \n");
	
       WAIT_FOR_ENTER;
	       
       CloseHandle (semaphore);
	printf( "Semaphore deleted.\n" );
	printf( "Stop.\n" );
	return 0;
}

清单 26 给出了作为支持进程间共享的有名称信号示例的消息 IPC 代码。


清单 26. 相应的 Linux 进程间信号示例代码，进程 1
                
#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#define WAIT_FOR_ENTER  printf( "Press ENTER\n" );getchar()
struct msgbuf {
        long mtype;         /* type of message */
        char mtext[1];      /* message text */
};
int main()
{
        key_t           msgKey;
        int             flag;
        struct msgbuf   buff;
        int             sem;
        int             nRet =0;
	printf( "Inter Process Semaphore test - Process 1.\n" );
	printf( "Start.\n" );
        
	flag = IPC_CREAT|IPC_EXCL;
      if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
                return 1;
      flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
      sem  = (int) msgget( msgKey, flag );
      
      if (sem == -1)
             if( errno == EEXIST )
             {
                    flag &= ~IPC_EXCL;
                    sem = (int) msgget( msgKey, flag );
                    if (msgctl(sem, IPC_RMID, NULL ) != 0)
                            return 1;
                    sem = (int) msgget( msgKey, flag );
                    if (sem == -1)
                            return 1;
             }
             else
                    return 1;
      printf( "Semaphore created. \n" );
      WAIT_FOR_ENTER;
      buff.mtype = 123;
      if( msgsnd( sem, &buff, 1, 0 ) < 0 )
          return 1;
      printf( "Semaphore Posted. \n" );
	
      WAIT_FOR_ENTER;
      if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
          return 1;
      printf( "Wait for Semaphore. \n" );
      WAIT_FOR_ENTER;
      msgctl(sem, 0, IPC_RMID );
      printf( "Semaphore deleted.\n" );
	printf( "Stop.\n" );
	return 0;
}




清单 27. Win32 进程间信号示例代码，进程 2
                
#include <stdio.h>
#include <windows.h>
int main()
{
	HANDLE	semaphore;
	DWORD   retVal;
	printf( "Inter Process Semaphore 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;
	semaphore = CreateSemaphore( &sec_attr, 0, 65536, “456789" );
	if( semaphore == (HANDLE) NULL )
		return RC_OBJECT_NOT_CREATED;
	printf( "Semaphore opened. (%lx)\n", nRet );
	
	printf( "Try to wait for semaphore.\n" );
	
       while( ( retVal = WaitForSingleObject( semaphore, 250 ) ) == WAIT_TIMEOUT)
		printf( "Timeout. \n");
	
       printf( "Semaphore acquired. \n");
       printf( "Try to post the semaphore.\n" );
	       
       if( ! ReleaseSemaphore(semaphore, 1, NULL) )
	     return RC_SEM_POST_ERROR;
	
       printf( "Semaphore posted. \n");
	
	CloseHandle(semaphore);
	printf( "Semaphore closed. \n");
	printf( "Stop.\n" );
	return 0;
}




清单 28. 相应的 Linux 进程间信号示例代码，进程 2
                
#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#define RC_TIMEOUT = 3
struct msgbuf {
        long mtype;         /* type of message */
        char mtext[1];      /* message text */
};
int main()
{
        key_t           msgKey;
        int             flag=0;
        struct msgbuf   buff;
        int             sem;
        int             nRet =0;
	printf( "Inter Process Semaphore test - Process 2.\n" );
	printf( "Start.\n" );
      if( ( msgKey = (key_t) atol( "456789" ) ) <= 0 )
            return 1;
      flag |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
      sem = (int) msgget( msgKey, flag );
      if (sem == -1)
            if( errno == EEXIST )
            {
                   flag &= ~IPC_EXCL;
                   sem = (int) msgget( msgKey, flag );
                   if (msgctl(sem, IPC_RMID, NULL ) != 0)
                          return 1;
                   sem = (int) msgget( msgKey, flag );
                   if (sem == -1)
                           return 1;
            }
            else
                   return 1;
	printf( "Semaphore opened. (%lx)\n", nRet );
	if( nRet != 0 )
          return 0;
	printf( "Try to wait for semaphore.\n" );
	while( ( nRet = sem_shared_wait_timed( sem, 250 ) ) == 3) 
	
	printf( "Timeout. (%lx)\n", nRet );
	printf( "Semaphore acquired. (%lx)\n", nRet );
	printf( "Try to post the semaphore.\n" );
       buff.mtype = 123;
       if( msgsnd( sem, &buff, 1, 0 ) < 0 )
          return 1;
	printf( "Semaphore posted. (%lx)\n", nRet );
	if( nRet != 0 )
		return 0;
	printf( "Semaphore closed. (%lx)\n", nRet );
	printf( "Stop.\n" );
	return 0;
}
int sem_shared_wait_timed( int sem, unsigned long timelimit)
{
        struct msgbuf           buff;
        struct timeval          timeOut;
        int                     msg[1];
        int                     nRet=0;
        timeOut.tv_sec  = timelimit / 1000;
        timeOut.tv_usec = (timelimit % 1000) * 1000;
        msg[0] = sem;
        nRet = select( 0x1000, (fd_set *)msg, NULL, NULL, &timeOut );
        if(nRet == 0)
           return 3;
        if( msgrcv( sem, &buff, 1, 0, 0 ) < 0 )
              return 1;
}

 

回页首

结束语

本系列的第三篇文章从信号 API 的角度讲述了从 Win32 到 Linux 的映射，并给出了您可以引用的信号示例代码。线程化的、同步的系统所提出的挑战不仅是设计与实现，也包括了质量保证的所有阶段。当进行从 Win32 到 Linux 的迁移时，可以将这些文章做为参考。一定要去阅读本系列中以前的文章。

分享到：
| POSIX.1 and ISO C标准头文件
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    福兴讯V587对讲机写频，调频软件 福摩斯特V587

    福兴讯V587对讲机写频，调频软件。福摩斯特V587对讲机写频，调频

    uni-helper_vite-plugin-uni-tai_1742854282.zip

    app开发

    LangChain框架详解：大语言模型应用开发的核心模块与实践

    内容概要：本文介绍了LangChain这一开源框架，它专为开发基于大型语言模型（LLM）的应用程序而设计。文章阐述了LangChain的核心理念、架构组成及其重要性。LangChain通过模块化设计解决了大模型应用开发中的效率低下和局限性问题，提供了标准化的接口和丰富的抽象层，使开发者能够轻松接入不同大模型并构建高效的应用程序。文中详细讲解了几个关键模块，包括Model I/O、Retrieval、Chains、Memory、Agents和Callbacks，以及如何安装和使用LangChain进行开发。此外，还展示了具体的代码示例，如如何调用OpenAI的API、构建LLMChain链路、设置回调机制和实现对话记忆功能。 适合人群：对大语言模型有一定了解并且有兴趣开发基于LLM的应用程序的研发人员和技术爱好者。 使用场景及目标：①帮助开发者快速掌握LangChain的基本概念和使用方法；②提供实用的代码示例，便于开发者实际操作；③解释如何通过LangChain克服大模型应用开发中的常见难题，如模型差异、输出不稳定等。 阅读建议：鉴于LangChain涉及较多的专业术语和技术细节，建议读者在阅读时结合官方文档和示例代码一起学习，尤其是对于核心模块的理解和实践。同时，关注GitHub上的最新版本更新，以获取最新的特性和改进。

    网络伴侣 iCompanion 2.1

    网络伴侣 iCompanion 2.1 网络计费软件，功能全面，支持ISDN

    移动开发_Flutter_简约聊天_纸聊APP_1742846962.zip

    app开发

    《基于YOLOv8的交通事故自动报警系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    《基于YOLOv8的八段锦练习指导系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    前端开发_UniApp_云开发_JsSdk_全端适配实战讲解_1742852088.zip

    app开发

    移动开发_Flutter_轮子推荐_开发效率提升_1742851671.zip

    移动开发_Flutter_轮子推荐_开发效率提升_1742851671.zip

    往复活塞杆密封件热弹流润滑仿真：Python实现与解析（复现论文，含详细可运行代码及解释）

    内容概要：本文详细介绍了往复活塞杆密封件在瞬态条件下热弹流润滑仿真的Python实现。首先定义了几何、材料和工况参数，然后分别构建了流体力学、热力学和固体力学模型。流体力学模型使用有限差分法求解瞬态雷诺方程，热力学模型考虑了温度和压力对粘度的影响，固体力学模型则采用了Mooney-Rivlin超弹性模型和Prony级数描述的粘弹性松弛。最后通过耦合求解实现了整个系统的时间积分，并绘制了液膜厚度和压力分布图。文中还讨论了模型的特点、简化假设以及扩展建议。 适合人群：机械工程领域的研究人员和技术人员，尤其是对密封件性能优化感兴趣的从业者。 使用场景及目标：适用于研究往复活塞杆密封件的工作机理及其在不同工况下的表现，帮助工程师理解和预测密封件的动态特性，从而改进设计和选材。 其他说明：该实现基于论文中的理论框架，但在实际应用时可能需要进一步调整和完善。

    人人商城V3-3.2.1版本.zip 亲测能用

    人人商城V3-3.2.1版本.zip 亲测能用

    《基于YOLOv8的灯光设备监测系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    Java面向对象编程，出现的示例代码

    Java面向对象编程，出现的示例代码

    蓝桥杯python相关资源，真题，蓝桥杯，蓝桥杯Python练习系统题库，蓝桥杯Python练习系统题库

    蓝桥杯python，蓝桥杯python相关资源，真题，蓝桥杯，蓝桥杯Python练习系统题库，蓝桥杯Python练习系统题库

    fsfzdgdfrgbzgr

    rgrgdfsegfasgrsredgf

    《基于YOLOv8的冲浪运动分析系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

    Lotus Notes 4.65

    Lotus Notes 4.65 是 IBM 旗下早期版本的企业级协作平台，主要面向办公自动化和非结构化数据管理领域。以下为综合信息整理： 一、版本背景与定位 核心架构 Lotus Notes 4.65 属于客户端-服务器架构的早期版本，其服务器端为 Lotus Domino18。 客户端功能：集成电子邮件、日历、联系人管理、文档数据库访问16。 服务器功能：支持分布式文档存储、跨平台数据同步及安全权限管理18。 技术特性 数据库技术：采用非结构化文档数据库，支持表单、视图、代理等自定义数据管理工具68。 工作流引擎：内置开发环境（Domino Designer），可定制审批流程、文档跟踪等企业级应用18。 跨平台兼容性：支持 Windows 95/98、NT 等早期操作系统，依赖 TCP/IP 协议实现网络通信25。

    Go语言入门指南：从基础语法到并发编程及错误处理

    内容概要：本文档详细介绍了Go语言的基础知识及其特性，旨在帮助初学者快速上手并掌握这门语言。首先概述了Go语言的特点，包括简洁高效的语法、强大的并发模型、跨平台支持以及丰富的标准库。接着逐步讲解了环境安装、基础语法、控制结构、集合类型、函数定义、结构体与方法、并发编程、错误处理等方面的内容。最后提供了包管理和学习资源的推荐，鼓励读者通过实战项目进一步提升技能。 适合人群：对编程有一定兴趣但尚未接触过Go语言的学习者，尤其是希望快速掌握一门高效并发编程语言的开发者。 使用场景及目标：①作为新手教程，帮助读者建立对Go语言的基本认识；②提供详细的语法指导，使读者能够独立完成简单的程序编写；③介绍并发编程和错误处理机制，培养解决实际问题的能力。 阅读建议：建议读者跟随文档内容进行实践操作，在理解和记忆的基础上多做练习，同时利用提供的学习资源加深理解。

    《基于YOLOv8的体育数据监测系统》（包含源码、完整数据集、可视化界面、部署教程）简单部署即可运行。功能完善、操作简单，适合毕设或课程设计.zip

    资源内项目源码是来自个人的毕业设计，代码都测试ok，包含源码、数据集、可视化页面和部署说明，可产生核心指标曲线图、混淆矩阵、F1分数曲线、精确率-召回率曲线、验证集预测结果、标签分布图。都是运行成功后才上传资源，毕设答辩评审绝对信服的保底85分以上，放心下载使用，拿来就能用。包含源码、数据集、可视化页面和部署说明一站式服务，拿来就能用的绝对好资源！！！ 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、大作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.txt文件，仅供学习参考, 切勿用于商业用途。

Magicbox
Global site tag (gtag.js) - Google Analytics