Fastest(performance-wise) way to share data(not objects) between .Net & Java

Question

I know of at least one post which has same words like this. But this is not exactly same as that post. I'm trying to work a way to "share" data between a .NET and Java application. I'm not concerned about objects, but just plain strings if u like.

I have a .NET application capturing real-time data and a Java application which has capability to analyze and work on this data. I'm looking for ways to re-use this same java app without coding it entirely in .NET.

My problem is that the data is "fairly" REAL-Time (.NET), and so has to be the analysis (Java). I can live with microsecond delays but I can't afford one second delay. WebServices, Queues (as in Messaging Queues), RDBMS are some of the options I can think of. Is there any better way?

Or has anybody got some real performance numbers for the solutions I mentioned above to select one of them? And just to get started: RDBMSs' are not "THAT" good for concurrent (connections doing) insertion/updation/reading, at least with the crude way of doing DBMS stuff. (Deadlocks?)

Answer 1

Sounds like a local socket could do. The latency should be in low ms or less.

Answer 2

Depending on your program you may get some milage out of what @Cowan reports in answer to 'Any Concept of shared memory in java', his answer is: http://stackoverflow.com/questions/1491519/any-concept-of-shared-memory-in-java/1492536#1492536

In summary: he say's that you can use memory mapped files between two processes on the same machine. This in theory could work between .NET and java assuming .NET has some memory mapped file support.

Answer 3

For completeness:

Another possible is to use Named pipes, it should be pretty quick, and I'd imagine (being a java guy I can only imagine) that .NET has native support for them. The down side is that on windows you'll have to either write a JNI extension or use a library like JNA to poke around at the Win32 API from Java.

Answer 4

What are "objects" if not a mechanism for describing "data"? But I digress - I suspect I would look at a TCP socket between the two. If the data is very basic, then fine - just write directly to the stream; if there is any complexity, perhaps use something like "protocol buffers" to provide an easy way of reading/writing dense data to a stream without having to write every last byte yourself.

I think microsecond delays are going to be a challenge for any approach here... will millisecond delays do?

Answer 5

Different machines communicate with each other by sending messages into sockets. Please check the below link for example.

Socket programming in the real world

Answer 6

Answers provided here are great. One idea that might be of interest, but is probably asking for more trouble than it's worth is to load both VMs in a single process (both the JVM and the CLR can be loaded within a native Windows application) and give them access to native code. Java via JNI and .Net via the mapping functions to native code that they allow.

You could also leverage native queue semaphores to wake up a thread on one side or the other when data is updated.

While JNI transitions are expense, they would probably still be faster than the native local socket implementation.

Answer 7

How is your Java application currently deployed? It sounds to me like you're willing to make some modification to it, so I'm assuming you have access to the source code.

I know this is a little out there, but could you compile the Java application in the J# compiler, so that your .NET app has native access to it?

Answer 8

You can convert your compiled java application to .NET by IKVM. After that you can change logic of your .NET application so it will not make data transfers to Java application, but just call data processing code written in Java as it were written and compiled for .NET.

Answer 9

There are a number of JMS servers which support .NET and Java clients. These can perform messages in under a millisecond.

However you might like to try an RPC solution like Hessian RPC or Protobuf RPC. These can achieve lower latencies and can give the appearance of direct calls between platforms. These support .NET and Java as well.