blocks|key|281868|text|你应该看看谷歌的Protocol+Buffers，它同时支持C%2B%2B和Java。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|281869|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/apis/protocolbuffers/docs/tutorials.html^0|8|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You should take a look at <a href="http://code.google.com/apis/protocolbuffers/docs/tutorials.html" rel="noreferrer">Protocol Buffers</a> from Google which supports both C++ and Java.

blocks|key|3147787|text|命名管道将比TCP更有效，但是如果只使用共享内存块呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3147788|我不知道Java端存在哪些原语来与共享内存交互，但从C%2B%2B端来看，访问共享内存中的数据比从套接字或命名管道中读取数据更有效。您必须实现自己的流控制和阻塞原语，但这些可以相当直接。|3147789|entityMap^0|K|4|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Named pipes would be more efficient than TCP, but how about just using shared memory blocks? 

I don't know what primitives exist on the Java side for interfacing with shared memory, but from the C++ side it would be more efficient to access data in shared memory than read it out of either a socket or named pipe. You would have to implement your own flow control and blocking primitives, but these could be fairly straight forward.

blocks|key|2194829|text|我会使用本地套接字，正如您所说的，这是最具跨平台的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2194830|内核用户空间拷贝应该不是问题，因为您可以选择的任何其他方法都将需要这种类型的拷贝，可能共享内存除外。它在每个Unix系统上都可用，而且Windows也有自己的doing+it方式。|offset|length|2194831|要在Java中使用共享内存，唯一的方法是通过您自己的.DLL/.SO和JNI访问它来实现它。|2194832|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/aa366551(VS.85).aspx^0|0|27|8|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I would use a local socket, which is, as you state, the most cross-platform method. 

Kernel-User space copies should not be an issue since any other method you could choose would requiere this kind of copy except for maybe shared memory. It is available on every Unix system and also Windows has its way of <a href="http://msdn.microsoft.com/en-us/library/aa366551(VS.85).aspx" rel="nofollow noreferrer">doing it</a>

To use shared memory in Java the only way is to implement it by means of your own .DLL/.SO and JNI to access it.

blocks|key|3148064|text|您最快的解决方案将是内存映射共享内存段，并实现环形缓冲区或其他消息传递机制。在C%2B%2B中，这很简单，而在Java语言中，您可以使用FileChannel.ma(http://java.sun.com/j2se/1.4.2/docs/api/java/nio/channels/FileChannel.html#map(java.nio.channels.FileChannel.MapMode,%2520long,%2520long%2529)p方法)来实现它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3148065|下一个替代方法是使用这两个进程的stdin/stdout。如果一个可以执行另一个，这可以是相当快的。|3148066|最后，正如您所提到的，您可以执行套接字IO。对于流视频，这不是一个很好的选择，但如果您传递XML，与其他处理相比，开销将是最小的。|3148067|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.4.2/docs/api/java/nio/channels/FileChannel.html#map(java.nio.channels.FileChannel.MapMode,%2520long,%2520long%2529)p^0|27|3T|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Your fastest solution will be memory mapping a shared segment of memory, and them implementing a ring-buffer or other message passing mechanism. In C++ this is straight forward, and in Java you have the <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/channels/FileChannel.html#map(java.nio.channels.FileChannel.MapMode,%20long,%20long)" rel="nofollow noreferrer">FileChannel.ma</a>p method which makes it possible.

The next alternative would be to use the stdin/stdout of the two processes. If one can exec the other, this can be quite fast.

Lastly, as you've noted, you can do socket IO. For streaming video this isn't a great option, but if your passing XML around, the overhead will be minimal in comparison to the other processing.

blocks|key|3147975|text|如果您对编写JNI感到满意，可以考虑使用Boost.Interprocess。这将为您提供Linux和Windows上的便携共享内存。请记住，没有用于读/写共享内存的内核往返。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3147976|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_37_0/doc/html/interprocess.html^0|K|I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you're happy with writing JNI, consider <a href="http://www.boost.org/doc/libs/1_37_0/doc/html/interprocess.html" rel="nofollow noreferrer">Boost.Interprocess</a>. This will give you portable shared memory on both Linux and Windows. Remember that there's no kernel roundtrip for reading/writing shared memory.

blocks|key|3148160|text|如果"one“函数调用中的数据量很大，我建议使用JNI。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3148161|看看这个：Sharing+output+streams+through+a+jni+interface|offset|length|3148162|本文中的代码片段，它将数据从c%2B%2B传输到java，相反也很容易做到：|3148163|总而言之，共享二进制数据(A/V文件、图像等)的一般策略从C到Java需要字节数组。在C中创建一个Java字节数组，如下所示：|3148164|const+char[]+rawData+=+{0,1,2,3,4,5,6,7,8,9};+//Or+get+some+raw+data+from+somewhere
int+dataSize+=+sizeof(rawData);
printf("Building+raw+data+array+copy\n");
jbyteArray+rawDataCopy+=+env->NewByteArray(dataSize);
env->SetByteArrayRegion(rawDataCopy,+0,+dataSize,+rawData);|code-block|syntax|javascript|3148165|并将其传递给Java，如下所示：|3148166|printf("Finding+callback+method\n");
//Assumes+obj+is+the+Java+instance+that+will+receive+the+raw+data+via+callback
jmethodID+aMethodId+=+env->GetMethodID(env->GetObjectClass(obj),"handleData","([B)V");
if(0==aMethodId)+throw+MyRuntimeException("Method+not+found+error");
printf("Invoking+the+callback\n");
env->CallVoidMethod(obj,aMethodId,+&rawDataCopy);|3148167|您将拥有一个如下所示的Java对象：|3148168|public+class+MyDataHandler+{
++OutputStream+dataStream;
++public+MyDataHandler(OutputStream+writeTo)+{+dataStream+=+writeTo;}
++public+void+handleData(byte[]+incomingData)+{+dataStream.write(incomingData);+}
}|3148169|该处理程序将通过本机方法传递给C，如下所示：|3148170|public+class+NativeIntegration+{
++public+native+void+generateBinaryWithHandler(MyDataHandler+handler);

++//Here+we+assume+response+is+something+like+a+network+stream
++public+void+doCallNativeFunction(ResponseStream+response)+{
++++MyDataHandler+handler+=+new+MyDataHandler(response);
++++generateBinaryWithHandler(handler);
++}
}|3148171|此外，您还可以使用其他技术:+CORBA、asp.1+(ASN.1+tool)、UDP或TCP|3148172|entityMap|0|LINK|mutability|MUTABLE|url|http://codeforfun.wordpress.com/2010/04/22/sharing-output-streams-through-a-jni-interface/|1|http://www.obj-sys.com/asn1-compiler.shtml?gclid=CPTMn7-j0qMCFYp_5QoddCXxtQ^0|0|5|1A|0|0|0|0|0|0|0|0|0|0|0|S|A|1|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@$D|1E|E|1F|1|1G]]|A|$]]|$1|F|3|G|5|6|7|1H|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1I|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1J|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1L|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1P|8|@]|9|@]|A|$M|N]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@$D|1R|E|1S|1|1T]]|A|$]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|1B]]]]

If it's a big chunk of data in "one" function call I would recommend JNI.

Take a look at this:<a href="http://codeforfun.wordpress.com/2010/04/22/sharing-output-streams-through-a-jni-interface/" rel="nofollow noreferrer">Sharing output streams through a jni interface</a>

Snippet from the article, it transfert data from c++ to java, the opposite would be also easy to do:

In all, the general strategy for sharing binary data (A/V files, images, etc.) from C with Java requires byte arrays. You create a Java byte array in C like this:

<pre><code>const char[] rawData = {0,1,2,3,4,5,6,7,8,9}; //Or get some raw data from somewhere
int dataSize = sizeof(rawData);
printf("Building raw data array copy\n");
jbyteArray rawDataCopy = env-&gt;NewByteArray(dataSize);
env-&gt;SetByteArrayRegion(rawDataCopy, 0, dataSize, rawData);
</code></pre>

And pass it to Java like this:

<pre><code>printf("Finding callback method\n");
//Assumes obj is the Java instance that will receive the raw data via callback
jmethodID aMethodId = env-&gt;GetMethodID(env-&gt;GetObjectClass(obj),"handleData","([B)V");
if(0==aMethodId) throw MyRuntimeException("Method not found error");
printf("Invoking the callback\n");
env-&gt;CallVoidMethod(obj,aMethodId, &amp;rawDataCopy);
</code></pre>

you would have a Java object that looked something like this:

<pre><code>public class MyDataHandler {
 OutputStream dataStream;
 public MyDataHandler(OutputStream writeTo) { dataStream = writeTo;}
 public void handleData(byte[] incomingData) { dataStream.write(incomingData); }
}
</code></pre>

That handler would be passed to C via native method like so:

<pre><code>public class NativeIntegration {
 public native void generateBinaryWithHandler(MyDataHandler handler);

 //Here we assume response is something like a network stream
 public void doCallNativeFunction(ResponseStream response) {
 MyDataHandler handler = new MyDataHandler(response);
 generateBinaryWithHandler(handler);
 }
}
</code></pre>

Also, you can use other technologies:
CORBA, ASN.1 (<a href="http://www.obj-sys.com/asn1-compiler.shtml?gclid=CPTMn7-j0qMCFYp_5QoddCXxtQ" rel="nofollow noreferrer">ASN.1 tool</a>), UDP or TCP

blocks|key|5259728|text|如果TCP的比特率太高，我会使用带有否定确认UDP的本地套接字(尽管我会先尝试TCP并确认这是一个问题)。如果您在同一台机器上进行流式传输，那么丢弃的数据包应该是最少的，但添加一个否定确认层将为您解决这种情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5259729|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would use a local socket with negative acknowledgment UDP if the bit rate is going to be too high for TCP (although I would try TCP first and confirm that it is a problem). There should be minimal, if any, packets dropped if you are doing the streaming on the same machine, but the addition of a negative acknowledgement layer will take care of that case for you.

blocks|key|3147908|text|使用System.out和System.in怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3147909|如果这不合适，那么Sockets是您最好的选择。|3147910|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

How about using System.out and System.in?

If that isn't suitable, then Sockets is your best bet.

blocks|key|280520|text|如果您的C%2B%2B进程启动了Java进程，那么它可能会从inheritedChannel中受益。此外，如果Java进程正在使用文件，我建议研究一下transferTo和transferFrom方法。在执行文件到文件IO时，这些方法避免了不必要的用户和内核空间之间的来回切换；如果您使用特殊的套接字通道，则可能会进行相同的优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|280521|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/spi/SelectorProvider.html#inheritedChannel())|1|http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/FileChannel.html#transferTo(long,%2520long,%2520java.nio.channels.WritableByteChannel)|2|http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/FileChannel.html#transferFrom(java.nio.channels.ReadableByteChannel,%2520long,%2520long)^0|Q|G|0|1Z|A|1|2A|C|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

If your C++ process starts the Java process, it might benefit from the <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/spi/SelectorProvider.html#inheritedChannel()" rel="nofollow noreferrer">inheritedChannel</a>. Also, if the Java process is using a file, I recommend exploration of the <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/FileChannel.html#transferTo(long,%20long,%20java.nio.channels.WritableByteChannel)" rel="nofollow noreferrer">transferTo</a> and <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/nio/channels/FileChannel.html#transferFrom(java.nio.channels.ReadableByteChannel,%20long,%20long)" rel="nofollow noreferrer">transferFrom</a> methods. When doing file to file IO, these avoid needlessly tripping back and forth between user and kernel space; the same optimizations might kick in if you're using a special socket channel.

blocks|key|281884|text|我建议使用UDP“连接”，它确认每N个没有错误的数据包，并请求重新传输它将丢失的几个数据包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|281885|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I recommend a UDP "connection" that acknowledges every Nth packet that was received without fault, and requests a retransmission of the few packets it will miss.

blocks|key|281830|text|我建议不要使用JNI，因为它很难调试。如果C%2B%2B代码分段或抛出未捕获的异常，那么您的JVM将崩溃，您将不知道原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|281831|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would advise against JNI, because it is very difficult to debug. If the C++ code segfaults or throws an uncaught exception, your JVM will crash, and you will have no idea why.

I'm looking to stream lots of data (up to ~1 Gbit) from Java to a C++ application (both on the same machine). I'm currently using a FIFO on Linux but need a Windows solution too.

The most cross-platform method seems to be a local socket, but:
a) won't I get huge overhead from TCP checksumming and copying to &amp; from kernel space, and
b) won't the average user's firewall try to inspect the and maybe block the connection?

It seems like a safer solution may be to use JNI and the Named Pipe API (\.\pipe\blah), making a god-awful platform-specific mess of both sides of the connection.

Are these really my 2 best options (and which would people recommend?)
Thanks!

Efficient data transfer from Java to C++ on windows

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我希望将大量数据(高达~1Gbit)从Java流式传输到C++应用程序(两者都在同一台机器上)。我目前在Linux上使用FIFO，但也需要Windows解决方案。跨平台最多的方法似乎是本地套接字，但是: a)我不会从TCP校验和和复制到内核空间中获得巨大的开销吗? b)普通用户的防火墙不会尝试检查并可能阻止连接吗？似乎更安全的解决方案可能是使用JNI和命名管道API (.\pipe\blah)，让

问windows环境下Java到C++的高效数据传输
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问windows环境下Java到C++的高效数据传输EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问windows环境下Java到C++的高效数据传输
EN