Socket s = ss.accept();
我想知道这里为什么不放到run方法中，
而下面的开启线程传入的Runnable实现类就不需要
传入Socket对象了，通过线程启动后，在创建Socket对象。

1. /*
   
2. 需求：上传图片。
   
3. 
   
4. 
   
5. 
   
6. */
   
7. /*
   
8. 客户端。
   
9. 1，服务端点。
   
10. 2，读取客户端已有的图片数据。
    
11. 3，通过socket 输出流将数据发给服务端。
    
12. 4，读取服务端反馈信息。
    
13. 5，关闭。
    
14. 
    
15. */
    
16. 
    
17. import java.io.*;
    
18. import java.net.*;
    
19. class  PicClient
    
20. {
    
21.         public static void main(String[] args)throws Exception
    
22.         {
    
23.                 if(args.length!=1)//为什么这里判断长度是1，就防止乱传参数呢？
    
24.                 {
    
25.                         System.out.println("请选择一个jpg格式的图片");
    
26.                         return ;
    
27.                 }
    
28. 
    
29. 
    
30. 
    
31. 
    
32.                 File file = new File(args[0]);
    
33.                 if(!(file.exists() && file.isFile()))
    
34.                 {
    
35.                         System.out.println("该文件有问题，要么补存在，要么不是文件");
    
36.                         return ;
    
37. 
    
38.                 }
    
39. 
    
40.                 if(!file.getName().endsWith(".jpg"))
    
41.                 {
    
42.                         System.out.println("图片格式错误,请重新选择");
    
43.                         return ;
    
44.                 }
    
45. 
    
46.                 if(file.length()>1024*1024*5)
    
47.                 {
    
48.                         System.out.println("文件过大，没安好心");
    
49.                         return ;
    
50.                 }
    
51.                
    
52. 
    
53. 
    
54. 
    
55.                 Socket s = new Socket("192.168.1.254",10007);
    
56. 
    
57.                 FileInputStream fis = new FileInputStream(file);
    
58. 
    
59.                 OutputStream out = s.getOutputStream();
    
60. 
    
61.                 byte[] buf = new byte[1024];
    
62. 
    
63.                 int len = 0;
    
64. 
    
65.                 while((len=fis.read(buf))!=-1)
    
66.                 {
    
67.                         out.write(buf,0,len);
    
68.                 }
    
69. 
    
70.                 //告诉服务端数据已写完
    
71.                 s.shutdownOutput();
    
72. 
    
73.                 InputStream in = s.getInputStream();
    
74. 
    
75.                 byte[] bufIn = new byte[1024];
    
76. 
    
77.                 int num = in.read(bufIn);
    
78.                 System.out.println(new String(bufIn,0,num));
    
79. 
    
80.                 fis.close();
    
81.                 s.close();
    
82.         }
    
83. }
    
84. 
    
85. /*
    
86. 服务端
    
87. 
    
88. 这个服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。
    
89. 这时B客户端连接，只有等待。
    
90. 因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以
    
91. 暂时获取不到B客户端对象。
    
92. 
    
93. 那么为了可以让多个客户端同时并发访问服务端。
    
94. 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
    
95. 
    
96. 
    
97. 
    
98. 如何定义线程呢？
    
99. 
    
100. 只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
     
101. */
     
102. 
     
103. class PicThread implements Runnable
     
104. {
     
105. 
     
106.         private Socket s;
     
107.         PicThread(Socket s)
     
108.         {
     
109.                 this.s = s;
     
110.         }
     
111.         public void run()
     
112.         {
     
113. 
     
114.                 int count = 1;
     
115.                 String ip  = s.getInetAddress().getHostAddress();
     
116.                 try
     
117.                 {
     
118.                         System.out.println(ip+"....connected");
     
119. 
     
120.                         InputStream in = s.getInputStream();
     
121. 
     
122.                         File dir =  new File("d:\\pic");
     
123. 
     
124.                         File file = new File(dir,ip+"("+(count)+")"+".jpg");
     
125. 
     
126.                         while(file.exists())
     
127.                                 file = new File(dir,ip+"("+(count++)+")"+".jpg");
     
128. 
     
129.                         FileOutputStream fos = new FileOutputStream(file);
     
130. 
     
131.                         byte[] buf = new byte[1024];
     
132. 
     
133.                         int len = 0;
     
134.                         while((len=in.read(buf))!=-1)
     
135.                         {
     
136.                                 fos.write(buf,0,len);
     
137.                         }
     
138. 
     
139.                         OutputStream out = s.getOutputStream();
     
140. 
     
141.                         out.write("上传成功".getBytes());
     
142. 
     
143.                         fos.close();
     
144. 
     
145.                         s.close();
     
146.                 }
     
147.                 catch (Exception e)
     
148.                 {
     
149.                         throw new RuntimeException(ip+"上传失败");
     
150.                 }
     
151.         }
     
152. }
     
153. 
     
154. 
     
155. 
     
156. class  PicServer
     
157. {
     
158.         public static void main(String[] args) throws Exception
     
159.         {
     
160.                 ServerSocket ss = new ServerSocket(10007);
     
161. 
     
162.                 while(true)
     
163.                 {
     
164.                         Socket s = ss.accept();//我想知道这里为什么不放到run方法中，
     
165.                                                                         //而下面的开启线程传入的Runnable实现类就不需要
     
166.                                                                         //传入Socket对象了，通过线程启动后，在创建Socket对象。
     
167. 
     
168.                         new Thread(new PicThread(s)).start();
     
169. 
     
170.                
     
171.                 }
     
172. 
     
173.                 //ss.close();
     
174.         }
     
175. }

复制代码

Socket s = ss.accept(); 如果这个放到new Thread()内，那么就不是一个服务器了。有几个线程就是几个服务器。 服务器只有一个，客户端发来请求上传数据，这时候将上传数据的代码到线程里分别去运行，
new Thread(new PicThread(s)).start(); 实现客户端并发上传的效果。

非常好的资源，谢谢分享！