两个 JVM 之间的共享内存

Question

在 Java 中有没有办法让两个 JVM（在同一台物理机器上运行）使用/共享相同的内存地址空间？假设 JVM-1 中的生产者将消息放在特定的预定义内存位置，如果 JVM-2 上的消费者知道要查看哪个内存位置，是否可以检索消息？

Answer 1

解决方案 1：

我认为最好的解决方案是使用内存映射文件。这允许您在任意数量的进程（包括其他非 Java 程序）之间共享内存区域。您不能将 java 对象放入内存映射文件中，除非您将它们序列化。以下示例显示您可以在两个不同的进程之间进行通信，但您需要使其更加复杂以允许进程之间更好的通信。我建议你看一下Java的NIO package，特别是下面示例中使用的类和方法。

服务器：

public class Server {

    public static void main( String[] args ) throws Throwable {
        File f = new File( FILE_NAME );

        FileChannel channel = FileChannel.open( f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE );

        MappedByteBuffer b = channel.map( MapMode.READ_WRITE, 0, 4096 );
        CharBuffer charBuf = b.asCharBuffer();

        char[] string = "Hello client\0".toCharArray();
        charBuf.put( string );

        System.out.println( "Waiting for client." );
        while( charBuf.get( 0 ) != '\0' );
        System.out.println( "Finished waiting." );
    }
}

客户：

public class Client {

    public static void main( String[] args ) throws Throwable {
        File f = new File( FILE_NAME );
        FileChannel channel = FileChannel.open( f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE );

        MappedByteBuffer b = channel.map( MapMode.READ_WRITE, 0, 4096 );
        CharBuffer charBuf = b.asCharBuffer();

        // Prints 'Hello server'
        char c;
        while( ( c = charBuf.get() ) != 0 ) {
            System.out.print( c );
        }
        System.out.println();

        charBuf.put( 0, '\0' );
    }

}

---

解决方案 2：

另一种解决方案是使用JavaSockets在进程之间来回通信。这还有一个额外的好处，就是可以非常轻松地通过网络进行通信。可以说这比使用内存映射文件要慢，但我没有任何基准来支持该声明。我不会发布实现此解决方案的代码，因为实现可靠的网络协议可能会变得非常复杂，并且是相当特定于应用程序的。有很多不错的社交网站可以通过快速搜索找到。

---

现在上面的例子是如果你想在两个不同的进程之间共享内存。如果您只想在当前进程中读取/写入任意内存，那么您应该首先了解一些警告。这违背了 JVM 的整个原则，你真的不应该在生产代码中这样做。如果您不非常小心，您会违反所有安全性并且很容易使 JVM 崩溃。

话虽如此，尝试一下还是很有趣的。要在当前进程中读取/写入任意内存，您可以使用 sun.misc.Unsafe 类。这是在我知道并使用过的所有 JVM 上提供的。可以在here找到有关如何使用该类的示例。

Answer 2

有一些 IPC 库可以通过 Java 中的内存映射文件促进共享内存的使用。

Chronicle-Queue

Chronicle Queue 类似于非阻塞 Java Queue，除了您可以在一个 JVM 中提供消息并在另一个 JVM 中轮询它。

在两个 JVM 中，您应该在同一个 FS 目录中创建一个 ChronicleQueue 实例（如果您不需要消息持久性，请将此目录放在内存挂载的 FS 中）：

ChronicleQueue ipc = ChronicleQueueBuilder.single("/dev/shm/queue-ipc").build();

在一个 JVM 中写入消息：

ExcerptAppender appender = ipc.acquireAppender();
appender.writeDocument(w -> {
    w.getValueOut().object(message);
});

在另一个 JVM 中读取消息：

ExcerptTailer tailer = ipc.createTailer();
// If there is no message, the lambda, passed to the readDocument()
// method is not called.
tailer.readDocument(w -> {
    Message message = w.getValueIn().object(Message.class);
    // process the message here
});

// or avoid using lambdas
try (DocumentContext dc = tailer.readingDocument()) {
    if (dc.isPresent()) {
        Message message = dc.wire().getValueIn().object(Message.class);
        // process the message here
    } else {
        // no message
    }
}

Aeron IPC

Aeron 不仅仅是 IPC 队列（它是一个网络通信框架），它还提供 IPC 功能。它类似于 Chronicle Queue，一个重要的区别是它使用 SBE 库进行消息编组/解组，而 Chronicle Queue 使用 Chronicle Wire。

Chronicle Map

Chronicle Map 允许通过某个键进行 IPC 通信。在两个 JVM 中，您应该创建一个具有相同配置的映射并持久化到同一个文件（如果您不需要实际的磁盘持久性，则该文件应该本地化到内存挂载的 FS 中，例如在 /dev/shm/ 中）：

Map<Key, Message> ipc = ChronicleMap
    .of(Key.class, Message.class)
    .averageKey(...).averageValue(...).entries(...)
    .createPersistedTo(new File("/dev/shm/jvm-ipc.dat"));

然后你可以在一个 JVM 中编写：

ipc.put(key, message); // publish a message

在接收方 JVM 上：

Message message = ipc.remove(key);
if (message != null) {
    // process the message here
}

Answer 3

Distributed_cache 是满足您要求的最佳解决方案。

在计算中，分布式缓存是在单一区域设置中使用的传统缓存概念的扩展。一个分布式缓存可以跨越多个服务器，因此它的规模和跨国容量都可以增长。

几个选项：

Terracotta 允许 JVM 集群中的线程使用相同的内置 JVM 工具跨 JVM 边界相互交互，这些工具扩展为具有集群范围的含义

Oracle_Coherence 是专有的1 基于 Java 的内存数据网格，旨在具有比传统关系数据库管理系统更好的可靠性、可扩展性和性能

Ehcache 是一种广泛使用的开源 Java 分布式缓存，用于通用缓存、Java EE 和轻量级容器。它具有内存和磁盘存储、通过复制和无效复制、侦听器、缓存加载器、缓存扩展、缓存异常处理程序、gzip 缓存 servlet 过滤器、RESTful 和 SOAP API

Redis 是一个数据结构服务器。它是开源的、联网的、内存中的，并且存储具有可选持久性的密钥。

Couchbase_Server 是一个开源、分布式（无共享架构）多模型 NoSQL 面向文档的数据库软件包，针对交互式应用程序进行了优化。这些应用程序可以通过创建、存储、检索、聚合、操作和呈现数据来为许多并发用户提供服务。

有用的帖子：

What is Terracotta?

Is Terracotta a distributed cache?

infoq文章

Answer 4

老实说，您不想共享相同的内存。您应该只将您需要的数据发送到其他 JVM。话虽如此，如果您确实需要共享内存，还有其他解决方案。

发送数据 两个 JVM 不共享相同的内存访问点，因此不可能使用来自一个 JVM 的引用在另一个 JVM 中使用。将简单地创建一个新的引用，因为它们彼此不了解。

但是，您可以将数据传送到其他 JVM，然后以多种方式返回：

1) 使用RMI，您可以设置远程服务器来解析数据。我发现设置起来有点麻烦，因为它需要更改安全性并且数据是Serializable。您可以在链接中找到更多信息。

2) 使用服务器是将数据发送到不同地方的古老方法。实现这一点的一种方法是使用ServerSocket 并在localhost 上连接Socket。如果要使用ObjectOutputStream，对象仍然需要为Serializable。

---

共享数据 这是非常危险和不稳定的，低级的，而且，不安全（字面意思）。

如果你想使用 Java 代码，你可以看看使用s.m.Unsafe，使用正确的内存地址，你将能够检索操作系统中支持 C/C++ 数组存储的对象。

否则，您可以使用native 方法自己访问 C/C++ 数组，尽管我不知道如何实现。

Answer 5

Jocket，我几年前做的一个实验项目就是这样做的。

如果您想使用Input/OutputStream，它包括java.net.Socket 和java.net.ServerSocket 的直接替换。

每个定向通道使用一对循环缓冲区来发送和获取数据（一个用于“数据包”，一个用于数据包地址）。缓冲区是通过RandomAccessFile 获得的。

它包含一个小的 JNI 层 (linux) 来实现 IPC 同步（即通知其他进程数据的可用性），但如果您想轮询数据，这不是强制性的。

Answer 6

是的，

使用中间程序，您可以写入和读取任意内存位置。你不能纯粹用 Java 来做。

例如，您可以编写一段可以读取任意内存位置并通过 JNI 调用的 C++ 代码。反向写入内存地址也是如此。

首先为应该处理这个问题的类编写一个类定义，例如：

public class MemTest {
    public native byte[] readMemory(int address);
    public native void writeMemory(int address, byte[] values);
}

然后你编译它。然后使用 javah.exe（或 linux 等效程序）为其生成标头：

javah MemTest

现在您编写一个包含该标头并定义方法的 .cpp 文件。编译为 DLL。要加载 .dll，您可以使用具有适当值的 -Djava.library.path JVM 参数或 System.loadLibrary()。

注意事项：我不建议这样做。几乎可以肯定有更好的方法来做你想做的事。

Answer 7

使用枢轴堆外内存不安全

如何使用 Unsafe 将 Object 字节复制到 off-head 区域，然后一些如何将便宜的指针和类名传递给第二个 JVM，后者将使用指针和类名复制堆外空间并将其转换为第二个 JVM 中的堆内对象。 它不是同一个对象实例，而是一个快速复制，没有序列化。

public static Unsafe getUnsafe() {
    try {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        return (Unsafe)f.get(null);
    } catch (Exception e) { /* ... */ }
}

MyStructure structure = new MyStructure(); // create a test object
structure.x = 777;

long size = sizeOf(structure);
long offheapPointer = getUnsafe().allocateMemory(size);
getUnsafe().copyMemory(
            structure,      // source object
            0,              // source offset is zero - copy an entire object
            null,           // destination is specified by absolute address, so destination object is null
            offheapPointer, // destination address
            size
    ); // test object was copied to off-heap

Pointer p = new Pointer(); // Pointer is just a handler that stores address of some object
long pointerOffset = getUnsafe().objectFieldOffset(Pointer.class.getDeclaredField("pointer"));
getUnsafe().putLong(p, pointerOffset, offheapPointer); // set pointer to off-heap copy of the test object

structure.x = 222; // rewrite x value in the original object
System.out.println(  ((MyStructure)p.pointer).x  ); // prints 777

....

class Pointer {
    Object pointer;
}

所以现在你将 MyStructure 和 p 从 ((MyStructure)p.pointer).x 传递到第二个 JVM，你应该能够：

MyStructure locallyImported = (MyStructure)p.pointer;

我可以想象一个用例：假设您有 2 个可能在或可能不在同一服务器上运行的微服务，以及一个可能在容器 AppServer 中实现的客户端策略，它知道服务部署在哪里，以防它检测到请求的服务在本地，它可能使用基于 Unsafe 的服务客户端来透明地查询其他服务。讨厌但有趣的是，我想看看不使用网络、绕过 WebAPI（直接调用处理控制器）和不序列化对性能的影响。在这种情况下，除了控制器参数之外，还应提供控制器本身。甚至没有考虑安全性。

从https://highlyscalable.wordpress.com/2012/02/02/direct-memory-access-in-java/借来的代码sn-ps