在32位和64位JVM上串行化TypedActor代理和ActorRef时，akka无声地失败

Question

修复以下问题需要哪些配置？ 64位jvm上的Akka Actor（machine1）不能在32位jvm（machine2）上使用TypedActor代理（CASE1） 但反之亦然（CASE2）。

是否有一些序列化的配置设置我错过了？ 我正在使用java中的akka​​-2.2.1。

我有一个很小的测试代码，总能复制这个问题。

尽管启用了甚至远程生命周期事件，但没有日志报告“错误”。 在CASE1上调用registerListener（）时它会超时。

我很无能为力，任何帮助/线索都非常感激。

server.java

public class Server implements ServerActor {

    public static final String serverActorName = "server";
    public static final String serverIP = "192.168.11.112";
    public static final int serverPort = 9999;

    public static void main(String[] args) {
        new Server();
    }

    ActorSystem serverSystem;

    public Server() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = %d", Server.serverIP,
                        Server.serverPort);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        serverSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) serverSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Server Akka IP=%s PORT=%s\n", addr, port);

        final Server server = this;

        // start server service
        @SuppressWarnings("unused")
        ServerActor proxy = TypedActor.get(serverSystem).typedActorOf(
                new TypedProps<Server>(ServerActor.class,
                        new Creator<Server>() {

                            private static final long serialVersionUID = 6301999771454618282L;

                            @Override
                            public Server create() {
                                return server;
                            }
                        }), Server.serverActorName);

    }

    @Override
    public boolean registerListener(ITestListener listener) {
        listener.update(10);
        return true;
    }

}

和client.java

public class Client implements ITestListener {

    public static final String clientActorName = "client";
    public static final String clientIP = "192.168.11.111";

    public static void main(String[] args) {
        new Client();
    }

    ActorSystem clientSystem;
    private ITestListener clientListener = null;

    public Client() {

        String network = String
                .format("akka.actor.provider = \"akka.remote.RemoteActorRefProvider\" \n"
                        + "akka.remote.enabled-transports = [\"akka.remote.netty.tcp\"] \n"
                        + "akka.remote.netty.tcp.hostname = \"%s\" \n"
                        + "akka.remote.netty.tcp.port = 0", Client.clientIP);

        Config config = ConfigFactory.parseString("akka.loglevel = DEBUG \n"
                + "akka.actor.debug.lifecycle = on \n" + network);

        clientSystem = ActorSystem.create("sys", config);

        RemoteActorRefProvider ref = (RemoteActorRefProvider) clientSystem
                .provider();
        Address addr = ref.transport().defaultAddress();
        String port = addr.port().get().toString();

        System.out.printf("Client Akka IP=%s PORT=%s\n", addr, port);

        final Client client = this;

        // start server service
        clientListener = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<Client>(ITestListener.class,
                        new Creator<Client>() {

                            private static final long serialVersionUID = 2034444366744329184L;

                            @Override
                            public Client create() {
                                return client;
                            }
                        }), Client.clientActorName);

        connect();

    }

    private void connect() {

        // Connect to remote actor system
        String remotePath = String.format("akka.tcp://sys@%s:%d/user/%s",
                Server.serverIP, Server.serverPort, Server.serverActorName);

        // get remote server proxy object
        // TypedActor.context().setReceiveTimeout(Duration.create("3 second"));
        ActorRef remoteRef = clientSystem.actorFor(remotePath);

        if (remoteRef == null)
            throw new RuntimeException("Cannot get remote akka actor");

        final ServerActor server = TypedActor.get(clientSystem).typedActorOf(
                new TypedProps<ServerActor>(ServerActor.class), remoteRef);

        server.registerListener(clientListener);

    }

    @Override
    public void update(int a) {
        System.out.printf("*********** Server Sent %d ************\n", a);
    }
}