`

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端口上的方法调用请求:

 

[java] view plaincopy
  1. public void exportObject(Target target) throws RemoteException {  
  2.     
  3.   // other code  
  4.     
  5. while (true) {  
  6.     ServerSocket myServer = server;  
  7.     if (myServer == null)  
  8.       return;  
  9.     Throwable acceptFailure = null;  
  10.     final Socket socket;  
  11.       
  12.     try {  
  13.     socket = myServer.accept();  
  14.       
  15.     /* 
  16.      * Find client host name (or "0.0.0.0" if unknown) 
  17.      */  
  18.     InetAddress clientAddr = socket.getInetAddress();  
  19.     String clientHost = (clientAddr != null  
  20.                  ? clientAddr.getHostAddress()  
  21.                  : "0.0.0.0");  
  22.       
  23.     /* 
  24.      * Spawn non-system thread to handle the connection 
  25.      */  
  26.     Thread t = (Thread)  
  27.         java.security.AccessController.doPrivileged (  
  28.             new NewThreadAction(new ConnectionHandler(socket,  
  29.                               clientHost),  
  30.                     "TCP Connection(" + ++ threadNum +  
  31.                     ")-" + clientHost,  
  32.                     truetrue));  
  33.     t.start();  
  34.       
  35.     } catch (IOException e) {  
  36.     acceptFailure = e;  
  37.     } catch (RuntimeException e) {  
  38.     acceptFailure = e;  
  39.     } catch (Error e) {  
  40.     acceptFailure = e;  
  41.     }  
  42. }  
  43.   
  44. // other code  

 

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

 

[java] view plaincopy
  1. public void dispatch(Remote obj, RemoteCall call) throws IOException {  
  2. // positive operation number in 1.1 stubs;  
  3. // negative version number in 1.2 stubs and beyond...  
  4. int num;  
  5. long op;  
  6. try {  
  7.     // read remote call header  
  8.     ObjectInput in;  
  9.     try {  
  10.     in = call.getInputStream();  
  11.     num = in.readInt();  
  12.     if (num >= 0) {  
  13.         if (skel != null) {  
  14.         oldDispatch(obj, call, num);  
  15.         return;  
  16.         } else {  
  17.         throw new UnmarshalException(  
  18.             "skeleton class not found but required " +  
  19.             "for client version");  
  20.         }  
  21.     }  
  22.     op = in.readLong();  
  23.     } catch (Exception readEx) {  
  24.     throw new UnmarshalException("error unmarshalling call header",  
  25.                      readEx);  
  26.     }  
  27.     /* 
  28.      * Since only system classes (with null class loaders) will be on 
  29.      * the execution stack during parameter unmarshalling for the 1.2 
  30.      * stub protocol, tell the MarshalInputStream not to bother trying 
  31.      * to resolve classes using its superclasses's default method of 
  32.      * consulting the first non-null class loader on the stack. 
  33.      */  
  34.     MarshalInputStream marshalStream = (MarshalInputStream) in;  
  35.     marshalStream.skipDefaultResolveClass();  
  36.     Method method = (Method) hashToMethod_Map.get(new Long(op));  
  37.     if (method == null) {  
  38.     throw new UnmarshalException("invalid method hash");  
  39.     }  
  40.     // if calls are being logged, write out object id and operation  
  41.     logCall(obj, method);  
  42.     // unmarshal parameters  
  43.     Class[] types = method.getParameterTypes();  
  44.     Object[] params = new Object[types.length];  
  45.     try {  
  46.     unmarshalCustomCallData(in);  
  47.     for (int i = 0; i < types.length; i++) {  
  48.         params[i] = unmarshalValue(types[i], in);  
  49.     }  
  50.     } catch (java.io.IOException e) {  
  51.     throw new UnmarshalException(  
  52.         "error unmarshalling arguments", e);  
  53.     } catch (ClassNotFoundException e) {  
  54.     throw new UnmarshalException(  
  55.         "error unmarshalling arguments", e);  
  56.     } finally {  
  57.     call.releaseInputStream();  
  58.     }  
  59.     // make upcall on remote object  
  60.     Object result;  
  61.     try {  
  62.     result = method.invoke(obj, params);  
  63.     } catch (InvocationTargetException e) {  
  64.     throw e.getTargetException();  
  65.     }  
  66.     // marshal return value  
  67.     try {  
  68.     ObjectOutput out = call.getResultStream(true);  
  69.     Class rtype = method.getReturnType();  
  70.     if (rtype != void.class) {  
  71.         marshalValue(rtype, result, out);  
  72.     }  
  73.     } catch (IOException ex) {  
  74.     throw new MarshalException("error marshalling return", ex);  
  75.     /* 
  76.      * This throw is problematic because when it is caught below, 
  77.      * we attempt to marshal it back to the client, but at this 
  78.      * point, a "normal return" has already been indicated, 
  79.      * so marshalling an exception will corrupt the stream. 
  80.      * This was the case with skeletons as well; there is no 
  81.      * immediately obvious solution without a protocol change. 
  82.      */  
  83.     }  
  84. catch (Throwable e) {  
  85.     logCallException(e);  
  86.       
  87.     ObjectOutput out = call.getResultStream(false);  
  88.     if (e instanceof Error) {  
  89.     e = new ServerError(  
  90.         "Error occurred in server thread", (Error) e);  
  91.     } else if (e instanceof RemoteException) {  
  92.     e = new ServerException(  
  93.         "RemoteException occurred in server thread",  
  94.         (Exception) e);  
  95.     }  
  96.     if (suppressStackTraces) {  
  97.     clearStackTraces(e);  
  98.     }  
  99.     out.writeObject(e);  
  100. finally {  
  101.     call.releaseInputStream(); // in case skeleton doesn't  
  102.     call.releaseOutputStream();  
  103. }  
  104.    }  
  105. protected static void marshalValue(Class type, Object value,  
  106.                    ObjectOutput out)  
  107. throws IOException  
  108.    {  
  109. if (type.isPrimitive()) {  
  110.     if (type == int.class) {  
  111.     out.writeInt(((Integer) value).intValue());  
  112.     } else if (type == boolean.class) {  
  113.     out.writeBoolean(((Boolean) value).booleanValue());  
  114.     } else if (type == byte.class) {  
  115.     out.writeByte(((Byte) value).byteValue());  
  116.     } else if (type == char.class) {  
  117.     out.writeChar(((Character) value).charValue());  
  118.     } else if (type == short.class) {  
  119.     out.writeShort(((Short) value).shortValue());  
  120.     } else if (type == long.class) {  
  121.     out.writeLong(((Long) value).longValue());  
  122.     } else if (type == float.class) {  
  123.     out.writeFloat(((Float) value).floatValue());  
  124.     } else if (type == double.class) {  
  125.     out.writeDouble(((Double) value).doubleValue());  
  126.     } else {  
  127.     throw new Error("Unrecognized primitive type: " + type);  
  128.     }  
  129. else {  
  130.     out.writeObject(value);  
  131. }  
  132.    }  
  133. rotected static Object unmarshalValue(Class type, ObjectInput in)  
  134. throws IOException, ClassNotFoundException  
  135.    {  
  136. if (type.isPrimitive()) {  
  137.     if (type == int.class) {  
  138.     return new Integer(in.readInt());  
  139.     } else if (type == boolean.class) {  
  140.     return new Boolean(in.readBoolean());  
  141.     } else if (type == byte.class) {  
  142.     return new Byte(in.readByte());  
  143.     } else if (type == char.class) {  
  144.     return new Character(in.readChar());  
  145.     } else if (type == short.class) {  
  146.     return new Short(in.readShort());  
  147.     } else if (type == long.class) {  
  148.     return new Long(in.readLong());  
  149.     } else if (type == float.class) {  
  150.     return new Float(in.readFloat());  
  151.     } else if (type == double.class) {  
  152.     return new Double(in.readDouble());  
  153.     } else {  
  154.     throw new Error("Unrecognized primitive type: " + type);  
  155.     }  
  156. else {  
  157.     return in.readObject();  
  158. }  
  159.    }  

 

   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)。

 

[java] view plaincopy
  1.  public Object invoke(Remote obj,  
  2.          java.lang.reflect.Method method,  
  3.          Object[] params,  
  4.          long opnum)  
  5. throws Exception  
  6.    {  
  7. if (clientRefLog.isLoggable(Log.VERBOSE)) {  
  8.     clientRefLog.log(Log.VERBOSE, "method: " + method);  
  9. }  
  10. if (clientCallLog.isLoggable(Log.VERBOSE)) {  
  11.     logClientCall(obj, method);  
  12. }  
  13.   
  14. Connection conn = ref.getChannel().newConnection();  
  15. RemoteCall call = null;  
  16. boolean reuse = true;  
  17. /* If the call connection is "reused" early, remember not to 
  18.  * reuse again. 
  19.  */  
  20. boolean alreadyFreed = false;  
  21. try {  
  22.     if (clientRefLog.isLoggable(Log.VERBOSE)) {  
  23.     clientRefLog.log(Log.VERBOSE, "opnum = " + opnum);  
  24.     }  
  25.     // create call context  
  26.     call = new StreamRemoteCall(conn, ref.getObjID(), -1, opnum);  
  27.     // marshal parameters  
  28.     try {  
  29.     ObjectOutput out = call.getOutputStream();  
  30.     marshalCustomCallData(out);  
  31.     Class[] types = method.getParameterTypes();  
  32.     for (int i = 0; i < types.length; i++) {   
  33.         marshalValue(types[i], params[i], out);  
  34.     }  
  35.     } catch (IOException e) {  
  36.     clientRefLog.log(Log.BRIEF,  
  37.         "IOException marshalling arguments: ", e);  
  38.     throw new MarshalException("error marshalling arguments", e);  
  39.     }  
  40.     // unmarshal return  
  41.     call.executeCall();  
  42.     try {  
  43.     Class rtype = method.getReturnType();  
  44.     if (rtype == void.class)  
  45.         return null;  
  46.     ObjectInput in = call.getInputStream();  
  47.       
  48.     /* StreamRemoteCall.done() does not actually make use 
  49.      * of conn, therefore it is safe to reuse this 
  50.      * connection before the dirty call is sent for 
  51.      * registered refs.   
  52.      */  
  53.     Object returnValue = unmarshalValue(rtype, in);  
  54.     /* we are freeing the connection now, do not free 
  55.      * again or reuse. 
  56.      */  
  57.     alreadyFreed = true;  
  58.     /* if we got to this point, reuse must have been true. */  
  59.     clientRefLog.log(Log.BRIEF, "free connection (reuse = true)");  
  60.     /* Free the call's connection early. */  
  61.     ref.getChannel().free(conn, true);  
  62.     return returnValue;  
  63.       
  64.     } catch (IOException e) {  
  65.     clientRefLog.log(Log.BRIEF,  
  66.              "IOException unmarshalling return: ", e);  
  67.     throw new UnmarshalException("error unmarshalling return", e);  
  68.     } catch (ClassNotFoundException e) {  
  69.     clientRefLog.log(Log.BRIEF,  
  70.         "ClassNotFoundException unmarshalling return: ", e);  
  71.     throw new UnmarshalException("error unmarshalling return", e);  
  72.     } finally {  
  73.     try {  
  74.         call.done();  
  75.     } catch (IOException e) {  
  76.         /* WARNING: If the conn has been reused early, 
  77.          * then it is too late to recover from thrown 
  78.          * IOExceptions caught here. This code is relying 
  79.          * on StreamRemoteCall.done() not actually 
  80.          * throwing IOExceptions.   
  81.          */  
  82.         reuse = false;  
  83.     }  
  84.     }  
  85. catch (RuntimeException e) {  
  86.     /* 
  87.      * Need to distinguish between client (generated by the 
  88.      * invoke method itself) and server RuntimeExceptions. 
  89.      * Client side RuntimeExceptions are likely to have 
  90.      * corrupted the call connection and those from the server 
  91.      * are not likely to have done so.  If the exception came 
  92.      * from the server the call connection should be reused. 
  93.      */  
  94.     if ((call == null) ||   
  95.     (((StreamRemoteCall) call).getServerException() != e))  
  96.            {  
  97.     reuse = false;  
  98.     }  
  99.     throw e;  
  100. catch (RemoteException e) {  
  101.     /* 
  102.      * Some failure during call; assume connection cannot 
  103.      * be reused.  Must assume failure even if ServerException 
  104.      * or ServerError occurs since these failures can happen 
  105.      * during parameter deserialization which would leave 
  106.      * the connection in a corrupted state. 
  107.      */  
  108.     reuse = false;  
  109.     throw e;  
  110. catch (Error e) {  
  111.     /* If errors occurred, the connection is most likely not 
  112.             *  reusable.  
  113.      */  
  114.     reuse = false;  
  115.     throw e;  
  116. finally {  
  117.     /* alreadyFreed ensures that we do not log a reuse that 
  118.      * may have already happened. 
  119.      */  
  120.     if (!alreadyFreed) {  
  121.     if (clientRefLog.isLoggable(Log.BRIEF)) {  
  122.         clientRefLog.log(Log.BRIEF, "free connection (reuse = " +  
  123.                    reuse + ")");  
  124.     }  
  125.     ref.getChannel().free(conn, reuse);  
  126.     }  
  127. }  
  128.    }  

 

2 RMI线程模型

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

 

[java] view plaincopy
  1. Thread t = (Thread)  
  2.             java.security.AccessController.doPrivileged (  
  3.                 new NewThreadAction(new ConnectionHandler(socket,  
  4.                                   clientHost),  
  5.                         "TCP Connection(" + ++ threadNum +  
  6.                         ")-" + clientHost,  
  7.                         truetrue));  

 

   在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

分享到:
评论

相关推荐

    Rmi.rar_Java RMI_RMI java_java RMI 线程_rmi

    8. **安全性(Security)**:RMI支持基于Java Security Manager的安全模型,可以通过设置策略文件控制客户端和服务器之间的权限。 9. **性能优化(Performance Optimization)**:RMI提供了许多优化手段,如持久化...

    Java RMI中文规范

    RMI是Java 1.1及更高版本的标准组成部分,确保了在任何支持JVM的系统间无缝通信。 1.1 背景 分布计算是指程序、数据和计算分布在广泛网络上的编程模式,旨在平衡计算资源,适应应用程序需求。分布式对象技术,如...

    JAVA RMI.rar_Java RMI_ME_RMI java_rmi

    4. **序列化**:由于Java对象不能直接在网络上传输,RMI使用Java的序列化机制将对象转换为字节流,然后在网络上传输,到达目的地后再反序列化恢复。 5. **异常处理**:RMI支持跨网络的异常处理,如果远程方法抛出...

    客户端服务器,多线程服务器,远程RMI会议

    综上所述,这个上机实验旨在让学生掌握Java中实现客户端-服务器通信、构建多线程服务器以及利用RMI进行远程调用的关键技能。通过实践,学生将能够理解这些核心概念,并能够在实际项目中应用。文件列表中的"客户端...

    RMI规范说明.rar_Java RMI_RMI java_rmi

    6. **安全性**:RMI支持标准的Java安全模型,可以控制客户端对远程对象的访问权限。通过策略文件,可以设定远程方法调用的安全策略。 7. **异常处理**:由于网络通信的不可靠性,RMI调用可能会抛出各种异常,如...

    编写简单的RMI程序 多线程web 服务器

    多线程模型则允许多个请求同时处理,提高了服务器的并发能力。在实现多线程Web服务器时,我们需要创建一个主线程池,用于接收新的连接请求,然后将每个请求分配给一个工作线程来处理。每个工作线程负责读取请求、...

    java-rmi.zip_RMI java_rmi

    Java Remote Method Invocation (RMI) 是Java编程语言中的一种机制,允许在不同的Java虚拟机(JVM)之间进行远程调用。"java-rmi.zip_RMI java_rmi"这个文件很可能是包含了一些关于RMI实现的示例代码或库文件。RMI在...

    javaRMI规范.pdf

    由于RMI是Java平台的标准组成部分,它在所有1.1及更高版本的Java虚拟机中都可用,且所有RMI系统使用相同的公开协议,实现了跨Java系统间的无缝通信。 综上所述,Java RMI是Java平台中实现分布式计算的一种强大工具...

    Java RMI开发

    本资源是一个关于Java RMI的英文书籍,虽然没有标签,但可以预期它会涵盖RMI的基础概念、实现机制以及实际应用。 在Java RMI中,核心概念包括: 1. **远程接口(Remote Interface)**:这是定义远程方法的接口,...

    JAVA远程调用RMI与应用

    RMI,即远程方法调用,是Java平台提供的分布式计算模型,它允许Java对象跨网络进行方法调用,如同本地调用一样。RMI的实现基于Java的面向对象特性,能够传递完整的对象作为参数和返回值,而不仅仅是预定义的数据类型...

    使用RMI远程连接JVM.用JMX获取JVM的参数

    RMI是Java提供的一种机制,允许在不同JVM之间透明地调用对象的方法,就像这些对象都在同一台机器上一样。RMI的核心组件包括远程接口、远程实现和注册表。在"RMIClientFactory.java"中,可能包含了创建RMI客户端连接...

    RMI - Java远程方法调用

    Java Remote Method Invocation (RMI) 是Java平台提供的一种机制,允许在不同的Java虚拟机之间进行对象的方法调用,跨越网络连接。RMI是Java分布式计算的核心技术,它使得开发者能够构建分布式应用程序,使得代码...

    Java线程基础知识

    除JVM外,许多Java标准库组件,如AWT、Swing、servlet容器、应用程序服务器和RMI等,也会在内部创建和管理线程。 线程之所以在程序设计中扮演关键角色,主要是由于以下几个原因: 1. 提高用户界面(UI)的响应性:...

    编写简单的HTTP 1.0客户端/服务器程序:.编写多线程Web服务器:编写简单的RMI程序

    服务器需要监听特定端口,接收到请求后,创建新的线程来处理,从而避免了单线程模型中的阻塞问题。此外,还需注意线程安全和资源管理,防止死锁和竞态条件等并发问题。 最后,RMI(Remote Method Invocation)是...

    JAVA_API1.6文档(中文)

    java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类(字符串标记生成器、随机数生成器和位数组)。 java.util.concurrent 在并发编程中很常用的实用工具类...

    java高级教程分布式多线程中间件-网盘整理合集

    1. **并发编程**:深入解析Java并发模型,包括线程安全、并发控制、死锁避免等。 2. **多线程实践**:如何设计和实现高效的多线程程序,包括线程池的使用和优化。 3. **分布式架构**:介绍分布式系统的设计原则,...

    java的RMI

    Java的远程方法调用(Remote Method Invocation,简称RMI)是Java平台中一种用于实现分布式计算的技术。它允许Java对象在不同的JVM之间进行交互,仿佛这些对象都在同一个进程中一样。RMI是Java企业版(Java EE)的一...

    RMI.rar_remote

    远程方法调用(Remote Method Invocation,RMI)是Java编程语言中的一种机制,它允许一个对象的方法被运行在不同JVM(Java Virtual Machine)上的另一个对象调用。这个标题"RMI.rar_remote"暗示了这是一个关于Java ...

Global site tag (gtag.js) - Google Analytics