C++ 和 Java 应用程序之间的 NamedPipe 进程间

Question

我需要从 C++ 端启动一个命名管道服务器，并让一个 Java 应用程序从管道中读取。

对于创建管道的 C++ 端，我遵循了 MSDN 中的示例： https://msdn.microsoft.com/en-us/library/windows/desktop/aa365603(v=vs.85).aspx

从Java端，我做了一段hacky代码来测试：

Thread readerThread = new Thread( new Runnable()
    {
        @Override
        public void run()
        {
            String line = null;
            while( true )
            {
                try
                {
                    final RandomAccessFile pipe =
                            new RandomAccessFile( "\\\\\\\\.\\\\pipe\\\\smarts_interprocess", "r" );
                    while( null != ( line = pipe.readLine() ) )
                    {
                        s_logger.warning( line );
                    }
                }
                catch( IOException ex )
                {
                    s_logger.severe( ex.getMessage() );
                    try
                    {
                        Thread.sleep( 1000 );
                    }
                    catch( InterruptedException e )
                    {
                        s_logger.info( "nothing available, I will sleep for a second" );
                    }
                }
            }
        }
    } );
    readerThread.start();

C++ 端代码：

void Pipe::startMessageLoop()
{
    DWORD dwWait{};
    BOOL fSuccess;

    fPendingIO = ConnectToNewClient(m_inputHandle, &oOverlap_);

    while (true)
    {
        dwWait = ::WaitForSingleObject(oOverlap_.hEvent, INFINITE);

        if (dwWait == WAIT_FAILED)
        {
            ::CloseHandle(oOverlap_.hEvent);
            std::cout << "failed to WaitForSingleObject.." << std::endl;
        }

        if (fPendingIO)
        {
            DWORD cbRet;
            fSuccess = GetOverlappedResult(
                m_inputHandle,     // handle to pipe 
                &oOverlap_,        // OVERLAPPED structure 
                &cbRet,            // bytes transferred 
                FALSE);            // do not wait 

            switch (dwState)
            {
            // Pending connect operation 
            case CONNECTING_STATE:
                if (!fSuccess)
                {
                    printf("Error %d.\n", GetLastError());
                    return;
                }
                dwState = WRITING_STATE;
                break;

                // Pending write operation 
            case WRITING_STATE:
                if (!fSuccess)
                {
                    DisconnectAndReconnect();
                    continue;
                }
                break;

            default:
            {
                printf("Invalid pipe state.\n");
                return;
            }
            }
        }


        std::string message = "naive message from server";
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        std::wstring data = converter.from_bytes(message.c_str());
        DWORD numBytesWritten = 0;

        switch (dwState)
        {           
            case WRITING_STATE:

                fSuccess = WriteFile(
                    m_inputHandle, // handle to our outbound pipe
                    data.c_str(), // data to send
                    wcslen(data.c_str()) * sizeof(wchar_t), // length of data to send (bytes)
                    &numBytesWritten, // will store actual amount of data sent
                    NULL // not using overlapped IO
                    );

                // FlushFileBuffers(m_inputHandle);
                // The write operation completed successfully. 
                if (fSuccess)
                {
                    fPendingIO = FALSE;                 
                    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
                    dwState = WRITING_STATE;
                    continue;
                }

                // The write operation is still pending. 
                if (!fSuccess && (GetLastError() == ERROR_IO_PENDING))
                {
                    fPendingIO = TRUE;
                    continue;
                }
                // An error occurred; disconnect from the client. 
                DisconnectAndReconnect();
                break;

            default:
            {
                printf("Invalid pipe state.\n");
                return;
            }
        }
    }
}

它可以毫无问题地连接到管道，但唯一的问题是 java 端无法获取在 C++ 端写入的数据，直到 C++ 进程完成（我的意思是从 VS 终止调试器）。

只要我的 C++ 进程仍在运行，它就会挂在 readLine 点： line = pipe.readLine()

有人对此有任何想法吗？

Answer 1

据我所知 - 如果您在服务器端使用完全相同的 MSDN 代码 - 服务器在将任何内容写入管道之前正在等待输入。如果您的客户端从不发送任何内容，那么pipe.readLine 将阻塞，直到连接断开。

Java 不是我的菜，但我猜测来自服务器的响应还必须包含一个换行符，以便 readLine 返回。

Answer 2

如果您在 readLine() 中被阻止，则对等方不会发送线路。对等体退出时解除阻塞的原因是阅读器遇到了流尾，并返回了到目前为止接收到的数据。

您需要找出对等方正在发送的内容并为其使用合适的读取方法。显然不是线条，所以readLine() 是不适合这项工作的工具。