CArray

CTypedPtrArray

CObArray

CPtrArray

CByteArray

CDWordArray

CStringArray

CUintArray

CWordArray

CTypedPtrList

CObList

CPtrList

CStringList

CMap

CTypedPtrMap

CMapWordToPtr

CMapPtrToWord

CMapPtrToPtr

CMapStringToPtr

CMapWordToOb

CMapStringToOb

CMapStringToString

BOOL CreateProcess(
 LPCTSTR lpApplicationName,                  // name of executable module
  LPTSTR lpCommandLine,                      // command line string
  LPSECURITY_ATTRIBUTES lpProcessAttributes, // SD
  LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SD
  BOOL bInheritHandles,                      // handle inheritance option
  DWORD dwCreationFlags,                     // creation flags
  LPVOID lpEnvironment,                      // new environment block
  LPCTSTR lpCurrentDirectory,                // current directory name
  LPSTARTUPINFO lpStartupInfo,               // startup information
  LPPROCESS_INFORMATION lpProcessInformation // process information
)

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int  execle(const  char  *path,  const  char  *arg  , ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

BOOL TerminateProcess(
  HANDLE hProcess, // handle to the process
  UINT uExitCode   // exit code for the process
);

DWORD WaitForMultipleObjects(
  DWORD nCount,             // number of handles in array
  CONST HANDLE *lpHandles,  // object-handle array
  BOOL bWaitAll,            // wait option
  DWORD dwMilliseconds      // time-out interval
);

VOID ExitProcess(
  UINT uExitCode   // exit code for all threads
);

DWORD GetEnvironmentVariable(
  LPCTSTR lpName,  // environment variable name
  LPTSTR lpBuffer, // buffer for variable value
  DWORD nSize      // size of buffer
);

BOOL SetEnvironmentVariable(
  LPCTSTR lpName,  // environment variable name
  LPCTSTR lpValue  // new value for variable
);

char *getenv(const char *name);
int setenv(const char *name, const char *value, int overwrite);

				
//Sample Application that explain process concepts
//Parameters Declaration/Definition
int TimetoWait;
STARTUPINFO si;
PROCESS_INFORMATION pi;
LPTSTR lpszCurrValue,LPTSTR lpszVariable;
TCHAR tchBuf[BUFSIZE];
BOOL fSuccess;
if(argc > 2)
{
    printf("InvalidArgument");
    ExitProcess(1); //Failure
}
//Get and display an  environment variable PATH
lpszCurrValue = ((GetEnvironmentVariable("PATH",tchBuf, BUFSIZE) > 0) ? tchBuf : NULL);
lpszVariable = lpszCurrValue;
//Display the environment variable
while (*lpszVariable)
    putchar(*lpszVariable++);
putchar('\n');
//Initialise si and pi
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );
//Create a childProcess
if( !CreateProcess( NULL,             // No module name (use command line).
                    "SomeProcess",    // Command line.
                    NULL,             // Process handle not inheritable.
                    NULL,             // Thread handle not inheritable.
                    FALSE,            // Set handle inheritance to FALSE.
                    0,                // No creation flags.
                    NULL,             // Use parent's environment block.
                    NULL,             // Use parent's starting directory.
                    &si,              // Pointer to STARTUPINFO structure.
                    &pi )             // Pointer to PROCESS_INFORMATION structure.
                        )
{
    printf( "CreateProcess failed." );
}
// Wait until child process exits.
if(argc == 2)
{
    TIMEOUT = atoi(argv[1]);
    ret = WaitForSingleObject( pi.hProcess, TIMEOUT );
    if(ret == WAIT_TIMEOUT)
    {
        TerminateProcess(pi.hProcess);
    }
}
else
{
    WaitForSingleObject( pi.hProcess, INFINITE );
    ...
}
    ExitProcess(0); //Success

				
#include <stdlib.h>
int main(int argc,char *argv[])
{
    //Parameters Declaration/Definition
    char PathName[255];
    char *Argptr[20];
    int rc;
    char *EnvValue,*lpszVariable;
    if(argc > 1)
    {
        printf(" Wrong parameters !!");
        exit(EXIT_FAILURE);
    }
    //Get and display an  environment variable PATH
    EnvValue = getenv("PATH");
    if(EnvValue == NULL)
    {
        printf("Invalid environment variable passed as param !!");
    }else
    {
        lpszVariable = EnvValue;
        while (*lpszVariable)
            putchar(*lpszVariable++);
        putchar('\n');
    }
    rc = fork(); //variable rc's value on success would be process ID in the parent
                 //process, and 0 in the child's thread of execution.
    switch(rc)
    {
        case -1:
            printf("Fork() function failed !!");
            ret = -1;
            break;
        case 0:
            printf("Child process...");
            setpgid(0,0);  //Change the parent grp ID to 0
        ret = execv(PathName,Argptr); // there are other flavours of exec available,
                                      // u can use any of them based on the arguments.
        if(ret == -1)
        {
            kill(getpid(),0);
        }
        break;
         default:
             // infinitely waits for child process to die
             Waitpid(rc,&status,WNOHANG);
             //Note RC will have PID returned since this is parent process.
             break;
    }
    exit(EXIT_SUCCESS);
}

HANDLE CreateThread(
  LPSECURITY_ATTRIBUTES lpThreadAttributes,     // SD
  SIZE_T dwStackSize,                           // initial stack size
  LPTHREAD_START_ROUTINE lpStartAddress,        // thread function
  LPVOID lpParameter,                           // thread argument
  DWORD dwCreationFlags,                        // creation option
  LPDWORD lpThreadId                            // thread identifier
);

int pthread_create (pthread_t *thread_id, pthread_attr_t *threadAttr,
                    void * (*start_address)(void *), void * arg);

int pthread_attr_init(pthread_attr_t *threadAttr);
int pthread_attr_destroy(pthread_attr_t *threadAttr);

VOID ExitThread(
  DWORD dwExitCode   // exit code for this thread
);

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);

BOOL SetPriorityClass(
  HANDLE hProcess,         // handle to the process
  DWORD dwPriorityClass    // Priority class
);

BOOL SetThreadPriority(
  HANDLE hThread,
  int nPriority
);

int pthread_attr_setschedpolicy(pthread attr_t *threadAttr, int policy);
int pthread_attr_setschedparam(pthread attr_t *threadAttr, const struct sched_param *param);

				
				Main Thread
enum stackSize = 120 * 1024 ;
// create a thread normal and real time thread
DWORD  normalTId, realTID;
HANDLE normalTHandle, realTHandle;
normalTHandle = CreateThread(
                NULL,            // default security attributes
                stackSize,       // 120K
                NormalThread,    // thread function
                NULL,            // argument to thread function
                0,               // use default creation flags
                &normalTId);     // returns the thread identifier
// Set the priority class as "High priority"
SetPriorityClass(pHandle, HIGH_PRIORITY_CLASS);
normalTHandle = CreateThread(
                 NULL,            // default security attributes
                 stackSize,       // 120K
                 NormalThread,    // thread function
                 NULL,            // argument to thread function
                 0,               // use default creation flags
                &normalTId);     // returns the thread identifier
CloseHandle(threadHandle);
...
...
// Thread function
DWORD WINAPI NormalThread ( LPVOID lpParam )
{
    HANDLE tHandle,pHandle;
    pHandle = GetCurrentProcess();
    tHandle = GetCurrentThread();
    // Set the priority class as "High priority"
    SetPriorityClass(pHandle, HIGH_PRIORITY_CLASS);
    // increase the priority by 2 points above the priority class
    SetThreadPriority(tHandle,THREAD_PRIORITY_HIGHEST);
    // perform job at high priority
    ...
    ...
    ...
    // Reset the priority class as "Normal"
   SetPriorityClass(pHandle, NORMAL_PRIORITY_CLASS);
    // set the priority back to normal
    SetThreadPriority(tHandle,THREAD_PRIORITY_NORMAL);
    // Exit thread
    ExitThread(0);
}
// Thread function
DWORD WINAPI RealTimeThread ( LPVOID lpParam )
{
    HANDLE tHandle, pHandle ;
    pHandle = GetCurrentProcess();
    tHandle = GetCurrentThread  ();
    // Set the priority class as "Real time"
   SetPriorityClass(pHandle, REALTIME_PRIORITY_CLASS);
    // increase the priority by 2 points above the priority class
    SetThreadPriority(tHandle,THREAD_PRIORITY_HIGHEST);
    // do time critical work
    ...
    ...
    ...
    // Reset the priority class as "Normal"
   SetPriorityClass(pHandle, NORMAL_PRIORITY_CLASS);
    // Reset the priority back to normal
    SetThreadPriority(tHandle,THREAD_PRIORITY_NORMAL);
    ExitThread(0);
}

				
static void * RegularThread (void *);
static void * CriticalThread (void *);
// Main Thread
       pthread_t thread1, thread2;  // thread identifiers
       pthread_attr_t threadAttr;
       struct sched_param param;  // scheduling priority
       // initialize the thread attribute
       pthread_attr_init(&threadAttr);
       // Set the stack size of the thread
       pthread_attr_setstacksize(&threadAttr, 120*1024);
       // Set thread to detached state. No need for pthread_join
       pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
       // Create the threads
       pthread_create(&thread1, &threadAttr, RegularThread, NULL);
       pthread_create(&thread2, &threadAttr, CriticalThread,NULL);
       // Destroy the thread attributes
       pthread_attr_destroy(&threadAttr);
       ...
       ...
  // Regular non-realtime Thread function
  static void * RegularThread (void *d)   {
       int priority = -18;
       // Increase the priority
       setpriority(PRIO_PROCESS, 0, priority);
       // perform high priority job
       ...
       ...
       // set the priority back to normal
       setpriority(PRIO_PROCESS, 0, 0);
       pthread_exit(NULL);
   }
   // Time Critical Realtime Thread function
   static void * CriticalThread (void *d) {
       // Increase the priority
        struct sched_param param;  // scheduling priority
        int policy = SCHED_RR;     // scheduling policy
        // Get the current thread id
        pthread_t thread_id = pthread_self();
        // To set the scheduling priority of the thread
        param.sched_priority = 90;
        pthread_setschedparam(thread_id, policy, &param);
        // Perform time critical task
        ...
        ...
        // set the priority back to normal
        param.sched_priority = 0;
        policy = 0;             // for normal threads
        pthread_setschedparam(thread_id, policy, &param);
        ....
        ....
        pthread_exit(NULL);
   }

Srinivasan S. Muthuswamy 是 IBM Global Services Group 的一位软件工程师。他于 2000 年加入 IBM，他所精通的编程语言涵盖了多种平台上（Linux、Windows、WebSphere、Lotus 等等）的脚本语言以及面向对象和面向过程的语言。他已经开发的解决方案包括 Linux 和 Windows 上的系统编程以及用于 J2EE 的 Web 解决方案。他在印度的 Coimbatore 国立科技大学（Government College of Technology）获得计算机工程学士学位，主要致力于集成和迁移。您可以通过 smuthusw@in.ibm.com 与他联系。

从 2000 年 12 月起，Kavitha Varadarajan 一直在 IBM India Software Lab 担任软件工程师。她的工作经验包括 host-access 客户机产品（比如 PCOMM）和网络软件（比如通信服务器）的开发与支持。Varadarajan 拥有迁移项目的实践经验，其中涉及到了面向对象 IPC Windows 应用程序向 Linux 的移植。她拥有印度的 Tanjore 山姆哈工程大学（Shanmugha College of Engineering）的计算机科学与工程硕士学位。您可以通过 vkavitha@in.ibm.com 与她联系。

HANDLE CreateSemaphore (
	LPSECURITY_ATTRIBUTES	lpSemaphoreAttributes,
	LONG			lInitialCount,
	LONG			lMaximunCount,
	LPCTSTR			lpName
); 

                    
int sem_init(sem_t *sem, int pshared, unsigned int value

                    
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);

                
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;
}

                
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;

BOOL CloseHandle (HANDLE hObject);

                
int sem_destroy(sem_t *sem);

                    
int pthread_cond_destroy(pthread_cond_t *cond);

                    
BOOL ReleaseSemaphore(
	HANDLE hSemaphore,
	LONG 	lReleaseCount,
	LPLONG	lpPreviousCount
);

                    
int sem_post(sem_t * sem);

                    
int pthread_cond_signal(pthread_cond_t *cond);

                    
DWORD WaitForSingleObject(
	HANDLE hHANDLE,
	DWORD	dwMilliseconds
);

                    
DWORD WaitForMultipleObjects(
	DWORD	nCount,
	Const	HANDLE* lpHandles,
	BOOL	bWaitAll,
	DWORD	dwMilliseconds
);

                    
int sem_wait(sem_t * sem);

                    
int sem_trywait(sem_t  * sem);

                    
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t  *mutex);

                
	int pthread_cond_timewait(
	pthread_cond_t		*cond,
	pthread_mutex_t		*mutex,
	timespec		*tm
);			

                    
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);

                
#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);
}

                
#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 );

                
#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;
}

                
#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;
}

                
#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;
}

                
#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;
}

Nam Keung 是 IBM 的一名高级程序员，他曾致力于 AIX 通信开发、AIX 多媒体、SOM/DSOM 开发和 Java 性能方面的工作。他目前的工作包括帮助独立软件提供商（Independent Software Vendors，ISV）进行应用程序设计、部署应用程序、性能调优和关于 pSeries 平台的教育。您可以通过 namkeung@us.ibm.com 与 Nam 联系。

HANDLE OpenMutex(
  DWORD dwDesiredAccess,
  BOOL bInheritHandle,
  LPCTSTR lpName
)

/* Fast */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;                    
/* Recursive */
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;    
/* Errorcheck */
pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;

int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);

BOOL CloseHandle(
  HANDLE hObject
);

HANDLE     hMutexWithNoTimeOut, hMutexWithTimeOut;
DWORD     dwRetCode;

// create a mutex
hMutexWithNoTimeOut = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

hMutexWithTimeOut = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutexWithNoTimeOut,  // Mutex handle
                                INFINITE);            // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutexWithNoTimeOut); // Mutex Handle

}

// case 2, using mutex with timeout specified.
dwRetCode = WaitForSingleObject(
                                hMutexWithTimeOut,
                                2000L); // 2 secs timeout

switch(dwRetCode) {
    case WAIT_OBJECT_0 :
        // success
        // access the shared resource
        .....

        // After using the shared resource, release the semaphore
        ReleaseMutex(hMutexWithTimeOut);
        ....

    break;

    case WAIT_TIMEOUT :
        // Handle the timeout case
        ...
    break;

    case WAIT_ABANDONED :
        // probe for abandoned mutex

    break;
}

....

// close all the mutex
CloseHandle(hMutexWithTimeout);
CloseHandle(hMutexWithNoTimeout);

#define TIMEOUT 200  // 2 Secs delay time
struct timespec delay;  // structure for providing timeout

pthread_mutexattr_t mutexattr;  // Mutex Attribute
pthread_mutex_t mutexWithNoTimeOut, mutexWithTimeOut; // Mutex variables

// Set the mutex as a recursive mutex
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);

// Create the mutex with the attributes set
pthread_mutex_init(&mutexWithNoTimeOut, &mutexattr);
pthread_mutex_init(&mutexWithTimeOut, &mutexattr);

// destroy the attribute
pthread_mutexattr_destroy(&mutexattr)


// Lock/Acquire the mutex and access the shared resource
pthread_mutex_lock (&mutexWithNoTimeOut);

// access the shared resource
 .. ...

// Unlock the mutex
pthread_mutex_unlock (&mutexWithNoTimeOut);
 ...


// Case 2, Accessing share resource with time out value specified in the
// Mutex call

while (timeout < TIMEOUT ) {

   delay.tv_sec = 0;
   delay.tv_nsec = 1000000;  // 1 milli sec delay

    // Tries to acquire the mutex and access the shared resource,
    // if success, access the shared resource,
    // if the shared reosurce already in use, it tries every 1 milli sec
    // to acquire the resource
    // if it does not acquire the mutex within 2 secs delay,
    // then it is considered to be failed

    irc = pthread_mutex_trylock(&mutexWithTimeOut);
    if (!irc)  {

        // Acquire mutex success
        // Access the shared resource


        // Unlock the mutex and release the shared resource
        pthread_mutex_unlock (&mutexWithTimeOut);


      break;
    }
    else {
        // check whether somebody else has the mutex
        if (irc == EPERM ) {
            // Yes, Resource already in use so sleep
            nanosleep(&delay, NULL);
            timeout++ ;
        }
        else{
            // Handle error condition
        }
    }
}

// Close all the mutex
pthread_mutex_destroy (&mutexWithNoTimeOut);
pthread_mutex_destroy (&mutexWithTimeOut);

// Process 1
HANDLE     hMutex;
DWORD     dwRetCode;

// create a mutex
hMutex = CreateMutex(
                     NULL,  // no security attriutes
                     FALSE, // initially not owned
                     NULL); // un named mutex so NULL

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutex,  // Mutex handle
                                INFINITE);  // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutex); // Mutex Handle

}


// close the mutex
CloseHandle(hMutex);

// Process 2
HANDLE     hMutex;
DWORD     dwRetCode;

// Open the mutex created by the Process 1
hMutex = OpenMutex(
                   NULL,        // no security attriutes
                   NULL,        // handle cannot be inhereited
                   "testMuex"); // named mutex

// acquire a mutex
dwRetCode = WaitForSingleObject(
                                hMutex,     // Mutex handle
                                INFINITE);  // Infinite wait

if (dwRetCode == WAIT_OBJECT_0) {

    // success
    // access the shared resource
    .....

   // release mutex
   ReleaseMutex(hMutex); // Mutex Handle

}


// close the mutex
CloseHandle(hMutex);

// Process 1
#define TIMEOUT 200



int main()
{
    //Definition of variables
    key_t key;
    int semid;
    int Ret;
    int timeout = 0;
    struct sembuf operation[1] ;

    union semun
    {
        int val;
        struct semid_ds *buf;
        USHORT *array;
    } semctl_arg,ignored_argument;


    key = ftok(); //Generate a unique key or supply a value

    semid = semget(key, // a unique identifier to identify semaphore set
             1,  // number of semaphore in the semaphore set
        0666 | IPC_CREAT // permissions (rwxrwxrwx) on the new
                 //semaphore set and creation flag
                    );
    if(semid < 0)
    {
        printf("Create semaphore set failed ");
        Exit(1);
    }

    //Set Initial value for the resource
    semctl_arg.val = 1; //Setting semval to 1

    semctl(semid, 0, SETVAL, semctl_arg);


    //Wait for Zero

    while(timeout < TIMEOUT)
    {
        delay.tv_sec = 0;
        delay.tv_nsec = 1000000;  /* 1 milli sec */

        //Call Wait for Zero with IPC_NOWAIT option,so it will be
        // non blocking

        operation[0].sem_op = -1; //Wait
        operation[0].sem_num = subset;
        operation[0].sem_flg = IPC_NOWAIT;

        ret = semop(semid, operation,1);
        if(ret < 0)
        {
            /* check whether somebody else has the mutex */
            if (retCode == EPERM )
            {
                /* sleep for delay time */
                nanosleep(&delay, NULL);
                timeout++ ;
            }
            else
            {
                printf("ERROR while wait ");
                break;
            }
        }
        else
        {
            /*semaphore got triggered */
            break;
        }

    }

    //Close semaphore
    iRc = semctl(semid, 1, IPC_RMID , ignored_argument);

}

// Process 2
int main()
{
    int key = 0x20;   //Process 2 shd know key value in order to open the
                     // existing semaphore set
    struct sembuf operation[1] ;

    //Open semaphore
    semid = semget(key, 1, 0);

    operation[0].sem_op = 1; //Release the resource so Wait in process
                             // 1 will be triggered
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore
    semop(semid, operation,1);
}

void InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

BOOL InitializeCriticalSectionAndSpinCount(
  LPCRITICAL_SECTION lpCriticalSection,
  DWORD dwSpinCount
)

void EnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
);

BOOL TryEnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

void DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
)

CRITICAL_SECTION csCriticalSection;

// Initialize a Critical Section
InitializeCriticalSection(
            &csCriticalSection); // Critical Section Object

// Enter a critical Section
EnterCriticalSection(
            &csCriticalSection); // Critical Section Object

// Access a shared resource



// Leave a Critical Section
LeaveCriticalSection(
            &csCriticalSection); // Critical Section Object


// Delete a Critical Section
DeleteCriticalSection(
            &csCriticalSection); // Critical Section Object

pthread_mutex_t mutex;           // Mutex
pthread_mutexattr_t mutexattr;   // Mutex attribute variable

// Set the mutex as a recursive mutex
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);

// create the mutex with the attributes set
pthread_mutex_init(&mutex, &mutexattr);

//After initializing the mutex, the thread attribute can be destroyed
pthread_mutexattr_destroy(&mutexattr)


// Acquire the mutex to access the shared resource
pthread_mutex_lock (&mutex);

// access the shared resource
 ..

// Release the mutex  and release the access to shared resource
pthread_mutex_unlock (&mutex);
 ...

// Destroy / close the mutex
irc = pthread_mutex_destroy (&mutex);

DWORD SignalObjectAndWait(
  HANDLE hObjectToSignal,
  HANDLE hObjectToWaitOn,
  DWORD dwMilliseconds,
  BOOL bAlertable
)

// Main thread
HANDLE hEventOne; // Global Variable
HANDLE hEventTwo; // Global Variable


// Thread 1
DWORD  dwRetCode;

// Create Event One
hEventOne = CreateEvent(
                     NULL,   // no security attributes
                     TRUE,   // Auto reset event
                     FALSE,  // initially set to non signaled state
                     NULL);  // un named event

// Create Event Two
hEventTwo = CreateEvent(
                     NULL,   // no security attributes
                     TRUE,   // Auto reset event
                     FALSE,  // initially set to non signaled state
                     NULL);  // un named event

// Signal hEventOne and Wait for the hEventTwo to be signaled
dwRetCode = SignalObjectAndWait(
                           hEventOne, // Object to be signaled
                           hEventTwo, // Object to wait on
                           INFINITE,  // Infinite wait
                           FALSE);    // Not alertable

  switch(dwRetCode) {
          case WAIT_OBJECT_O :
                   // Event is signaled
                   // go ahead and proceed the work


         default :
                   // Probe for error
  }




// Completed the job,
// now close the event handle
CloseHandle(hEventOne);
CloseHandle(hEventTwo);


// Thread 2
// Condition met for the event hEventTwo
// now set the event
SetEvent(
         hEventTwo);    // Event Handle

// Main thread
int key = 0x20;  // Semaphore key

// Thread 1
    struct sembuf operation[2] ;

    // Create 2 semaphores
    semid = semget(key, 2, 0666 | IPC_CREAT);


    operation[0].sem_op  = 1; //Release first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    operation[0].sem_op  = -1; // Wait on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 1 and wait on semaphore 2
    // note : thread is suspended until the semaphore 2 is released.
    semop(semid, operation, 2);

    // thread is released
    // delete the semaphore
    semctl(semid, 0, IPC_RMID , 0)


// Thread 2
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 2
    semop(semid, operation, 1);

DWORD WaitForMultipleObjects(
  DWORD nCount,
  const HANDLE* lpHandles,
  BOOL bWaitAll,
  DWORD dwMilliseconds
)

HANDLE     hEvents[2];
DWORD     i, dwRetCode;

// Create two event objects.

for (i = 0; i < 2; i++)
{
    hEvents[i] = CreateEvent(
        NULL,   // no security attributes
        FALSE,  // auto-reset event object
        FALSE,  // initial state is nonsignaled
        NULL);  // unnamed object

}

// The creating thread waits for other threads or processes
// to signal the event objects.

dwRetCode  = WaitForMultipleObjects(
                       2,           // number of objects in array
                       hEvents,     // array of objects
                       FALSE,       // wait for any
                       INFINITE);   // indefinite wait

// Return value indicates which event is signaled.

switch (dwEvent)
{
    // hEvent[0] was signaled.
    case WAIT_OBJECT_0 + 0:
        // Perform tasks required by this event.
        break;

    // hEvent[1] was signaled.
    case WAIT_OBJECT_0 + 1:
        // Perform tasks required by this event.
        break;

    // Return value is invalid.
    default:
        // probe for error
}

// Semaphore
sem_t semOne  ;
sem_t semTwo  ;
sem_t semMain ;

// Main thread
sem_init(semOne,0,0) ;
sem_init(semTwo,0,0) ;
sem_init(semMain,0,0) ;

// create 2 threads each one waits on one semaphore
// if signaled signals the main semaphore

sem_wait(&semMain);


// Thread 1
sem_wait(&semOne);
sem_post(&semMain);


// Thread 2
sem_wait(&semTwo);
sem_post(&semMain);

HANDLE     hEvents[2];
DWORD     i, dwRetCode;

// Create two event objects.

for (i = 0; i < 2; i++)
{
    hEvents[i] = CreateEvent(
        NULL,   // no security attributes
        FALSE,  // auto-reset event object
        FALSE,  // initial state is nonsignaled
        NULL);  // unnamed object

}

// The creating thread waits for other threads or processes
// to signal the event objects.

dwRetCode  = WaitForMultipleObjects(
  2,           // number of objects in array
  hEvents,     // array of objects
  TRUE,        // wait for both the objects to be signaled
  INFINITE);   // indefinite wait

// Return value indicates which event is signaled.

switch (dwEvent)
{
    // hEvent[0] and hEvent[1] were signaled.
    case WAIT_OBJECT_0 :
        // Perform tasks required by this event.

        break;

    // Return value is invalid.
    default:
        // probe for error
}

// Semaphore
sem_t semOne  ;
sem_t semTwo  ;
sem_t semMain ;
pthread_mutex_t mutMain = PTHREAD_MUTEX_INITIALIZER;

// Main thread
sem_init(semOne,0,0) ;
sem_init(semTwo,0,0) ;
sem_init(semMain,0,0) ;

// create 2 threads each one waits on one semaphore
// if signaled signals the main semaphore

sem_wait(&semMain);


// Thread 1
sem_wait(&semOne);

// lock the Mutex
pthread_mutex_lock(&mutMain);
count ++;
if(count == 2) {
     // semaphore semTwo is already signaled
     // so post the main semaphore
     sem_post(&semMain);
}
pthread_mutex_unlock(&mutMain);


// Thread 2
sem_wait(&semTwo);
// lock the Mutex
pthread_mutex_lock(&mutMain);
count ++;
if(count == 2) {
     // semaphore semOne is already signaled
     // so post the main semaphore
     sem_post(&semMain);
}
pthread_mutex_unlock(&mutMain);
 

// Main thread
int key = 0x20;  // Semaphore key

// Thread 1
    struct sembuf operation[2] ;

    // Create 2 semaphores
    semid = semget(key, 2, 0666 | IPC_CREAT);


    operation[0].sem_op  = -1; // Wait on first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    operation[0].sem_op  = -1; // Wait on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    // Wait on both the semaphores
    // Note : thread is suspended until both the semaphores are released.
    semop(semid, operation, 2);

    // thread is released
    // delete the semaphore
    semctl(semid, 0, IPC_RMID , 0)


// Thread 2
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the second resource
    operation[0].sem_num = 1;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 2
    semop(semid, operation, 1);

// Thread 3
    struct sembuf operation[1] ;

    // open semaphore
    mysemid = semget(key, 2, 0);

    operation[0].sem_op  = 1; // Release on the first resource
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;

    //Release semaphore 1
    semop(semid, operation, 1);
 

Srinivasan S. Muthuswamy works as a Software Engineer for IBM Global Services Group. He joined IBM in 2000, and his expertise in programming reaches from scripting languages to object- and procedure-oriented languages on multiple platforms (Linux, Windows, WebSphere, Lotus, and so on). Muthuswamy has developed solutions ranging from system programming on Linux and Windows to Web solutions for J2EE. His primary focus is on integration and porting, and he holds a B.Eng. in Computer Engineering from the Government College of Technology, Coimbatore, India. You can contact him at <a href="mailto:smuthusw@in.ibm.com">smuthusw@in.ibm.com</a>.

Kavitha Varadarajan has worked as a software Engineer in the IBM India Software Lab from December 2000. Her work experience involves development and support of host-access client products such as PCOMM and networking software like the communication server. Varadarajan has experience with a migration project that involves porting object-oriented IPC Windows applications to Linux. She holds a B.Eng. in Computer Science and Engineering from Shanmugha College of Engineering, Tanjore, India. She can be contacted at <a href="mailto:vkavitha@in.ibm.com">vkavitha@in.ibm.com</a>.

void __attribute__ ((constructor)) app_init(void);
void __attribute__ ((destructor)) app_fini(void);

				Win32 sample
_DLL_InitTerm(HMODULE modhandle, DWORD fdwReason, LPVOID lpvReserved)
{	
    WSADATA			Data;	
    switch (fdwReason)	
    {		
        case DLL_PROCESS_ATTACH:		
        if (_CRT_init() == -1)			
           return 0L;               
          /* start with initialization code */		
          app_init();		
          break;	
    case DLL_PROCESS_DETACH:		
         /* Start with termination code*/               
         app_fini();		
         _CRT_term();		
         break;      
    …..	
    default:		
          /* unexpected flag value - return error indication */		
            return 0UL;	
    }	return 1UL;		/* success */
}
      

				Win32 example
PROCESS_INFORMATION    procInfo;
STARTUPINFO	        startupInfo;
typedef DWORD          processId;
char                   *exec_path_name
char                   *_cmd_line;
        GetStartupInfo( &startupInfo );     // You must fill in this structure
if( CreateProcess( exec_path_name,  // specify the executable program
                       _cmd_line,   // the command line arguments
                       NULL,       // ignored in Linux
                       NULL,       // ignored in Linux
                       TRUE,       // ignored in Linux
                       DETACHED_PROCESS | HIGH_PRIORITY_CLASS,
                       NULL,       // ignored in Linux
                       NULL,       // ignored in Linux
               &startupInfo,
                    &procInfo))
        *processId = procInfo.dwProcessId;
else
{
        *processId = 0;
          return RC_PROCESS_NOT_CREATED;
}	
      

				Equivalent Linux code
#include <stdlib.h>
#include <stdio.h>
int    processId;
char  *exec_path_name;
char  *	cmd_line ;
cmd_line = (char *) malloc(strlen(_cmd_line ) + 1 );
if(cmd_line == NULL)
         return RC_NOT_ENOUGH_MEMORY;
         	
strcpy(cmd_line, _cmd_line);
if( ( *processId = 
        fork() ) == 0 )		// Create child
 {	
         char		*pArg, *pPtr;
         char		*argv[WR_MAX_ARG + 1];
         int		 argc;
         if( ( pArg = strrchr( exec_path_name, '/' ) ) != NULL )
                pArg++;
         else
                pArg = exec_path_name;
         argv[0] = pArg;
         argc = 1;
         
         if( cmd_line != NULL && *cmd_line != '\0' )
         {
                  
               pArg = strtok_r(cmd_line, " ", &pPtr);
               
               while( pArg != NULL )
               {
                              argv[argc] = pArg;
                              argc++;
                              if( argc >= WR_MAX_ARG )
                              break;
                              pArg = strtok_r(NULL, " ", &pPtr);
                }
         }
         argv[argc] = NULL;
         
         execv(exec_path_name, argv);
         free(cmd_line);
         exit( -1 );
}
else if( *processId == -1 )
{
           *processId = 0;
           free(cmd_line);
           return RC_PROCESS_NOT_CREATED;
}
      

				Win32 sample code
if( thread != (HANDLE) NULL )
{
    HANDLE	thread_dup;
    if( DuplicateHandle( OpenProcess(PROCESS_ALL_ACCESS, TRUE,  processId),
                                     thread,
                                     GetCurrentProcess(),
                                     &thread_dup,  //Output
                                     0,
                                     FALSE,
                                     DUPLICATE_SAME_ACCESS ))
      {
            TerminateThread( thread_dup, 0);
       }
}
TerminateProcess(
        OpenProcess(PROCESS_ALL_ACCESS, TRUE, 
        processId), 
   (UINT)0 );
      

				Equivalent  Linux code
pid_t	nRet;
int	status;
kill( processId, SIGTERM );
nRet = waitpid( processId, &status, WNOHANG);  //Check specified
   process is terminated
      

				Win 32 sample
HANDLE      nProc;
DWORD       dwExitCode;
nProc = OpenProcess(PROCESS_ALL_ACCESS, TRUE, processId);
if ( nProc != NULL)
{
     GetExitCodeProcess( nProc, &dwExitCode );
     if (dwExitCode == STILL_ACTIVE )
            return RC_PROCESS_EXIST;
     else
            return RC_PROCESS_NOT_EXIST;
}
else
     return RC_PROCESS_NOT_EXIST;
      

				Equivalent Linux code
if ( kill ( processId, 0 ) == -1 && errno == ESRCH ) // No process can 
                                       be found
                             // corresponding to processId
         return RC_PROCESS_NOT_EXIST;
else
        return RC_PROCESS_EXIST;
      

				Win32 sample
int		hThrd;
DWORD          dwIDThread;
unsigned       stacksize;
void           *thrdparam; //parameter to be passed to the thread when it 
                                  //begins execution
HANDLE         *threadId;
if( stacksize < 8192 )
     stacksize = 8192;
else
     stacksize = (stacksize/4096+1)*4096;
     
     hThrd = _beginthread( thrdproc,    // Definition of a thread entry 
                                                                  //point
                                NULL,
                                stacksize,
                                thrdparam);
if (hThrd == -1)
     return RC_THREAD_NOT_CREATED);
     *threadId = (HANDLE) hThrd;
__________________________________________________________________     
                          
        Equivalent Linux code
                                                            
#include <pthread.h>
pthread_t   *threadId;
void         thrdproc  (void *data);  //the thread procedure (function) to 
                                               //be executed. 
                      //It receives a single void parameter
void        *thrdparam; //parameter to be passed to the thread when it 
                               //begins execution
pthread_attr_t  attr;
int             rc = 0;
if (thrdproc == NULL || threadId == NULL)
     	return RC_INVALID_PARAM);
     	
if (rc = pthread_attr_init(&attr))	
     return RC_THREAD_NOT_CREATED);  // EINVAL, ENOMEM
      
if (rc = pthread_attr_setstacksize(&attr, stacksize))
     return RC_THREAD_NOT_CREATED);   // EINVAL, ENOSYS
     
if (rc = pthread_create(threadId, &attr, (void*(*)(void*))thrdproc, 
   thrdparam))
     return RC_THREAD_NOT_CREATED);      // EINVAL, EAGAIN
      

echo 524288000 > /proc/sys/kernel/shmmax

				Win32 sample code
typedef struct
 {
   // This receives a pointer within the current process at which the 
   // shared memory is located.
   // The same shared memory may reside at different addresses in other
   // processes which share it.
       void *	location;
       HANDLE	hFileMapping;
}mem_shared_struct, *mem_shared, *token;
mem_shared_struct   *token;
if ((*token = (mem_shared) malloc(sizeof(mem_shared_struct))) == NULL)     
     return RC_NOT_ENOUGH_MEMORY;
     
if (newmode == new_shared_create)
   (*token)->hFileMapping = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL,
                 PAGE_READWRITE,
                 0,
                (DWORD) size,
                 (LPSTR) name);
 else
      (*token)->hFileMapping = OpenFileMapping(FILE_MAP_ALL_ACCESS,
                 FALSE,
                 (LPSTR) name);
if ((*token)->hFileMapping == NULL)
{
      free( *token );
      return RC_SHM_NOT_CREATED );
}
(*token)->location = MapViewOfFile((*token)->hFileMapping,
                                      FILE_MAP_READ | FILE_MAP_WRITE, 
                                      0, 0, 0);
if ((*token)->location == NULL)
{
      CloseHandle((*token)->hFileMapping);
            free(*token);
            return RC_OBJECT_NOT_CREATED;
}
____________________________________________________________________
                     
        Equivalent Linux code
                                  
typedef struct
{    	
      void    *location;
      int	 nFileDes;	
      cs_size	 nSize;	
      char	 *pFileName;
}mem_shared_struct, *mem_shared, token;
mode_t	mode=0;
int	flag=0;
int	i, ch='\0';
char   name_buff[128];
if (newmode == new_shared_create)
                  flag = O_CREAT;
else if (newmode != new_shared_attach)	
                  return RC_INVALID_PARAM;
                  
if ((*token = (mem_shared) malloc(sizeof(mem_shared_struct))) == NULL)
               return RC_NOT_ENOUGH_MEMORY;
               
strcpy(name_buff, "/tmp/" );
strcat(name_buff, name );
if(((*token)->pFileName = malloc(strlen(name_buff)+1)) == NULL )
{     
      free(*token);
      return RC_NOT_ENOUGH_MEMORY;
}
mode |= S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
flag |= O_RDWR;
if(newmode == new_shared_create)    
      remove(name_buff);
      
if(((*token)->nFileDes = open(name_buff, flag, mode)) < 0)
{    
      free((*token)->pFileName);
      free(*token);
      return RC_OBJECT_NOT_CREATED;
}
if(newmode == new_shared_create)
{    
      lseek((*token)->nFileDes, size - 1, SEEK_SET);
      write((*token)->nFileDes, &ch, 1);
}
if(lseek((*token)->nFileDes, 0, SEEK_END) < size)
{	
         free((*token)->pFileName);
         free(*token);
         return RC_MEMSIZE_ERROR;
}
(*token)->location = mmap( 0, size,
                  PROT_READ | PROT_WRITE,
                  MAP_VARIABLE | MAP_SHARED, 
                      (*token)->nFileDes,
                                  0);
                                  
if((int)((*token)->location) == -1)
{   
       free((*token)->pFileName);
       free(*token);    
       return RC_OBJECT_NOT_CREATED;
}
(*token)->nSize = size;strcpy((*token)->pFileName, name_buff);
      

Nam Keung 是一名高级程序员，他曾致力于 AIX 通信开发、AIX 多媒体、SOM/DSOM 开发和 Java 性能方面的工作。他目前的工作包括帮助 ISV 进行应用程序设计、部署应用程序、性能调优和关于 pSeries 平台的教育。他从 1987 年起就是 IBM 的程序员了。您可以通过 namkeung@us.ibm.com 与 Nam 联系。

Chakarat Skawratananond 是 IBM eServer Solutions Enablement 组织的一名技术顾问，在那里，他帮助独立软件开发商在 IBM pSeries 平台上使用他们的用于 AIX 5L 和 Linux 的应用程序。您可以通过 chakarat@us.ibm.com 与他联系。

HANDLE CreateSemaphore(
  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  LONG lInitialCount,
  LONG lMaximumCount,
  LPCTSTR lpName
);

HANDLE OpenSemaphore(
  DWORD dwDesiredAccess,
  BOOL bInheritHandle,
  LPCTSTR lpName
)

BOOL ReleaseSemaphore(
  HANDLE hSemaphore,
  LONG lReleaseCount,
  LPLONG lpPreviousCount
);

BOOL CloseHandle(
  HANDLE hObject
);

				
HANDLE hSemaphore;
LONG   lCountMax = 10;
LONG   lPrevCount;
DWORD  dwRetCode;
// Create a semaphore with initial and max. counts of 10.
hSemaphore = CreateSemaphore(
                      NULL,        // no security attributes
                      0,           // initial count
                      lCountMax,   // maximum count
                      NULL);       // unnamed semaphore
// Try to enter the semaphore gate.
dwRetCode = WaitForSingleObject(
                   hSemaphore,  // handle to semaphore
                   2000L);   // zero-second time-out interval
switch (dwRetCode)
{
    // The semaphore object was signaled.
    case WAIT_OBJECT_0:
        // Semaphore is signaled
        // go ahead and continue the work
        goto success:
        break;
    case WAIT_TIMEOUT:
        // Handle the time out case
        break;
}
Success:
// Job done, release the semaphore
ReleaseSemaphore(
        hSemaphore,  // handle to semaphore
        1,           // increase count by one
        NULL)        // not interested in previous count
// Close the semaphore handle
CloseHandle(hSemaphore);

				
				// Main thread
#define TIMEOUT 200  /* 2 secs */
// Thread 1
sem_t sem     ; // Global Variable
int   retCode ;
// Initialize event semaphore
retCode = sem_init(
                   sem,   // handle to the event semaphore
                   0,     // not shared
                   0);    // initially set to non signaled state
while (timeout < TIMEOUT ) {
   delay.tv_sec = 0;
   delay.tv_nsec = 1000000;  /* 1 milli sec */
   // Wait for the event be signaled
   retCode = sem_trywait(
                   &sem); // event semaphore handle
                          // non blocking call
   if (!retCode)  {
        /* Event is signaled */
        break;
   }
   else {
       /* check whether somebody else has the mutex */
       if (retCode == EPERM ) {
            /* sleep for delay time */
            nanosleep(&delay, NULL);
            timeout++ ;
       }
       else{
           /* error  */
       }
   }
}
// Completed the job,
// now destroy the event semaphore
retCode = sem_destroy(
                      &sem);   // Event semaphore handle
// Thread 2
// Condition met
// now signal the event semaphore
sem_post(
         &sem);    // Event semaphore Handle
 

				
				// Process 1
#define TIMEOUT 200
//Definition of variables
    key_t key;
    int semid;
    int Ret;
    int timeout = 0;
    struct sembuf operation[1] ;
    union semun
    {
        int val;
        struct semid_ds *buf;
        USHORT *array;
    } semctl_arg,ignored_argument;
    key = ftok(); // Generate a unique key, U can also supply a value instead
    semid = semget(key,             // a unique identifier to identify semaphore set
                    1,              // number of semaphore in the semaphore set
                   0666 | IPC_CREAT // permissions (rwxrwxrwx) on the new
                                    //    semaphore set and creation flag
                    );
   //Set Initial value for the resource
    semctl_arg.val = 0; //Setting semval to 0
    semctl(semid, 0, SETVAL, semctl_arg);
    //Wait for Zero
    while(timeout < TIMEOUT)
    {
        delay.tv_sec = 0;
        delay.tv_nsec = 1000000;  /* 1 milli sec */
        //Call Wait for Zero with IPC_NOWAIT option,so it will be non blocking
        operation[0].sem_op = -1; // Wait until the semaphore count becomes 0
        operation[0].sem_num = 0;
        operation[0].sem_flg = IPC_NOWAIT;
        ret = semop(semid, operation,1);
        if(ret < 0)
        {
            /* check whether somebody else has the mutex */
            if (retCode == EPERM )
            {
                /* sleep for delay time */
                nanosleep(&delay, NULL);
                timeout++ ;
            }
            else
            {
                printf("ERROR while wait ");
                break;
            }
        }
        else
        {
            /*semaphore got triggered */
            break;
        }
    }
    //Close semaphore
    iRc = semctl(semid, 1, IPC_RMID , ignored_argument);
}
// Process 2
key_t key = KEY; // Process 2 should know key value in order to open the
                 //    existing semaphore set
    struct sembuf operation[1] ;
    //Open semaphore
    semid = semget(key, 1, 0);
    operation[0].sem_op = 1; // Release the resource so Wait in process 1 will
                             //    be triggered
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;
    //Release semaphore
    semop(semid, operation,0);
}
 

HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes,
  BOOL bManualReset,
  BOOL bInitialState,
  LPCTSTR lpName
)

HANDLE OpenEvent(
  DWORD dwDesiredAccess,
  BOOL bInheritHandle,
  LPCTSTR lpName
)

int pthread_condattr_init(pthread_condattr_t *attr)
int pthread_condattr_destroy(pthread_condattr_t *attr)

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);

BOOL SetEvent(
  HANDLE hEvent
)

int pthread_cond_signal(pthread_cond_t *cond)
int pthread_cond_broadcast(pthread_cond_t *cond)

BOOL ResetEvent(
  HANDLE hEvent
);

BOOL CloseHandle(
  HANDLE hObject
);

int sem_destroy(sem_t *sem)
int pthread_cond_destroy(pthread_cond_t *cond)

				
				// Main thread
HANDLE hEvent; // Global Variable
// Thread 1
DWORD  dwRetCode;
// Create Event
hEvent = CreateEvent(
                     NULL,    // no security attributes
                     FALSE,   // Auto reset event
                     FALSE,   // initially set to non signaled state
                     NULL);   // un named event
// Wait for the event be signaled
dwRetCode = WaitForSingleObject(
                                hEvent,    // Mutex handle
                              INFINITE);   // Infinite wait
switch(dwRetCode) {
          case WAIT_OBJECT_O :
                 // Event is signaled
                 // go ahead and proceed the work
         default :
                   // Probe for error
}
// Completed the job,
// now close the event handle
CloseHandle(hEvent);
// Thread 2
// Condition met for the event hEvent
// now set the event
SetEvent(
         hEvent);    // Event Handle

				
				// Main thread
sem_t sem     ; // Global Variable
// Thread 1
int   retCode ;
// Initialize event semaphore
retCode = sem_init(
                   sem,   // handle to the event semaphore
                   0,     // not shared
                   0);    // initially set to non signaled state
// Wait for the event be signaled
retCode = sem_wait(
                   &sem); // event semaphore handle
                          // Indefinite wait
// Event Signaled
// a head and proceed the work
// Completed the job,
// now destroy the event semaphore
retCode = sem_destroy(
                      &sem);   // Event semaphore handle
// Thread 2
// Condition met
// now signal the event semaphore
sem_post(
         &sem);    // Event semaphore Handle

				
				// Main thread
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;
// Thread 1
 ...
pthread_mutex_lock(&mutex);
// signal one thread to wake up
pthread_cond_signal(&condvar);
pthread_mutex_unlock(&mutex);
// this signal is lost as no one is waiting
// Thread 1 now tries to take the mutex lock
// to send the signal but gets blocked
     ...
    pthread_mutex_lock(&mutex);
// Thread 1 now gets the lock and can
// signal thread 2 to wake up
      pthread_cond_signal(&condvar);
      pthread_mutex_unlock(&mutex);
// Thread 2
pthread_mutex_lock(&mutex);
pthread_cond_wait(&condvar, &mutex);
pthread_mutex_unlock(&mutex);
// Thread 2 blocks indefinitely
// One way of avoiding losing the signal is as follows
// In Thread 2 - Lock the mutex early to avoid losing signal
pthread_mutex_lock (&mutex);
// Do work
.......
// This work may lead other threads to send signal to thread 2
// Thread 2 waits for indefinitely for the signal to be posted
pthread_cond_wait (&condvar, &Mutex );
// Thread 2 unblocks upon receipt of signal
pthread_mutex_unlock (&mutex);

				
				// Process 1
DWORD  dwRetCode;
HANDLE hEvent; // Local variable
// Create Event
hEvent = CreateEvent(
                     NULL,        // no security attributes
                     FALSE,       // Auto reset event
                     FALSE,       // initially set to non signaled state
                     "myEvent");  // un named event
// Wait for the event be signaled
dwRetCode = WaitForSingleObject(
                                hEvent,    // Mutex handle
                              INFINITE);   // Infinite wait
switch(dwRetCode) {
          case WAIT_OBJECT_O :
                 // Event is signaled
                 // go ahead and proceed the work
         default :
                   // Probe for error
}
// Completed the job,
// now close the event handle
CloseHandle(hEvent);
// Process 2
HANDLE hEvent; // Local variable
// Open the Event
hEvent = CreateEvent(
                     NULL,        // no security attributes
                     FALSE,       // do not inherit handle
                     "myEvent");  // un named event
// Condition met for the event hEvent
// now set the event
SetEvent(
         hEvent);    // Event Handle
// completed the job, now close the event handle
CloseHandle(hEvent);

				
				// Process 1
int main()
{
    //Definition of variables
    key_t key;
    int semid;
    int Ret;
    int timeout = 0;
    struct sembuf operation[1] ;
    union semun
    {
        int val;
        struct semid_ds *buf;
        USHORT *array;
    } semctl_arg,ignored_argument;
    key = ftok(); /Generate a unique key, U can also supply a value instead
    semid = semget(key,                // a unique identifier to identify semaphore set
                     1,                // number of semaphore in the semaphore set
                     0666 | IPC_CREAT  // permissions (rwxrwxrwx) on the new
                                       //     semaphore set and creation flag
                    );
    if(semid < 0)
    {
        printf("Create semaphore set failed ");
        Exit(1);
    }
    //Set Initial value for the resource - initially not owned
    semctl_arg.val = 0; //Setting semval to 0
    semctl(semid, 0, SETVAL, semctl_arg);
    // wait on the semaphore
    // blocked until it is signaled
    operation[0].sem_op = -1;
    operation[0].sem_num = 0;
    operation[0].sem_flg = IPC_WAIT;
    ret = semop(semid, operation,1);
    // access the shared resource
    ...
    ...
    //Close semaphore
    iRc = semctl(semid, 1, IPC_RMID , ignored_argument);
}
// Process 2
int main()
{
    key_t key = KEY; //Process 2 shd know key value in order to open the
                // existing semaphore set
    struct sembuf operation[1] ;
    //Open semaphore
    semid = semget(key, 1, 0);
    // signal the semaphore by incrementing the semaphore count
    operation[0].sem_op = 1;
    operation[0].sem_num = 0;
    operation[0].sem_flg = SEM_UNDO;
    semop(semid, operation,0);
}