如何给运行中的进程传递命令行参数？

例如我有一个程序AAA.exe 
这时由B进程来调用AAA.exe 带参数-XXX， AAA -XXX;
如果AAA还没有启动，就会启动进程AAA，参数XXX也会传进去。

但是如果再次调用AAA -YYY，也就是AAA已启动过了，还在运行中。再次调用，如何让AAA进程知道有进程再次调用它，并获得传入的参数－YYY？

14 个解决方案

#1

可以这样处理。
如果程序AAA.EXE启动了，可以让B给AAA发送消息（PostMessage或SendMessage）
在AAA.exe中接到这个消息并处理就可以了。

#2

因为B程序可能会是多个，或是别人的程序，所以最好还是以一样的命令行参数的方式调用

#3

那先让之前的A退出，用当前的命令行运行一个新的A呢？

#4

我现在是要解决这个问题，不是绕开这个问题

#5

引用 2 楼 fastxyf 的回复:

因为B程序可能会是多个，或是 别人的程序，所以最好还是以一样的命令行参数的方式调用

楼主，你觉得有可能实现么？
没可能就要想办法绕开。

#6

我有一个办法，但不确实是最好的：

建立一个带命名的同步对象S，创建 AAA 进程的时候尝试对 S 加锁，如果可以，就继续运行；如果不行，则说明已经有AAA进程的一个实例存在，这时尝试往已存在的AAA进程发送消息，将命令行参数附着在消息参数里面，自己退出。
这样就可以保证AAA进程的在系统中只有一个实例，每次尝试起新的进程只会向第一个创建的进程发送消息，告诉它新的命令行参数。

这个消息传递接收机制可以用不同的 IPC 机制去实现（比如 SOCKET 或者是对进程中的 UI 线程发送消息），关键看你的应用程序的运行方式是如何设计的。

此外，还要考虑 如何在所有 AAA 进程的实例之间共享一块存储空间，保存一个用于接收消息的目标句柄，这个可以用 File Mapping 实现。

#7

引用 6 楼 BenjaminHuang 的回复:

我有一个办法，但不确实是最好的： 

建立一个带命名的同步对象S，创建 AAA 进程的时候尝试对 S 加锁，如果可以，就继续运行；如果不行，则说明已经有AAA进程的一个实例存在，这时尝试往已存在的AAA进程发送消息，将命令行参数附着在消息参数里面，自己退出。 
这样就可以保证AAA进程的在系统中只有一个实例，每次尝试起新的进程只会向第一个创建的进程发送消息，告诉它新的命令行参数。 

这个消息传递接收机制可以用不同的 IPC…

有点意思

#8

操作系统是如何知道一个程序已经有实例在运行的？我想也许从这方面入手看有没有可能解决问题。

如果一定要B程序，要专门的操作去实现，就会失去了通用性，那我的应用就没有意议了。

#9

据我所知，操作系统是不会自动地去判断程序是否已经有运行的实例的，每次通过 shell 去单击可执行文件的时候，默认都是创建新的进程。
为了保证程序实例的唯一性，一定要通过同步对象。

#10

在函数入口处 使用FindWindow每次都判断AAA是否已运行，

#11

引用 9 楼 BenjaminHuang 的回复:

据我所知，操作系统是不会自动地去判断程序是否已经有运行的实例的，每次通过 shell 去单击可执行文件的时候，默认都是创建新的进程。 
为了保证程序实例的唯一性，一定要通过同步对象。

我没有做任何判断，但是实例都是唯一的。好像是随便写一个程序都是这样的

#12

前一段时间,搞过这样的问题
AAA.exe这个程序是你自己的吧?
在WM上一般情况下写一个程序,都会在进入WINMAIN之后会判断是否已经有一个实例了,如果有就会退出.
把这个逻辑改一下,进入WINMAIN后先判断是否已存在一个实例,如果不存在,正常执行,如果存在,则需要与已存在的实例进程进行通信,把参数传过去进行处理,然后退出.
这样其它程序调用AAA时,比如都createprocess(AAA,-XXX...) 就可以了
关键是AAA的两个实例进程之间的通信，要控制好。可以通过内存映射文件或消息对列实现。

#13

呵呵，我之前确实没有留意到这个细节，你可以看一下用向导创建的工程代码。

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    ...
    hWnd = FindWindow(szWindowClass, szTitle);
    if (hWnd) 
    {
        // set focus to foremost child window
        // The "| 0x00000001" is used to bring any owned windows to the foreground and
        // activate them.
        SetForegroundWindow((HWND)((ULONG) hWnd | 0x00000001));
        return 0;
    }
    ...
}

这个行为是可以控制的，IPC 的行为，在 SetForeGroundWindow 之后做就可以了。

#14

使用管道对命令行程序AAA.exe  进行标准输入、输出重定向
#include <windows.h> 
#include <tchar.h>
#include <stdio.h> 
//#include <strsafe.h>

#define BUFSIZE 4096 
 
HANDLE g_hChildStd_IN_Rd = NULL;
HANDLE g_hChildStd_IN_Wr = NULL;

HANDLE g_hChildStd_OUT_Rd = NULL;
HANDLE g_hChildStd_OUT_Wr = NULL;

HANDLE g_hInputFile = NULL;
 
void CreateChildProcess(void); 
void WriteToPipe(void); 
void ReadFromPipe(void); 
void ErrorExit(PTSTR); 
 
int _tmain(int argc, TCHAR *argv[]) 
{ 
   SECURITY_ATTRIBUTES saAttr; 
 
   printf("\n->Start of parent execution.\n");

// Set the bInheritHandle flag so pipe handles are inherited. 
 
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
   saAttr.bInheritHandle = TRUE; 
   saAttr.lpSecurityDescriptor = NULL; 

// Create a pipe for the child process's STDOUT. 
 
   if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0) ) 
      ErrorExit(TEXT("StdoutRd CreatePipe")); 

// Ensure the read handle to the pipe for STDOUT is not inherited.

   if ( ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
      ErrorExit(TEXT("Stdout SetHandleInformation")); 

// Create a pipe for the child process's STDIN. 
 
   if (! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)) 
      ErrorExit(TEXT("Stdin CreatePipe")); 

// Ensure the write handle to the pipe for STDIN is not inherited. 
 
   if ( ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
      ErrorExit(TEXT("Stdin SetHandleInformation")); 
 
// Create the child process. 
   
   CreateChildProcess();

// Get a handle to an input file for the parent. 
// This example assumes a plain text file and uses string output to verify data flow. 
 
   if (argc == 1) 
      ErrorExit(TEXT("Please specify an input file.\n")); 

   g_hInputFile = CreateFile(
       argv[1], 
       GENERIC_READ, 
       0, 
       NULL, 
       OPEN_EXISTING, 
       FILE_ATTRIBUTE_READONLY, 
       NULL); 

   if ( g_hInputFile == INVALID_HANDLE_VALUE ) 
      ErrorExit(TEXT("CreateFile")); 
 
// Write to the pipe that is the standard input for a child process. 
// Data is written to the pipe's buffers, so it is not necessary to wait
// until the child process is running before writing data.
 
   WriteToPipe(); 
   printf( "\n->Contents of %s written to child STDIN pipe.\n", argv[1]);
 
// Read from pipe that is the standard output for child process. 
 
   printf( "\n->Contents of child process STDOUT:\n\n", argv[1]);
   ReadFromPipe(); 

   printf("\n->End of parent execution.\n");

// The remaining open handles are cleaned up when this process terminates. 
// To avoid resource leaks in a larger application, close handles explicitly. 

   return 0; 
} 
 
void CreateChildProcess()
// Create a child process that uses the previously created pipes for STDIN and STDOUT.
{ 
   TCHAR szCmdline[]=TEXT("child");
   PROCESS_INFORMATION piProcInfo; 
   STARTUPINFO siStartInfo;
   BOOL bSuccess = FALSE; 
 
// Set up members of the PROCESS_INFORMATION structure. 
 
   ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
 
// Set up members of the STARTUPINFO structure. 
// This structure specifies the STDIN and STDOUT handles for redirection.
 
   ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
   siStartInfo.cb = sizeof(STARTUPINFO); 
   siStartInfo.hStdError = g_hChildStd_OUT_Wr;
   siStartInfo.hStdOutput = g_hChildStd_OUT_Wr;//输出重定向
   siStartInfo.hStdInput = g_hChildStd_IN_Rd;//输入重定向
   siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
 
// Create the child process. 
    
   bSuccess = CreateProcess(NULL, 
      szCmdline,     // command line 
      NULL,          // process security attributes 
      NULL,          // primary thread security attributes 
      TRUE,          // handles are inherited 
      0,             // creation flags 
      NULL,          // use parent's environment 
      NULL,          // use parent's current directory 
      &siStartInfo,  // STARTUPINFO pointer 
      &piProcInfo);  // receives PROCESS_INFORMATION 
   
   // If an error occurs, exit the application. 
   if ( ! bSuccess ) 
      ErrorExit(TEXT("CreateProcess"));
   else 
   {
      // Close handles to the child process and its primary thread.
      // Some applications might keep these handles to monitor the status
      // of the child process, for example. 

      CloseHandle(piProcInfo.hProcess);
      CloseHandle(piProcInfo.hThread);
   }
}
 
void WriteToPipe(void) 

// Read from a file and write its contents to the pipe for the child's STDIN.
// Stop when there is no more data. 
{ 
   DWORD dwRead, dwWritten; 
   CHAR chBuf[BUFSIZE];
   BOOL bSuccess = FALSE;
 
   for (;;) 
   { 
      bSuccess = ReadFile(g_hInputFile, chBuf, BUFSIZE, &dwRead, NULL);
      if ( ! bSuccess || dwRead == 0 ) break; 
      
      bSuccess = WriteFile(g_hChildStd_IN_Wr, chBuf, dwRead, &dwWritten, NULL);
      if ( ! bSuccess ) break; 
   } 
 
// Close the pipe handle so the child process stops reading. 
 
   if ( ! CloseHandle(g_hChildStd_IN_Wr) ) 
      ErrorExit(TEXT("StdInWr CloseHandle")); 
} 
 
void ReadFromPipe(void) 

// Read output from the child process's pipe for STDOUT
// and write to the parent process's pipe for STDOUT. 
// Stop when there is no more data. 
{ 
   DWORD dwRead, dwWritten; 
   CHAR chBuf[BUFSIZE]; 
   BOOL bSuccess = FALSE;
   HANDLE hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

// Close the write end of the pipe before reading from the 
// read end of the pipe, to control child process execution.
// The pipe is assumed to have enough buffer space to hold the
// data the child process has already written to it.
 
   if (!CloseHandle(g_hChildStd_OUT_Wr)) 
      ErrorExit(TEXT("StdOutWr CloseHandle")); 
 
   for (;;) 
   { 
      bSuccess = ReadFile( g_hChildStd_OUT_Rd, chBuf, BUFSIZE, &dwRead, NULL);
      if( ! bSuccess || dwRead == 0 ) break; 

      bSuccess = WriteFile(hParentStdOut, chBuf, 
                           dwRead, &dwWritten, NULL);
      if (! bSuccess ) break; 
   } 
} 
 
void ErrorExit(PTSTR lpszFunction) 

// Format a readable error message, display a message box, 
// and exit from the application.
{ 
    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 

    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );

    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR)); 
  //  StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
//        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK); 

    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
    ExitProcess(1);
}