欢迎大家搜索“小猴子的技术笔记”关注我的公众号，有问题可以及时和我交流。
对于一些平台业务对接除了http还有就是socket用的比较多了，特别软件是跟硬件设备做对接。在并发要求不是很高的时候，可以使用BIO的socket，因为它足够简单，足够方便。如果并发量很高的话，推荐使用NIO的socket，因为它能够支持较高的并发。
如果使用的是长连接的话，那么需要注意的是长连接的心跳保持，客户端的断线重连，报文格式的定义等。
如果可以的话，还是建议使用netty这个强大的框架，因为它对各种协议的封装还是很到位的。如果你熟悉它的API的话，那么这里真的强烈推荐netty（后期我会更新学习笔记）。
言归正传，接下来聊一聊BIO-短连接需要注意的事项：如果短连接作为客户端是比较简单的，只用connect->recv/send->close的流程接收数据发送数据，有业务请求来了，进行处理即可，下面给出了代码范例（以下代码均可以在gitee中找到：https://gitee.com/MonkeyBroth...）：
public class SocketClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("localhost", 8888);
byte[] bytes = new byte[1024];
InputStream in = socket.getInputStream();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
// 关闭输入流，告诉服务端我读取数据完毕了
socket.shutdownInput();
// 如果需要给socketServer返回处理之后的数据，可以拿到输出流进行输出。
OutputStream out = socket.getOutputStream();
out.write("这里是处理完毕的数据".getBytes(StandardCharsets.UTF_8));
// 关闭输出流，告诉服务端我写完数据了
socket.shutdownOutput();
System.out.println("数据发送完毕");
socket.close();
}
}连接上服务端，连接上之后，处理数据，处理完毕之后关闭这个socket进行释放资源就可以了。
BIO-服务端：如果是服务端那就 需要注意的东西比较多了，第一个就是并发量很大的很大的时候千万不要使用BIO 的socket更建议使用NIO或者netty框架来帮助你解决业务问题。首先来看一个类似一问一答式BIO的socket服务。
public class SocketServer {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8888);
Socket socket = server.accept();
byte[] bytes = new byte[1024];
InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();
out.write("这里是服务端发送的数据".getBytes(StandardCharsets.UTF_8));
// 告诉客户端，我已经发送完一部分数据了。如果不调用的话，客户端是接受不到输入信号的
socket.shutdownOutput();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
socket.shutdownInput();
server.close();
}
}这里是有问题的：就是只能有一个socket client来连接，如果是并发的业务是不能够满足需求的，因此需要为每一个socket启动一个线程。但是这样是很消耗资源的。所以并不是并发量特别大的话，还是可以的。再强调一下，超过一百的并发就不要使用BIO了！切记！！！
接下来模拟一下低并发的socket请求，看一下客户端和服务端是怎么处理的。首先客户端使用了while循环，这里“TimeUnit.SEONDS.sleep(1)”进行了休眠1秒，也就是每一秒都来一个请求（如果要每秒请求100的话，可以使用CountDownLatch进行控制，文章最后有实例）。
public class SocketClient {
public static void main(String[] args) throws Exception {
while (true) {
TimeUnit.SECONDS.sleep(1);
Socket socket = new Socket("localhost", 8888);
byte[] bytes = new byte[1024];
InputStream in = socket.getInputStream();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
// 关闭输入流，告诉服务端我读取数据完毕了
socket.shutdownInput();
// 如果需要给socketServer返回处理之后的数据，可以拿到输出流进行输出。
OutputStream out = socket.getOutputStream();
out.write("这里是处理完毕的数据".getBytes(StandardCharsets.UTF_8));
// 关闭输出流，告诉服务端我写完数据了
socket.shutdownOutput();
System.out.println("数据发送完毕");
socket.close();
}
}
}对应的server服务就需要使用到线程池了，java为我们默认提供了一些线程池。
虽然我在刚开始写socket的时候使用了JDK提供的线程池，但是后来对线程池的深入研究之后发现一些潜在问题。因此还是推荐使用自定的线程池，这样一来可以对参数进行把控，还可以对线程池进行自定义设置名称。
public class SocketServer {
public static void main(String[] args) throws IOException {
Executor executor = Executors.newCachedThreadPool();
ServerSocket server = new ServerSocket(8888);
while(true) {
Socket socket = server.accept();
executor.execute(() ->{
try(InputStream in = socket.getInputStream();OutputStream out = socket.getOutputStream();){
byte[] bytes = new byte[1024];
out.write("这里是服务端发送的数据".getBytes(StandardCharsets.UTF_8));
// 告诉客户端，我已经发送完一部分数据了。如果不调用的话，客户端是接受不到结束信号的
socket.shutdownOutput();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
socket.shutdownInput();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
});
}
}
}自定义的线程池，我的生产上在使用，具体的参数可以根据自己的业务进行设置。
public class SocketServer {
public static void main(String[] args) throws IOException {
// 自定义线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
10,
10,
5L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10),
new MySocketThreadFactory("自定义socket线程池"),
new ThreadPoolExecutor.DiscardPolicy());
ServerSocket server = new ServerSocket(8888);
while(true) {
Socket socket = server.accept();
executor.execute(() ->{
try(InputStream in = socket.getInputStream();OutputStream out = socket.getOutputStream();){
byte[] bytes = new byte[1024];
out.write("这里是服务端发送的数据".getBytes(StandardCharsets.UTF_8));
// 告诉客户端，我已经发送完一部分数据了。如果不调用的话，客户端是接受不到结束信号的
socket.shutdownOutput();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
socket.shutdownInput();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
});
}
}
}
自定义线程工厂生产可用。
public class MySocketThreadFactory implements ThreadFactory {
/**
* 线程组
*/
private final ThreadGroup threadGroup;
/**
* 线程数量初始值，这里只是展示使用
*/
private final AtomicInteger threadNumber = new AtomicInteger(1);
/**
* 线程名前缀
*/
public final String namePrefix;
public MySocketThreadFactory(String name) {
SecurityManager s = System.getSecurityManager();
threadGroup = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
if (null == name || "".equals(name.trim())) name = "pool";
// 线程池数量初始值，这里只是展示使用
AtomicInteger poolNumber = new AtomicInteger(1);
namePrefix = name + "-" + poolNumber.getAndIncrement() + "-socket-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(threadGroup, r, namePrefix + threadNumber.getAndIncrement(), 0);
if (t.isDaemon()) t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}以上的BIO的socket是生产上可以使用的，在并发量不高的情况下可以直接拿去使用。再一次强调，高并发请勿使用线程的socket！
这里给了并发的测试代码：
public class SocketClient {
public static void main(String[] args) throws Exception {
CountDownLatch downLatch = new CountDownLatch(1);
IntStream.range(0,25).forEach(v -> new Thread(() ->{
try {
downLatch.await();
Socket socket = new Socket("localhost", 8888);
byte[] bytes = new byte[1024];
InputStream in = socket.getInputStream();
StringBuffer sb = new StringBuffer();
int len;
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 接收到信息，拿到接收的信息之后就可以处理了。
System.out.println("接收到消息：" + sb.toString());
// 关闭输入流，告诉服务端我读取数据完毕了
socket.shutdownInput();
// 如果需要给socketServer返回处理之后的数据，可以拿到输出流进行输出。
OutputStream out = socket.getOutputStream();
out.write("这里是处理完毕的数据".getBytes(StandardCharsets.UTF_8));
// 关闭输出流，告诉服务端我写完数据了
socket.shutdownOutput();
System.out.println("数据发送完毕");
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}).start());
downLatch.countDown();
}
}并发过来就不行，这个时候就需要调整线程池的设置了。由此可见BIO的socket的中等并发使用是很依赖线程池的。
对于socket阻塞式短连接的使用到此就结束了。需要注意的就是短连接是阻塞式的，因此如果一个业务有问题的话，那么就会阻塞其余的业务。因此开辟了线程池来进行处理这个问题，但是它不适用于高并发的场景，在高并发的场景下建议使用NIO的socket或者netty框架来帮助完成业务！
最后欢迎大家添加我的微信号“小猴子的技术笔记”，如果有问题可以及时和我交流。