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

最新推荐文章于 2021-10-09 00:01:13 发布
最新推荐文章于 2021-10-09 00:01:13 发布
阅读量241 收藏 2
点赞数
分类专栏： 网络编程 文章标签： socket 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MonkeyBrothers/article/details/114007621
版权

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


    对于一些平台业务对接除了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的时候使用了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框架来帮助完成业务！

    最后欢迎大家添加我的微信号，如果有问题可以及时和我交流。
在这里插入图片描述

小猴子的技术笔记
关注
专栏目录
Netty-自定义线程池处理长耗时业务
skystep的博客
08-22 1143
在Netty中，EventLoop 和 EventExecutorGroup 提供的普通任务不能解决长耗时业务处理引起的 I/O 线程阻塞问题，究其原因：在 Netty 中，一个 channel 在它的生命中期内只注册于一个 EventLoop，而一个 EventLoop 在它的生命周期内只和一个线程绑定，一个给定的 channel 的 I/O 操作都是由相同的线程进行处理。为此不能直接在该线程上进行长耗时业务处理。为了解决这个问题，通常的做法是：自定义线程池,把长耗时的业务都丢到线程池中去处理。
十二、连接池线程池配置——HttpClient连接池
最新发布
流楚丶格念的博客
08-27 1753
3.x、4.x 和 5.x API 是完全不兼容的，使用起来比较麻烦。在 HttpClient 的执行过程中，连接复用是一个关键的性能优化点。通过合理配置连接池参数、正确处理连接的使用和释放，以及关注连接池的生命周期和性能监控，可以有效提高。下面是对连接池源码的重要步骤分析，包括连接的复用和非复用情况的处理，以及连接池内部的数据结构。此异常通常表示连接池中的连接用尽，导致无法获取到可用连接。这种状态表示线程在等待连接池中的连接。时，到每个主机的并发最多只有 200，但总的并发连接数为 300。
socket 线程池实现（已经在项目中应用）
01-28
socket服务端线程池实现 不依赖于第三方jar，基于jdk编写。
自定义线程池
小小先生的博客
05-23 174
简单聊一聊线程池：线程的多次重复创建需要消耗系统大量的资源，而线程池的做法是当需要大量的线程时，由线程池统一创建，交由main线程使用，且可重复使用，避免了创建大量的线程。 这里是一个最简单的线程池，由三部分组成：线程池，阻塞队列，main调用者。 线程池：用来创建线程，创建的线程用worker表示，用workers集合存储 参数： 任务队列：queue 线程集合：workers 核心数：coreSize（用来限制创建的worker数量，即只允许线程池创建多少个线程） 阻塞队列：用于..
java Socket + 自定义线程池 实现web服务器 仿Servlet
BurukeYou
10-01 1125
在上一篇的基础上进行优化,链接如下 java Socket 简单实现http服务器 仿Servlet 改进 上一次是每来一个请求就创建一个线程去处理并关闭,这样对性能损耗很大,加入自定义线程池去处理请求,预先创建一堆线程,每次用完再放回去提高线程复用性. 代码目录结构 改变后的startServer.java为 public class startServer { //自定义线程池 ...
java socket连接池_JAVA服务器端Socket线程池
weixin_36411999的博客
02-12 550
importjava.util.Vector;importjava.net.*;importjava.io.*;publicclassThreadPool{publicstaticfinalintMAX_THREADS=100;publicstaticfinalintMAX_SPARE_THREADS=50;publicstaticfinalintMIN...
工具集合：各种基类，蓝牙控制，自定义总线，加密解密，SQLite数据库，Socket保持长连接等.zip
01-04
工具集合：各种基类，蓝牙控制，自定义总线，加密解密，SQLite数据库，Socket保持长连接，UDP通信，图片处理，日期处理，弹出自定义对话框，GSP获取，计时器，通知栏下载，处理队列，延迟操作，防粘连操作，文件处理...
C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip
10-19
综上所述，这个项目展示了如何利用C++的socket编程技术，结合线程池和Windows IOCP机制，设计并实现一个能够处理大量并发连接的TCP服务器。这是一项对系统设计和性能优化有着深度要求的任务，对于理解和提升网络编程...
SuperSocket 自定义AppServer、AppSession、CommandBase
05-15
自定义AppServer主要涉及继承`SuperSocket.SocketServer.AppServer`类，并重写其中的方法，如`Start`、`Stop`、`GetSessionById`等，以控制服务器的启动、停止及管理会话。 2. **AppSession**：AppSession代表了...
长连接 短连接 异步 同步 )阻塞与非阻塞详解
weixin_33754065的博客
11-14 525
一。通信方式 主要有以下三大类: (一)SERVER/CLIENT方式 1.一个Client方连接一个Server方，或称点对点(peer to peer)： 2.多个Client方连接一个Server方，这也是通常的并发服务器方式。 3.一个Client方连接多个Server方，这种方式很少见，主要 用于一个客户向多个服务器发送请求情况...
TCP/IP，http，socket，长连接，短连接
hddygs001的专栏
03-22 3885
转载自http://my.oschina.net/ksfzhaohui/blog/95803   TCP/IP TCP/IP是个协议组，可分为三个层次：网络层、传输层和应用层。 在网络层有IP协议、ICMP协议、ARP协议、RARP协议和BOOTP协议。 在传输层中有TCP协议与UDP协议。 在应用层有:TCP包括FTP、HTTP、TELNET、SMTP等协议
Java 源码 - 工作实战：Socket 结合线程池的使用
热门推荐
。
10-09 20万+
不啰嗦，我们直接开始！ 引导语 Socket 面试最终题一般都是让你写一个简单的客户端和服务端通信的例子，本文就带大家一起来写这个 demo。 1、要求 可以使用 Socket 和 ServiceSocket 以及其它 API； 写一个客户端和服务端之间 TCP 通信的例子； 服务端处理任务需要异步处理； 因为服务端处理能力很弱，只能同时处理 5 个请求，当第六个请求到达服务器时，需要服务器返回明确的错误信息：服务器太忙了，请稍后重试~。 需求比较简单，唯一复杂的地方在于第四点，我们需要对客户
java线程池_程序员：java使用线程池和TCP实现简单多轮聊天系统
weixin_39820158的博客
11-12 173
最近在做物联网项目,需要使用TCP和传感器进行双向交互,通过这种渠道,找到了下面的代码,写成博客主要也是为了记录一下,以后用到随时可以看。代码实现服务端package com.tcp;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStre...
java socket 线程池_java socket编程的一个例子（线程池）
weixin_35160923的博客
02-16 505
服务器程序EchoServer.java；import java.io.*;import java.net.*;import java.util.concurrent.*;public class EchoServer {private int port=10000;private ServerSocket serverSocket;private ExecutorService executor...
java多线程tcp_TCP多线程（线程池）
weixin_39591423的博客
05-18 324
package Threed; /** * Created by SuPhoebe on 2015/12/27. * 基于TCP协议的Socket通信，实现用户登陆 * 服务器端 */ import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Ex.
【java的socket编程】结合多线程Thread实现通信（使用线程池和非线程池对比）、java开发UDP/IP网络程序
qq_41358574的博客
06-25 1650
文件目录： chartserver: public class ChatServer { private static final int SOCKET_PORT = 52000; public static ArrayList<SocketBean> mSocketList = new ArrayList<SocketBean>(); private void initServer() { try { // 创建一个ServerSocket，用于监听客户端So
Java多线程与线程池实现Socket多个客户端连接服务器同时通信代码
半途行走的博客
04-06 2261
多线程是实现的服务器端： package com.main; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io...
生产者与消费者模型、线程与socket编程
no_face_jack的博客
09-13 474
生产者与消费者模型、线程与socket编程生产者与消费者模型线程与socket编程 生产者与消费者模型 生产者：生产数据的线程 消费者：使用、处理数据的线程 缓冲区：隔离生产者和消费者，这样可以避免互相等待，提高运行效率。 生产者快于消费者：缓冲区爆满 撑死 消费者快于生产者：缓冲区一直空 饿死 使用条件变量可以解决生产者与消费之间的效率不匹配问题。 生产者快于消费者，通知消费者加速消费，生产者睡眠降低生产速度。 消费者快于生产者，通知生产者加速生产，消费者睡眠降低消费速度。 线程与socket编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值