TCP使用中的多线程问题

　1、问题：一般的TCP程序在处理多线程情况时会出现问题：

　　　　如：有A、B两个客户端向服务器发送数据，当A客户端连接上以后被服务端获取到，服务端执行具体流程；这时B客户端连接，只有等待。

　　　　　　　　因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以暂时获取不到B客户端对象。

2、解决思路：
　　　服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

程序代码：

　　客户端：

1. class MyClient{
   
2.         public static void main(String args[]){
   
3.                 try {
   
4.                         Socket s = new Socket(InetAddress.getLocalHost().getHostAddress(),11001        );
   
5.                         FileInputStream ins = new FileInputStream("test/1.jpg");
   
6.                         OutputStream out = s.getOutputStream();
   
7.                         //BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
   
8.                         byte[] buf = new byte[1024];
   
9.                         int len = 0;
   
10.                         while((len = ins.read(buf))!= -1){
    
11.                                 out.write(buf, 0, len);
    
12.                         }
    
13.                        
    
14.                         s.shutdownOutput();//结束图片上传，读取服务器返回信息
    
15.                        
    
16. //                        String str = bufr.readLine();
    
17. //                        System.out.println(str);
    
18.                         InputStream in = s.getInputStream();
    
19.                         byte[] bytes = new byte[1024];
    
20.                         int lens = in.read(bytes);
    
21.                         System.out.println("服务器返回："+ new String(bytes,0,lens));
    
22.                        
    
23.                         ins.close();
    
24.                         s.close();
    
25.                                        
    
26.                 }  catch (Exception e) {
    
27.                         // TODO Auto-generated catch block
    
28.                         e.printStackTrace();
    
29.                 }
    
30.                
    
31.         }
    
32. }

复制代码

服务器端：

1. class ThreadServer{
   
2.         public static void main(String args[]){
   
3.                 try {
   
4.                         ServerSocket server = new ServerSocket(10001);
   
5.                        
   
6.                         while(true){  //注意：while中使用true，是因为accept方法为阻塞方法，不会导致程序无限循环
   
7.                                 Socket s = server.accept();
   
8.                                 new Thread(new PicThread(s)).start();
   
9.                         }
   
10.                 } catch (IOException e) {
    
11.                         // TODO Auto-generated catch block
    
12.                         e.printStackTrace();
    
13.                 }               
    
14.                
    
15.         }
    
16. }
    
17. 
    
18. class PicThread implements Runnable{//封装服务器端，实现单线程
    
19.         private Socket s;
    
20.         PicThread(Socket s){
    
21.                 this.s = s;
    
22.                
    
23.         }
    
24.        
    
25.         public void run(){//将客户端处理代码写run方法中
    
26.                 try {
    
27.                         InputStream in = s.getInputStream();
    
28.                         FileOutputStream fout = new FileOutputStream("Thread.jpg");
    
29.                         byte[] buf = new byte[1024];
    
30.                         int len = 0;
    
31.                         while((len=in.read(buf))!=-1){
    
32.                                 fout.write(buf,0,len);
    
33.                         }
    
34.                        
    
35.                         OutputStream out = s.getOutputStream();
    
36.                         byte[] bytes = "图片上传成功".getBytes();
    
37.                         out.write(bytes);
    
38.                        
    
39.                         fout.close();
    
40.                         s.close();
    
41.                        
    
42.                 } catch (Exception e) {
    
43.                         // TODO Auto-generated catch block
    
44.                         e.printStackTrace();
    
45.                 }
    
46.                
    
47.         }
    
48.        

复制代码

这样就实现了多客户端向服务器发送文件。

3、设计亮点

　　在这个TCP程序中十分巧妙的将服务器端将每一个客户端封装到一个单独的线程中，从而是服务器具备了处理多线程的能力；这样的设计思路在开发中非常有用。

　　

1. ServerSocket server = new ServerSocket(10001);
   
2.                        
   
3.                         while(true){  //注意：while中使用true，是因为accept方法为阻塞方法，不会导致程序无限循环
   
4.                                 Socket s = server.accept();
   
5.                                 new Thread(new PicThread(s)).start();
   
6.                         }

复制代码

nice{:2_36:}