大部分情况下，我们面对在两个java进程只见传递数据的问题时，第一个想到的就是开server，然后通过socket收发消息。这方面有大量的框架可用，就不细说了。
但如果两个进程是在一台机器上，那么还可以使用另一种方式来传递数据，那就是使用RandomAccessFile的文件映射模式。
RandomAccessFile的map方法把文件映射到内存中进行快速读写。因此可以通过把消息包写入到文件中，然后另一个进程读取出来的方式来完成数据传递。
在这个过程中，重点是要考虑什么时候写入完成，只有写入完成后，读取进程才可以去读数据，否则就是错误的数据。具体方案如下：
保留文件的首个byte作为标志位，1表示A进程写入完毕，0表示B进程读取完毕。
步骤1：A进程开始写入时，先跳过首字节，然后将数据长度，数据内容写入到文件。写入完毕后，将文件的首字节置为1
步骤2：B进程定时刷新文件到内存中，读取首字节，如果是0则跳出，等待下次刷新。如果是1表示有新数据，则加载。加载完毕后设置首字节为0.表示已经读取完毕。
步骤3：A进程定时刷新文件到内存，读取首字节，如果是0，表示可以写入，继续步骤1的流程。如果是1，则表示数据还没被读取，不可写入。等待下次刷新。
经过以上3个步骤，完成数据的进程间传递。此模式也可以用于将数据传递到非java进程。
代码如下：
public class TestRandomAccessFile {
private static String FileName="aa.a";
private static volatile Linux1 lx1;
private static volatile Linux2 lx2;
private static long from;
private static void close(Closeable c){
try{
c.close();
}catch(IOException ie){
ie.printStackTrace();
}
}
public static class Linux1{
MappedByteBuffer buf;
RandomAccessFile raf;
public Linux1(){
try{
raf = new RandomAccessFile(FileName, "rw");
buf = raf.getChannel().map(MapMode.READ_WRITE, 0, 1024*1024);
}catch(IOException ie){
ie.printStackTrace();
}
new Thread(()->{
try{
while(true){
readAndWrite();
}
}catch(IOException e){
e.printStackTrace();
}
}).start();
}
private void readAndWrite() throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String s = reader.readLine();
if(s != null){
if("exit".equalsIgnoreCase(s)){
exitAll();
}else{
write(s);
}
}
}
private void write(String s){
if(s.length() == 0)return;
buf.load();
buf.position(0);
byte mark = buf.get();
while(mark != 0){
buf.load();
mark = buf.get();
}
if(s != null && s.length() > 0){
buf.putShort((short)s.length());
for (int i = 0; i< s.length(); i++){
buf.putChar(s.charAt(i));
}
buf.position(0);
buf.put((byte)1); //加可读标记
buf.force();
from = System.nanoTime();
}
}
public void exit(){
close(raf);
}
}
public static class Linux2{
MappedByteBuffer buf;
RandomAccessFile raf;
public Linux2(){
try{
raf = new RandomAccessFile(FileName, "rw");
buf = raf.getChannel().map(MapMode.READ_WRITE, 0, 1024*1024);
}catch(IOException e){
e.printStackTrace();
}
new Thread(()->{
while(true){
checkAndRead();
if(from > 0){
long t = (System.nanoTime()-from);
System.out.println("time=" + t);
from = -1;
}
try{
TimeUnit.NANOSECONDS.sleep(1);
}catch(Exception e){
e.printStackTrace();
}
}
}).start();
}
private void checkAndRead(){
buf.load();
if(buf.remaining() == 0)return;
buf.position(0);
byte mark = buf.get();
if(mark == 0)return;
int len = buf.getShort();
if(len > 0){
char[] cs = new char[len];
for (int i = 0; i< len; i++){
cs[i] = buf.getChar();
}
// /System.out.println("***** " + new String(cs));
}
buf.position(0);
buf.put((byte)0);
}
public void exit(){
close(raf);
}
}
public static void exitAll(){
lx1.exit();
lx2.exit();
System.exit(0);
}
public static void main(String[] args){
lx1 = new Linux1();
lx2 = new Linux2();
}
}
测试下来，使用netty走socket传数据，时间在0.5-1ms之间。用RandomAccessFile模式传数据，则依赖于轮询快慢。由于java定时器的误差，及时是用Thread.sleep(0,1)的方式，我们也只能做到平均1ms左右的延迟。但如果是不sleep（现实不能如此，会导致单核被完全占用），那么延迟可以在0.001ms。所以如果能找到一种更有效的轮询方法，那么使用RandomAccessFile进行进程间数据传输的效率会更高，如果不能，那还不如就Socket模式吧，更通用。