JAVA RMI线程模型及内部实现机制

JAVA RMI线程模型及内部实现机制

 

1 RMI内部实现

  JAVA RMI是JAVA分布式结构的基础。 远程对象的通信过程中， RMI 使用标准机制： stub 和skeleton 。远程对象的 stub 担当远程对象的客户本地代表或代理人角色，调用程序将调 用本地stub 的方法，而本地 stub 将负责执行对远程对象的方法调用。在 RMI 中，远程对象的 stub 与该远程对象所实现的远程接口集相同。调用 stub 的方法时将执行下列操作： 
   (1) 初始化与包含远程对象的远程虚拟机的连接； 
　 (2) 对远程虚拟机的参数进行编组-传输参数； 
　 (3) 等待远程方法调用结果； 
　 (4) 解编（读取）返回值或返回的异常； 
　 (5) 将值返回给调用程序。

  为了向调用程序展示比较简单的调用机制， stub 将参数的序列化和网络级通信等细节隐藏了起来。在远程虚拟机中，每个远程对象都可以 有相应的 skeleton。s keleton 负责将调用分配给实际的远程对象实现。它在接收方法调用时 执行下列操作：

  (1) 解编（读取）远程方法的参数；

  (2) 调用实际远程对象实现上的方法；

  (3) 将结果（返回值或异常）编组（写入并传输）给调用程序。  

  stub 和 skeleton 由 rmic 编译器生成。在最新的JDK中，不需要手工生产stub和skeleton，用动态代理生成的Proxy代替了stub，而skeleton则取消了。

  我们可以查看源代码来了解RMI的内部实现。Server端调用UnicastRemoteObject的export方法输出远程对象，export方法会在一个线程里监听某个TCP端口上的方法调用请求：

 

public void exportObject(Target target) throws RemoteException {

  // other code

while (true) {
    ServerSocket myServer = server;
    if (myServer == null)
      return;
    Throwable acceptFailure = null;
    final Socket socket;

    try {
    socket = myServer.accept();

    /*
     * Find client host name (or "0.0.0.0" if unknown)
     */
    InetAddress clientAddr = socket.getInetAddress();
    String clientHost = (clientAddr != null
                 ? clientAddr.getHostAddress()
                 : "0.0.0.0");

    /*
     * Spawn non-system thread to handle the connection
     */
    Thread t = (Thread)
        java.security.AccessController.doPrivileged (
            new NewThreadAction(new ConnectionHandler(socket,
                              clientHost),
                    "TCP Connection(" + ++ threadNum +
                    ")-" + clientHost,
                    true, true));
    t.start();

    } catch (IOException e) {
    acceptFailure = e;
    } catch (RuntimeException e) {
    acceptFailure = e;
    } catch (Error e) {
    acceptFailure = e;
    }
}

// other code

 

  上面的代码已被修改以展示主要的要点，Server端就是在ServerSocket的accept方法上面监听到来的请求，如果有新的方法调用请求到来，Server产生一个单独的线程来处理新接收的请求：

 

public void dispatch(Remote obj, RemoteCall call) throws IOException {
// positive operation number in 1.1 stubs;
// negative version number in 1.2 stubs and beyond...
int num;
long op;
try {
    // read remote call header
    ObjectInput in;
    try {
    in = call.getInputStream();
    num = in.readInt();
    if (num >= 0) {
        if (skel != null) {
        oldDispatch(obj, call, num);
        return;
        } else {
        throw new UnmarshalException(
            "skeleton class not found but required " +
            "for client version");
        }
    }
    op = in.readLong();
    } catch (Exception readEx) {
    throw new UnmarshalException("error unmarshalling call header",
                     readEx);
    }
    /*
     * Since only system classes (with null class loaders) will be on
     * the execution stack during parameter unmarshalling for the 1.2
     * stub protocol, tell the MarshalInputStream not to bother trying
     * to resolve classes using its superclasses's default method of
     * consulting the first non-null class loader on the stack.
     */
    MarshalInputStream marshalStream = (MarshalInputStream) in;
    marshalStream.skipDefaultResolveClass();
    Method method = (Method) hashToMethod_Map.get(new Long(op));
    if (method == null) {
    throw new UnmarshalException("invalid method hash");
    }
    // if calls are being logged, write out object id and operation
    logCall(obj, method);
    // unmarshal parameters
    Class[] types = method.getParameterTypes();
    Object[] params = new Object[types.length];
    try {
    unmarshalCustomCallData(in);
    for (int i = 0; i < types.length; i++) {
        params[i] = unmarshalValue(types[i], in);
    }
    } catch (java.io.IOException e) {
    throw new UnmarshalException(
        "error unmarshalling arguments", e);
    } catch (ClassNotFoundException e) {
    throw new UnmarshalException(
        "error unmarshalling arguments", e);
    } finally {
    call.releaseInputStream();
    }
    // make upcall on remote object
    Object result;
    try {
    result = method.invoke(obj, params);
    } catch (InvocationTargetException e) {
    throw e.getTargetException();
    }
    // marshal return value
    try {
    ObjectOutput out = call.getResultStream(true);
    Class rtype = method.getReturnType();
    if (rtype != void.class) {
        marshalValue(rtype, result, out);
    }
    } catch (IOException ex) {
    throw new MarshalException("error marshalling return", ex);
    /*
     * This throw is problematic because when it is caught below,
     * we attempt to marshal it back to the client, but at this
     * point, a "normal return" has already been indicated,
     * so marshalling an exception will corrupt the stream.
     * This was the case with skeletons as well; there is no
     * immediately obvious solution without a protocol change.
     */
    }
} catch (Throwable e) {
    logCallException(e);

    ObjectOutput out = call.getResultStream(false);
    if (e instanceof Error) {
    e = new ServerError(
        "Error occurred in server thread", (Error) e);
    } else if (e instanceof RemoteException) {
    e = new ServerException(
        "RemoteException occurred in server thread",
        (Exception) e);
    }
    if (suppressStackTraces) {
    clearStackTraces(e);
    }
    out.writeObject(e);
} finally {
    call.releaseInputStream(); // in case skeleton doesn't
    call.releaseOutputStream();
}
   }
protected static void marshalValue(Class type, Object value,
                   ObjectOutput out)
throws IOException
   {
if (type.isPrimitive()) {
    if (type == int.class) {
    out.writeInt(((Integer) value).intValue());
    } else if (type == boolean.class) {
    out.writeBoolean(((Boolean) value).booleanValue());
    } else if (type == byte.class) {
    out.writeByte(((Byte) value).byteValue());
    } else if (type == char.class) {
    out.writeChar(((Character) value).charValue());
    } else if (type == short.class) {
    out.writeShort(((Short) value).shortValue());
    } else if (type == long.class) {
    out.writeLong(((Long) value).longValue());
    } else if (type == float.class) {
    out.writeFloat(((Float) value).floatValue());
    } else if (type == double.class) {
    out.writeDouble(((Double) value).doubleValue());
    } else {
    throw new Error("Unrecognized primitive type: " + type);
    }
} else {
    out.writeObject(value);
}
   }
rotected static Object unmarshalValue(Class type, ObjectInput in)
throws IOException, ClassNotFoundException
   {
if (type.isPrimitive()) {
    if (type == int.class) {
    return new Integer(in.readInt());
    } else if (type == boolean.class) {
    return new Boolean(in.readBoolean());
    } else if (type == byte.class) {
    return new Byte(in.readByte());
    } else if (type == char.class) {
    return new Character(in.readChar());
    } else if (type == short.class) {
    return new Short(in.readShort());
    } else if (type == long.class) {
    return new Long(in.readLong());
    } else if (type == float.class) {
    return new Float(in.readFloat());
    } else if (type == double.class) {
    return new Double(in.readDouble());
    } else {
    throw new Error("Unrecognized primitive type: " + type);
    }
} else {
    return in.readObject();
}
   }

 

   dispatch方法处理接收的请求，先从输入流中读取方法的编号来获得方法名称：op = in.readLong()，然后读取方法的所有参数：params[i] = unmarshalValue(types[i], in)，接着就可以执行方法调用了：result = method.invoke(obj, params)，最后把方法执行结果写入到输出流中：marshalValue(rtype, result, out)。一个方法调用就执行完成了。

  Client端请求一个远程方法调用时，先建立连接：Connection conn = ref.getChannel().newConnection()，然后发送方法参数： marshalValue(types[i], params[i], out)，再发送执行方法请求：call.executeCall()，最后得到方法的执行结果：Object returnValue = unmarshalValue(rtype, in)，并关闭接：

ref.getChannel().free(conn, true)。

 

 public Object invoke(Remote obj,
         java.lang.reflect.Method method,
         Object[] params,
         long opnum)
throws Exception
   {
if (clientRefLog.isLoggable(Log.VERBOSE)) {
    clientRefLog.log(Log.VERBOSE, "method: " + method);
}
if (clientCallLog.isLoggable(Log.VERBOSE)) {
    logClientCall(obj, method);
}

Connection conn = ref.getChannel().newConnection();
RemoteCall call = null;
boolean reuse = true;
/* If the call connection is "reused" early, remember not to
 * reuse again.
 */
boolean alreadyFreed = false;
try {
    if (clientRefLog.isLoggable(Log.VERBOSE)) {
    clientRefLog.log(Log.VERBOSE, "opnum = " + opnum);
    }
    // create call context
    call = new StreamRemoteCall(conn, ref.getObjID(), -1, opnum);
    // marshal parameters
    try {
    ObjectOutput out = call.getOutputStream();
    marshalCustomCallData(out);
    Class[] types = method.getParameterTypes();
    for (int i = 0; i < types.length; i++) {
        marshalValue(types[i], params[i], out);
    }
    } catch (IOException e) {
    clientRefLog.log(Log.BRIEF,
        "IOException marshalling arguments: ", e);
    throw new MarshalException("error marshalling arguments", e);
    }
    // unmarshal return
    call.executeCall();
    try {
    Class rtype = method.getReturnType();
    if (rtype == void.class)
        return null;
    ObjectInput in = call.getInputStream();

    /* StreamRemoteCall.done() does not actually make use
     * of conn, therefore it is safe to reuse this
     * connection before the dirty call is sent for
     * registered refs.
     */
    Object returnValue = unmarshalValue(rtype, in);
    /* we are freeing the connection now, do not free
     * again or reuse.
     */
    alreadyFreed = true;
    /* if we got to this point, reuse must have been true. */
    clientRefLog.log(Log.BRIEF, "free connection (reuse = true)");
    /* Free the call's connection early. */
    ref.getChannel().free(conn, true);
    return returnValue;

    } catch (IOException e) {
    clientRefLog.log(Log.BRIEF,
             "IOException unmarshalling return: ", e);
    throw new UnmarshalException("error unmarshalling return", e);
    } catch (ClassNotFoundException e) {
    clientRefLog.log(Log.BRIEF,
        "ClassNotFoundException unmarshalling return: ", e);
    throw new UnmarshalException("error unmarshalling return", e);
    } finally {
    try {
        call.done();
    } catch (IOException e) {
        /* WARNING: If the conn has been reused early,
         * then it is too late to recover from thrown
         * IOExceptions caught here. This code is relying
         * on StreamRemoteCall.done() not actually
         * throwing IOExceptions.
         */
        reuse = false;
    }
    }
} catch (RuntimeException e) {
    /*
     * Need to distinguish between client (generated by the
     * invoke method itself) and server RuntimeExceptions.
     * Client side RuntimeExceptions are likely to have
     * corrupted the call connection and those from the server
     * are not likely to have done so.  If the exception came
     * from the server the call connection should be reused.
     */
    if ((call == null) ||
    (((StreamRemoteCall) call).getServerException() != e))
           {
    reuse = false;
    }
    throw e;
} catch (RemoteException e) {
    /*
     * Some failure during call; assume connection cannot
     * be reused.  Must assume failure even if ServerException
     * or ServerError occurs since these failures can happen
     * during parameter deserialization which would leave
     * the connection in a corrupted state.
     */
    reuse = false;
    throw e;
} catch (Error e) {
    /* If errors occurred, the connection is most likely not
            *  reusable.
     */
    reuse = false;
    throw e;
} finally {
    /* alreadyFreed ensures that we do not log a reuse that
     * may have already happened.
     */
    if (!alreadyFreed) {
    if (clientRefLog.isLoggable(Log.BRIEF)) {
        clientRefLog.log(Log.BRIEF, "free connection (reuse = " +
                   reuse + ")");
    }
    ref.getChannel().free(conn, reuse);
    }
}
   }

 

2 RMI线程模型

  在JDK1.5及以前版本中，RMI每接收一个远程方法调用就生成一个单独的线程来处理这个请求，请求处理完成后，这个线程就会释放：

 

Thread t = (Thread)
            java.security.AccessController.doPrivileged (
                new NewThreadAction(new ConnectionHandler(socket,
                                  clientHost),
                        "TCP Connection(" + ++ threadNum +
                        ")-" + clientHost,
                        true, true));

 

   在JDK1.6之后，RMI使用线程池来处理新接收的远程方法调用请求-ThreadPoolExecutor。

  下面是一个简单的RMI程序的执行线程抓图，我们可以更好的了解RMI的线程机制。这个简单的RMI程序是服务端有一个远程方法实现，一个客户端同时请求执行这个远程方法100次。在JDK1.5中执行时生成的线程如下图所示，每个方法调用请求都是在一个单独的线程里执行，即 A Thread per Request。

在JDK1.6中执行时生成的线程如下图所示，这些线程都是在ThreadPoolExecutor线程池中执行的。

3 RMI线程池参数

  在JDK1.6中，RMI提供了可配置的线程池参数属性：

sun.rmi.transport.tcp.maxConnectionThread - 线程池中的最大线程数量

sun.rmi.transport.tcp.threadKeepAliveTime - 线程池中空闲的线程存活时间

 

转自：http://blog.csdn.net/sureyonder/article/details/5653609