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。skeleton负责将调用分配给实际的远程对象实现。它在接收方法调用时执行下列操作：

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

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

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

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

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

[java] view plain copy

1. publicvoidexportObject(Targettarget)throwsRemoteException{
3. //othercode
5. while(true){
6. ServerSocketmyServer=server;
7. if(myServer==null)
8. return;
9. ThrowableacceptFailure=null;
10. finalSocketsocket;
12. try{
13. socket=myServer.accept();
15. /*
16. *Findclienthostname(or"0.0.0.0"ifunknown)
17. */
18. InetAddressclientAddr=socket.getInetAddress();
19. StringclientHost=(clientAddr!=null
20. ?clientAddr.getHostAddress()
21. :"0.0.0.0");
23. /*
24. *Spawnnon-systemthreadtohandletheconnection
25. */
26. Threadt=(Thread)
27. java.security.AccessController.doPrivileged(
28. newNewThreadAction(newConnectionHandler(socket,
29. clientHost),
30. "TCPConnection("+++threadNum+
31. ")-"+clientHost,
32. true,true));
33. t.start();
35. }catch(IOExceptione){
36. acceptFailure=e;
37. }catch(RuntimeExceptione){
38. acceptFailure=e;
39. }catch(Errore){
40. acceptFailure=e;
41. }
42. }
44. //othercode

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

[java] view plain copy

1. publicvoiddispatch(Remoteobj,RemoteCallcall)throwsIOException{
2. //positiveoperationnumberin1.1stubs;
3. //negativeversionnumberin1.2stubsandbeyond...
4. intnum;
5. longop;
6. try{
7. //readremotecallheader
8. ObjectInputin;
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. thrownewUnmarshalException(
18. "skeletonclassnotfoundbutrequired"+
19. "forclientversion");
20. }
21. }
22. op=in.readLong();
23. }catch(ExceptionreadEx){
24. thrownewUnmarshalException("errorunmarshallingcallheader",
25. readEx);
26. }
27. /*
28. *Sinceonlysystemclasses(withnullclassloaders)willbeon
29. *theexecutionstackduringparameterunmarshallingforthe1.2
30. *stubprotocol,telltheMarshalInputStreamnottobothertrying
31. *toresolveclassesusingitssuperclasses'sdefaultmethodof
32. *consultingthefirstnon-nullclassloaderonthestack.
33. */
34. MarshalInputStreammarshalStream=(MarshalInputStream)in;
35. marshalStream.skipDefaultResolveClass();
36. Methodmethod=(Method)hashToMethod_Map.get(newLong(op));
37. if(method==null){
38. thrownewUnmarshalException("invalidmethodhash");
39. }
40. //ifcallsarebeinglogged,writeoutobjectidandoperation
41. logCall(obj,method);
42. //unmarshalparameters
43. Class[]types=method.getParameterTypes();
44. Object[]params=newObject[types.length];
45. try{
46. unmarshalCustomCallData(in);
47. for(inti=0;i<types.length;i++){
48. params[i]=unmarshalValue(types[i],in);
49. }
50. }catch(java.io.IOExceptione){
51. thrownewUnmarshalException(
52. "errorunmarshallingarguments",e);
53. }catch(ClassNotFoundExceptione){
54. thrownewUnmarshalException(
55. "errorunmarshallingarguments",e);
56. }finally{
57. call.releaseInputStream();
58. }
59. //makeupcallonremoteobject
60. Objectresult;
61. try{
62. result=method.invoke(obj,params);
63. }catch(InvocationTargetExceptione){
64. throwe.getTargetException();
65. }
66. //marshalreturnvalue
67. try{
68. ObjectOutputout=call.getResultStream(true);
69. Classrtype=method.getReturnType();
70. if(rtype!=void.class){
71. marshalValue(rtype,result,out);
72. }
73. }catch(IOExceptionex){
74. thrownewMarshalException("errormarshallingreturn",ex);
75. /*
76. *Thisthrowisproblematicbecausewhenitiscaughtbelow,
77. *weattempttomarshalitbacktotheclient,butatthis
78. *point,a"normalreturn"hasalreadybeenindicated,
79. *somarshallinganexceptionwillcorruptthestream.
80. *Thiswasthecasewithskeletonsaswell;thereisno
81. *immediatelyobvioussolutionwithoutaprotocolchange.
82. */
83. }
84. }catch(Throwablee){
85. logCallException(e);
87. ObjectOutputout=call.getResultStream(false);
88. if(einstanceofError){
89. e=newServerError(
90. "Erroroccurredinserverthread",(Error)e);
91. }elseif(einstanceofRemoteException){
92. e=newServerException(
93. "RemoteExceptionoccurredinserverthread",
94. (Exception)e);
95. }
96. if(suppressStackTraces){
97. clearStackTraces(e);
98. }
99. out.writeObject(e);
100. }finally{
101. call.releaseInputStream();//incaseskeletondoesn't
102. call.releaseOutputStream();
103. }
104. }
105. protectedstaticvoidmarshalValue(Classtype,Objectvalue,
106. ObjectOutputout)
107. throwsIOException
108. {
109. if(type.isPrimitive()){
110. if(type==int.class){
111. out.writeInt(((Integer)value).intValue());
112. }elseif(type==boolean.class){
113. out.writeBoolean(((Boolean)value).booleanValue());
114. }elseif(type==byte.class){
115. out.writeByte(((Byte)value).byteValue());
116. }elseif(type==char.class){
117. out.writeChar(((Character)value).charValue());
118. }elseif(type==short.class){
119. out.writeShort(((Short)value).shortValue());
120. }elseif(type==long.class){
121. out.writeLong(((Long)value).longValue());
122. }elseif(type==float.class){
123. out.writeFloat(((Float)value).floatValue());
124. }elseif(type==double.class){
125. out.writeDouble(((Double)value).doubleValue());
126. }else{
127. thrownewError("Unrecognizedprimitivetype:"+type);
128. }
129. }else{
130. out.writeObject(value);
131. }
132. }
133. rotectedstaticObjectunmarshalValue(Classtype,ObjectInputin)
134. throwsIOException,ClassNotFoundException
135. {
136. if(type.isPrimitive()){
137. if(type==int.class){
138. returnnewInteger(in.readInt());
139. }elseif(type==boolean.class){
140. returnnewBoolean(in.readBoolean());
141. }elseif(type==byte.class){
142. returnnewByte(in.readByte());
143. }elseif(type==char.class){
144. returnnewCharacter(in.readChar());
145. }elseif(type==short.class){
146. returnnewShort(in.readShort());
147. }elseif(type==long.class){
148. returnnewLong(in.readLong());
149. }elseif(type==float.class){
150. returnnewFloat(in.readFloat());
151. }elseif(type==double.class){
152. returnnewDouble(in.readDouble());
153. }else{
154. thrownewError("Unrecognizedprimitivetype:"+type);
155. }
156. }else{
157. returnin.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 plain copy

1. publicObjectinvoke(Remoteobj,
2. java.lang.reflect.Methodmethod,
3. Object[]params,
4. longopnum)
5. throwsException
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. }
14. Connectionconn=ref.getChannel().newConnection();
15. RemoteCallcall=null;
16. booleanreuse=true;
17. /*Ifthecallconnectionis"reused"early,remembernotto
18. *reuseagain.
19. */
20. booleanalreadyFreed=false;
21. try{
22. if(clientRefLog.isLoggable(Log.VERBOSE)){
23. clientRefLog.log(Log.VERBOSE,"opnum="+opnum);
24. }
25. //createcallcontext
26. call=newStreamRemoteCall(conn,ref.getObjID(),-1,opnum);
27. //marshalparameters
28. try{
29. ObjectOutputout=call.getOutputStream();
30. marshalCustomCallData(out);
31. Class[]types=method.getParameterTypes();
32. for(inti=0;i<types.length;i++){
33. marshalValue(types[i],params[i],out);
34. }
35. }catch(IOExceptione){
36. clientRefLog.log(Log.BRIEF,
37. "IOExceptionmarshallingarguments:",e);
38. thrownewMarshalException("errormarshallingarguments",e);
39. }
40. //unmarshalreturn
41. call.executeCall();
42. try{
43. Classrtype=method.getReturnType();
44. if(rtype==void.class)
45. returnnull;
46. ObjectInputin=call.getInputStream();
48. /*StreamRemoteCall.done()doesnotactuallymakeuse
49. *ofconn,thereforeitissafetoreusethis
50. *connectionbeforethedirtycallissentfor
51. *registeredrefs.
52. */
53. ObjectreturnValue=unmarshalValue(rtype,in);
54. /*wearefreeingtheconnectionnow,donotfree
55. *againorreuse.
56. */
57. alreadyFreed=true;
58. /*ifwegottothispoint,reusemusthavebeentrue.*/
59. clientRefLog.log(Log.BRIEF,"freeconnection(reuse=true)");
60. /*Freethecall'sconnectionearly.*/
61. ref.getChannel().free(conn,true);
62. returnreturnValue;
64. }catch(IOExceptione){
65. clientRefLog.log(Log.BRIEF,
66. "IOExceptionunmarshallingreturn:",e);
67. thrownewUnmarshalException("errorunmarshallingreturn",e);
68. }catch(ClassNotFoundExceptione){
69. clientRefLog.log(Log.BRIEF,
70. "ClassNotFoundExceptionunmarshallingreturn:",e);
71. thrownewUnmarshalException("errorunmarshallingreturn",e);
72. }finally{
73. try{
74. call.done();
75. }catch(IOExceptione){
76. /*WARNING:Iftheconnhasbeenreusedearly,
77. *thenitistoolatetorecoverfromthrown
78. *IOExceptionscaughthere.Thiscodeisrelying
79. *onStreamRemoteCall.done()notactually
80. *throwingIOExceptions.
81. */
82. reuse=false;
83. }
84. }
85. }catch(RuntimeExceptione){
86. /*
87. *Needtodistinguishbetweenclient(generatedbythe
88. *invokemethoditself)andserverRuntimeExceptions.
89. *ClientsideRuntimeExceptionsarelikelytohave
90. *corruptedthecallconnectionandthosefromtheserver
91. *arenotlikelytohavedoneso.Iftheexceptioncame
92. *fromtheserverthecallconnectionshouldbereused.
93. */
94. if((call==null)||
95. (((StreamRemoteCall)call).getServerException()!=e))
96. {
97. reuse=false;
98. }
99. throwe;
100. }catch(RemoteExceptione){
101. /*
102. *Somefailureduringcall;assumeconnectioncannot
103. *bereused.MustassumefailureevenifServerException
104. *orServerErroroccurssincethesefailurescanhappen
105. *duringparameterdeserializationwhichwouldleave
106. *theconnectioninacorruptedstate.
107. */
108. reuse=false;
109. throwe;
110. }catch(Errore){
111. /*Iferrorsoccurred,theconnectionismostlikelynot
112. *reusable.
113. */
114. reuse=false;
115. throwe;
116. }finally{
117. /*alreadyFreedensuresthatwedonotlogareusethat
118. *mayhavealreadyhappened.
119. */
120. if(!alreadyFreed){
121. if(clientRefLog.isLoggable(Log.BRIEF)){
122. clientRefLog.log(Log.BRIEF,"freeconnection(reuse="+
123. reuse+")");
124. }
125. ref.getChannel().free(conn,reuse);
126. }
127. }
128. }

2 RMI线程模型

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

[java] view plain copy

1. Threadt=(Thread)
2. java.security.AccessController.doPrivileged(
3. newNewThreadAction(newConnectionHandler(socket,
4. clientHost),
5. "TCPConnection("+++threadNum+
6. ")-"+clientHost,
7. 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