java用Socket实现的远程桌面浏览&n…

转自http://fluagen.blog.51cto.com/146595/425818

用socket做长连接时，出现了内存溢出的错误。搞了4天的时间总算是搞定了。

现总结下：

1.socket一般分为短连接和长连接。

长连接是一旦一个客户端登陆上服务器，其与服务器之间的连接就不关闭，不管他们之间进行了多少次交易，直到客户端退出登陆或网络出现故障。这种技术在联机交易系统实现有利于提高效率。  
 短连接是客户端每发一个请求就与服务器建立一个连接，交易完成后关闭连接，这种技术实现较长连接简单。

长:connect连上后不断开,  进行N次收发操作.  

 短:每次都connect,  完成任务后立即断开.  下次重连.  
   
 一般都是accept后启动一个线程去处理，该线程中的处理大致如下  
   
  短连接：  
  run(){  
     read          //读取请求包  
     process    //处理  
     write        //应答处理结果  
  }  
   
  长连接：  
  run(){  
   while(NotEnd){  
       read  
       process  
       write  
     }  
  }

2.短连接进行一次连接做完业务逻辑处理后就关闭连接，关闭了socket连接也就释放了socket所占用的资源，所以不会出现内存溢出的问题。

长连接一般是连接上服务器后，会做一个循环的业务逻辑处理。如果这个时候我们不得不在循环里创建对象发送到服务器端做处理然后服务器端（反之亦然），那么就有可能出现内存溢出的问题。

例如下面实现的远程桌面的程序:

服务器端

 

1. com.hjdf.calis.cvrs.util.CvrsSystem.println(serverPort + " 等待连接中......"); 
2.                 serverSkt.setSoTimeout(10*60*1000);//服务器端的超时时间 
3.                 clientSkt = serverSkt.accept(); 
4.                 com.hjdf.calis.cvrs.util.CvrsSystem.println(serverPort+"与" + 
5.                             clientSkt.getInetAddress() + " 建立连接"); 
6.                 clientSkt.setSoTimeout(60*1000);//客户端的超时时间 
7.                 ObjectOutputStream out = new ObjectOutputStream(clientSkt.getOutputStream()); 
8.                 ObjectInputStream  in= new ObjectInputStream(clientSkt.getInputStream()); 
9.  
10.             ObjectOutputStream pipeout = new ObjectOutputStream(outputstream); 
11.              ObjectInputStream  pipein = new ObjectInputStream(inputstream); 
12.              String pipstr="GET"; 
13.              if(iswrite){ 
14.               pipstr = (String) pipein.readObject(); 
15.                if (pipstr != null) { 
16.                  out.writeObject(pipstr); 
17.                } 
18.                iswrite =false; 
19.              }else{ 
20.               out.writeObject(pipstr); 
21.               out.flush(); 
22.              } 
23.                ScreenImageInfo screenInfo= (ScreenImageInfo)in.readObject(); 
24.                 while(screenInfo!=null){ 
25.                   pipeout.writeObject(screenInfo); 
26.                   if(iswrite){ 
27.                    pipstr = (String) pipein.readObject(); 
28.                     if (pipstr != null) { 
29.                       out.writeObject(pipstr); 
30.                     } 
31.                     iswrite =false; 
32.                   }else{ 
33.                    out.writeObject(pipstr); 
34.                    out.flush(); 
35.                   } 
36.                      screenInfo= (ScreenImageInfo)in.readObject(); 
37.  
38.                 } 

 

客户端

 

 

1. ObjectInputStream  in= new ObjectInputStream(clientSkt.getInputStream()); 
2.         Toolkit toolkit = Toolkit.getDefaultToolkit(); 
3.         Dimension screenSize = toolkit.getScreenSize(); 
4.         Rectangle screenRect = new Rectangle(screenSize); 
5.         Robot robot = new Robot(); 
6.         ObjectOutputStream out = new ObjectOutputStream(clientSkt.getOutputStream()); 
7.         while ( (clientCom = (String) in.readObject()) != null) { 
8.  
9.           if (clientCom.equals("GET")) { 
10.                 BufferedImage image = robot.createScreenCapture(screenRect); 
11.                 ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream(); 
12.                 JPEGImageEncoder encoder = 
13.                     JPEGCodec.createJPEGEncoder(byteOutStream); 
14.  
15.                 JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(image); 
16.                 param.setQuality(0.5f, false); 
17.                 encoder.setJPEGEncodeParam(param); 
18.                 encoder.encode(image); 
19.                 ScreenImageInfo imageInfo = 
20.                     new ScreenImageInfo(byteOutStream.toByteArray()); 
21.                 out.writeObject(imageInfo); 
22.           } 
23.         } 

 上面的客户端循环的创建对象，服务器端循环的读出。由于socket流一直没有得到释放，socket流中会一直持有新创建的ScreenImageInfo对象的引用，这样java的垃圾回收器不会回收循环创建的对象，导致内存溢出。

修改服务器端和客户端，解决内存溢出：

服务器

 

1. com.hjdf.calis.cvrs.util.CvrsSystem.println(serverPort + " 等待连接中......"); 
2.                 serverSkt.setSoTimeout(10*60*1000);//服务器端的超时时间 
3.                 clientSkt = serverSkt.accept(); 
4.                 com.hjdf.calis.cvrs.util.CvrsSystem.println(serverPort+"与" + 
5.                             clientSkt.getInetAddress() + " 建立连接"); 
6.                 clientSkt.setSoTimeout(60*1000);//客户端的超时时间 
7.                  
8.                 while(true){ 
9.                     ObjectInputStream  in= new ObjectInputStream(clientSkt.getInputStream()); 
10.                     ObjectOutputStream pipeout = new ObjectOutputStream(outputstream); 
11.                     ScreenImageInfo screenInfo= (ScreenImageInfo)in.readObject(); 
12.                     if(screenInfo!=null){ 
13.                       pipeout.writeObject(screenInfo); 
14.                     } 
15.                 } 

客户端

1. Toolkit toolkit = Toolkit.getDefaultToolkit(); 
2.         Dimension screenSize = toolkit.getScreenSize(); 
3.         Rectangle screenRect = new Rectangle(screenSize); 
4.         Robot robot = new Robot(); 
5.         while(true){ 
6.             ObjectOutputStream out = new ObjectOutputStream(clientSkt.getOutputStream()); 
7.           BufferedImage image = robot.createScreenCapture(screenRect); 
8.           ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream(); 
9.           JPEGImageEncoder encoder = 
10.               JPEGCodec.createJPEGEncoder(byteOutStream); 
11.  
12.           JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(image); 
13.           param.setQuality(0.5f, false); 
14.           encoder.setJPEGEncodeParam(param); 
15.           encoder.encode(image); 
16.           ScreenImageInfo imageInfo = 
17.               new ScreenImageInfo(byteOutStream.toByteArray()); 
18.           out.writeObject(imageInfo); 
19.         } 

 修改后的服务器端和客户端socket，虽然也没有一直得到释放，但是ObjectInputStream in= newObjectInputStream(clientSkt.getInputStream());和ObjectOutputStreamout = newObjectOutputStream(clientSkt.getOutputStream());在循环中每次都会生成新的ObjectInputStream  和ObjectOutputStream对象，并且该对象的引用也不会被socket所持有。所以java的垃圾回收器可以回收这些对象，不会出现内存溢出的问题。