一、本次目标
编写最简单的1:1的server:client，感受socket通信编程；
修改client为多线程，模拟多个client请求server，观测server响应；
封装server处理client请求方法，另开线程处理；
处理线程加入线程池管理，减轻server负荷；
二、动手实践
1、编写配置接口，包含默认服务端地址、端口等
package com.cjt.io;public interface Config {
String DEFAULT_ENCODE = "UTF-8";
String DEFAULT_ADDR = "127.0.0.1"; int DEFAULT_PORT = 6666;
}2、编写时间工具类DateUtil，方便输出日志打印
package com.cjt.io;import java.text.SimpleDateFormat;import java.util.Date;public class DateUtil { private final static String DEFAULT_PATTERN = "HH:mm:ss"; public static String getCurTimeStr(){
SimpleDateFormat sdf = new SimpleDateFormat(DEFAULT_PATTERN); return sdf.format(new Date());
}
}3、编写服务端代码
package com.cjt.io.bio;import com.cjt.io.Config;import com.cjt.io.DateUtil;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.ServerSocket;import java.net.Socket;public class ServerBIO implements Config{ private ServerSocket server; private ServerBIO(int port){ try {
server = new ServerSocket(port);
} catch (IOException e) {
e.printStackTrace();
}
} private void start() {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:服务端已经启动"); try { while (true) {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:server循环获取client请求开始"); // 阻塞，直到有客户端发起请求
Socket socket = server.accept();
System.out.println("[" + DateUtil.getCurTimeStr() + "]:有新的client连接啦"); try (BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE))){
String line;
StringBuilder builder = new StringBuilder(); // 普通IO流会阻塞，所以这里的readLine()时间会根据客户端操作的时间而定
while ((line = reader.readLine()) != null) {
builder.append(line);
builder.append(System.getProperty("line.separator"));
}
System.out.println("[" + DateUtil.getCurTimeStr() + "]:client传来消息");
System.out.println(builder.toString());
} catch (IOException e) {
e.printStackTrace(); break;
}
}
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args){ new ServerBIO(DEFAULT_PORT).start();
}
}4、编写客户端代码
package com.cjt.io.bio;import com.cjt.io.Config;import com.cjt.io.DateUtil;import java.io.*;import java.net.Socket;public class ClientBIO implements Config { private String serverIp; private int port; private String msg; private int second; private ClientBIO(String serverIp, int port) { this.serverIp = serverIp; this.port = port;
} private ClientBIO second(int second) { this.second = second; return this;
} private ClientBIO msg(String msg) { this.msg = msg; return this;
} private void sleep(int second) { try {
Thread.sleep(second * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} public void send() { try (Socket socket = new Socket(serverIp, port)) {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
writer.write(msg);
writer.flush();
sleep(second);
System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息" + msg);
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
ClientBIO client_1 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(3).msg("我是第一个客户端");
client_1.send();
}
}5、测试IO流的阻塞性
基于最简单的单线程方式我们分别实现了server和client的编写，这里不会详细阐述怎么读流，写数据，buffered流怎么用，主要是研究IO流的特性，更好地学会怎么处理高并发中的流处理。
首先启动ServerBIO，查看控制台：
[17:06:54]:服务端已经启动[17:06:54]:server循环获取client请求开始
根据server的代码，可以发现目前就阻塞在server.accept()这个位置，然后我们再启动client的main方法，模拟了两个client一前一后发送请求，观察client的控制台：
[17:06:57]:连接server成功[17:07:00]:client写入消息我是第一个客户端
同时切到server的控制台：
[17:06:54]:服务端已经启动[17:06:54]:server循环获取client请求开始[17:06:57]:有新的client连接啦[17:07:00]:client传来消息 我是第一个客户端[17:07:00]:server循环获取client请求开始
57秒client连接server成功，同时server打印“有新的client连接”，由于手动sleep的原因，直到00秒时client请求写入数据才完成，而server便一直阻塞在reader.readLine()这个位置，直接阻塞到00秒读取到client的消息，然后继续循环获取client阻塞在server.accept()这个位置。
这只是一个最最简单的socket通信模型，只有一个client请求，那么我们修改client实现Runnable接口，开启线程发送数据，模拟多个client并行访问server：
package com.cjt.io.bio;import com.cjt.io.Config;import com.cjt.io.DateUtil;import java.io.*;import java.net.Socket;public class ClientBIO implements Config, Runnable { private String serverIp; private int port; private String msg; private int second; private ClientBIO(String serverIp, int port) { this.serverIp = serverIp; this.port = port;
} private ClientBIO second(int second) { this.second = second; return this;
} private ClientBIO msg(String msg) { this.msg = msg; return this;
} private void sleep(int second) { try {
Thread.sleep(second * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} @Override
public void run() { try (Socket socket = new Socket(serverIp, port)) {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
writer.write(msg);
writer.flush();
sleep(second);
System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息" + msg);
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
ClientBIO client_1 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(3).msg("我是第一个客户端"); new Thread(client_1).start();
ClientBIO client_2 = new ClientBIO(DEFAULT_ADDR, DEFAULT_PORT).second(1).msg("我是第二个客户端"); new Thread(client_2).start();
}
}运行client的main方法，观察client的控制台：
[17:21:44]:连接server成功[17:21:44]:连接server成功[17:21:45]:client写入消息我是第二个客户端[17:21:47]:client写入消息我是第一个客户端
很明显多线程并行发送请求到server，由于client_2的sleep为1秒的原因，较client_1先打印，然后回到server的控制台：
[17:21:37]:服务端已经启动[17:21:37]:server循环获取client请求开始[17:21:44]:有新的client连接啦[17:21:47]:client传来消息 我是第一个客户端[17:21:47]:server循环获取client请求开始[17:21:47]:有新的client连接啦[17:21:47]:client传来消息 我是第二个客户端[17:21:47]:server循环获取client请求开始
server这里控制台输出完全相反，44秒提示“有新的client连接啦”，这里是client_1，通过后面的msg也可以知道，然后在47秒读取完client_1后立即获取到client_2的连接，虽然client_2的sleep有1秒的时间，但是由于client_2的连接时间在44秒，所以数据早已准备就绪，但是server的线程阻塞在读取client_1了。
三、补充完善
1、封装server处理client请求，单独新开线程：
package com.cjt.io.bio;import com.cjt.io.Config;import com.cjt.io.DateUtil;import java.io.*;import java.net.Socket;public class ClientHandler implements Runnable, Config { private Socket socket;
ClientHandler(Socket socket) { this.socket = socket;
} @Override
public void run() { try {
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE));
String line;
StringBuilder builder = new StringBuilder(); // 普通IO流会阻塞，所以这里的readLine()时间会根据客户端操作的时间而定
while ((line = reader.readLine()) != null) {
builder.append(line);
builder.append(System.getProperty("line.separator"));
}
System.out.println("[" + DateUtil.getCurTimeStr() + "]:client传来消息");
System.out.println(builder.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
}同时修改server的start调用代码：
System.out.println("[" + DateUtil.getCurTimeStr() + "]:服务端已经启动");while (true) { try {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:server循环获取client请求开始"); // 阻塞，直到有客户端发起请求
Socket socket = server.accept();
System.out.println("[" + DateUtil.getCurTimeStr() + "]:有新的client连接啦"); new Thread(new ClientHandler(socket)).start();
} catch (IOException e) {
e.printStackTrace(); break;
}
}不需要修改client代码，直接启动server后，在启动client的main方法，观测这次server的控制台：
[17:37:53]:服务端已经启动[17:37:53]:server循环获取client请求开始[17:38:00]:有新的client连接啦[17:38:00]:server循环获取client请求开始[17:38:00]:有新的client连接啦[17:38:00]:server循环获取client请求开始[17:38:02]:client传来消息 我是第二个客户端[17:38:04]:client传来消息 我是第一个客户端
对比上面，很明显server新开了client处理线程，在处理client消息方面不会造成阻塞了。server收到client连接后新开线程处理并立即轮询接下来连接的client，“我是第二个客户端”较先打印很好的印证了这点。
2、将ClientHandler处理线程加入到线程池
Java创建的线程属于宝贵的系统资源，若是在大量的client访问时，则会创建大量的client消息处理线程，这样必将导致系统性能急剧下降，最终宕掉。所以我们可以将client消息处理线程加入到线程池中进行管理：
··· ···// 定长线程池，超出数量的线程会在队列中等待private ExecutorService threadPool = Executors.newFixedThreadPool(20); ··· ···// 创建一个新的线程加入到线程池中管理并立即提交执行threadPool.execute(new Thread(new ClientHandler(socket))); ··· ···
这样就不用担心由于高并发产生巨大的线程从而使系统崩溃，运行结果与上面相差无异。这里就不再重复，感兴趣的可以自己试试。
3、增加server响应
修改ClientHandler，简单回应client（复述消息）：
··· ···// 在写之前必须关闭读socket.shutdownInput(); BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE)); writer.write(builder.toString()); writer.flush(); socket.close(); ··· ···
那么client的发送消息也得需要读取server的响应了，修改client的run方法：
@Override
public void run() { try (Socket socket = new Socket(serverIp, port)) {
System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), DEFAULT_ENCODE));
writer.write(msg);
writer.flush();
sleep(second);
System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息");
System.out.println(msg); // 在写之前必须关闭写
socket.shutdownOutput();
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), DEFAULT_ENCODE));
StringBuilder builder = new StringBuilder(); while ((msg = reader.readLine()) != null){
builder.append(msg);
builder.append(System.getProperty("line.separator"));
}
System.out.println("[" + DateUtil.getCurTimeStr() + "]:server传来消息");
System.out.println(builder.toString());
} catch (IOException e) {
e.printStackTrace();
}
}同样的先运行server后，再执行client的main方法，观测client的控制台：
[18:08:07]:连接server成功 [18:08:07]:连接server成功 [18:08:08]:client写入消息 我是第二个客户端 [18:08:08]:server传来消息 我是第二个客户端 Disconnected from the target VM, address: '127.0.0.1:61618', transport: 'socket'[18:08:10]:client写入消息 我是第一个客户端 [18:08:10]:server传来消息 我是第一个客户端
这说明已经server成功做出了响应，并且client也成功读取到了server的消息。这里需要强调的是：
jdk 1.7开始，try后面可直接初始化某些流（implements AutoCloseable），则会自动关闭；
socket关闭后对应的输入/输出流也会被关闭；
socket 一次I/O操作既有读也有写的话，中间一定要加上shutup流；
作者：叫我宫城大人
链接：https://www.jianshu.com/p/f1a91337c7d8