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

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

复制代码

Socket s = ss.accept();这句代码中先要了解一下accept()方法
accept()方法是侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
把他放到run方法中如果客户端没连接上来，无法返回socket对象，那run（）方法就停到那了，即启动着线程又在那瞎等，浪费内存。还不如在还没有启动线程时就提前连接客户端接受到socket对象，做好一切之后，再启动线程，岂不更加的合理。