将 Windows IPC 应用移植到 Linux，第 1 部分: 进程和线程

CreateProcess()

CreateProcessAsUser()

fork()

setuid()

exec()

可映射

TerminateProcess()

kill()

可映射

SetThreadpriority()

GetThreadPriority()

Setpriority()

getPriority()

可映射

GetCurrentProcessID()

getpid()

可映射

Exitprocess()

exit()

可映射

Waitforsingleobject()

Waitformultipleobject()

GetExitCodeProcess()

waitpid()

Using Sys V semaphores, Waitforsingleobject/multipleobject

不能实现

与上下文相关

GetEnvironmentVariable

SetEnvironmentVariable

getenv()

setenv()

可映射

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

CreateThread

pthread_create

pthread_attr_init

pthread_attr_setstacksize

pthread_attr_destroy

可映射

ThreadExit

pthread_exit

可映射

WaitForSingleObject

pthread_join

pthread_attr_setdetachstate

pthread_detach

可映射

SetPriorityClass

SetThreadPriority

setpriority

sched_setscheduler

sched_setparam

pthread_setschedparam

pthread_setschedpolicy

pthread_attr_setschedparam

pthread_attr_setschedpolicy

与上下文相关

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, ¶m);
// Perform time critical task
...
...
// set the priority back to normal
param.sched_priority = 0;
policy = 0;             // for normal threads
pthread_setschedparam(thread_id, policy, ¶m);
....
....
pthread_exit(NULL);
}