生产上使用自定义线程池控制socket短连接需要注意的事项

欢迎大家搜索“小猴子的技术笔记”关注我的公众号，有问题可以及时和我交流。

对于一些平台业务对接除了http还有就是socket用的比较多了，特别软件是跟硬件设备做对接。在并发要求不是很高的时候，可以使用BIO的socket，因为它足够简单，足够方便。如果并发量很高的话，推荐使用NIO的socket，因为它能够支持较高的并发。

如果使用的是长连接的话，那么需要注意的是长连接的心跳保持，客户端的断线重连，报文格式的定义等。

如果可以的话，还是建议使用netty这个强大的框架，因为它对各种协议的封装还是很到位的。如果你熟悉它的API的话，那么这里真的强烈推荐netty（后期我会更新学习笔记）。

言归正传，接下来聊一聊BIO-短连接需要注意的事项：如果短连接作为客户端是比较简单的，只用connect->recv/send->close的流程接收数据发送数据，有业务请求来了，进行处理即可，下面给出了代码范例（以下代码均可以在gitee中找到：https://gitee.com/MonkeyBrothers/study/tree/master/springboot-netty/src/main/java/org/hry/socket/bio/shortlink）：

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短连接需要注意的事项虽然我在刚开始写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框架来帮助完成业务！

最后欢迎大家添加我的微信号，如果有问题可以及时和我交流。