一、本次目标
- 编写最简单的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流；