一次socket长连接运行导致的性能问题

最新推荐文章于 2022-10-11 10:14:25 发布

shengfq

最新推荐文章于 2022-10-11 10:14:25 发布

阅读量6.2k

点赞数

分类专栏：总结随笔文章标签： socket 线程

本文链接：https://blog.csdn.net/shengfuqiang/article/details/78883768

版权

总结随笔专栏收录该内容

2 篇文章 0 订阅

订阅专栏

socket长连接篇

客户端维持心跳导致出现性能问题

客户端代码

实现一个定时发送心跳包给服务端的线程，一个接收服务端返回消息的线程。

package practice;

import client.Client;
import client.KeepAlive;

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

/**
 * Created by sheng on 17/12/22.
 */
public class MyClient {
    private boolean running =false;
    interface ObjectAction {
        Object doAction(Object obj);
    }

    class DefaultObjectAction implements ObjectAction {
        @Override
        public Object doAction(Object object) {
            System.out.println(object);
            return object;
        }
    }

    public static void main(String[] args) {
        MyClient client = new MyClient();
        client.doStart();
    }

    public void doStart(){
        try {
            if(running)return;
            Socket socket=new Socket("127.0.0.1",7890);
            running=true;
            Thread t1=new Thread(new KeepAliveWatchDog(socket));
            t1.start();
            Thread t2=new Thread(new ReceiveThread(socket));
            t2.start();
            Scanner input=new Scanner(System.in);
            String command=input.next();
            if(command.equals("cancel")){
                doStop();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void doStop(){
        if(running) running=false;
    }

    class KeepAliveWatchDog extends Thread{
        Socket socket;
        long lastReceive=System.currentTimeMillis();
        public KeepAliveWatchDog(Socket socket){
            this.socket=socket;
        }
        @Override
        public void run() {
            //线程靠running变量保持持续活跃,一旦主线程要求关闭,所有子线程要主动关闭套接字
            //看门狗每3秒心跳一次
            while(running){
            try {
                if (System.currentTimeMillis() - lastReceive > 2000) {
                    OutputStream outputStream = socket.getOutputStream();
                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
                    objectOutputStream.writeObject(new KeepAlive());
                    System.out.println("send to server...");
                    objectOutputStream.flush();
                    lastReceive = System.currentTimeMillis();
                } else {
                    Thread.sleep(10);
                }
            }catch(IOException e){

            }catch(InterruptedException e){

            }
            }
            if(!running){
                close();
            }
        }

        public void close(){
            if(this.socket!=null){
                try {
                    this.socket.close();
                }catch(IOException ex){

                }
            }
            System.out.println("KeepAliveWatchDog socket closed");
        }
    }
    class ReceiveThread extends Thread{
        Socket socket;
        public ReceiveThread(Socket socket){
            this.socket=socket;
        }
        @Override
        public void run() {
                while(running){
                    try {
                        InputStream inputStream = socket.getInputStream();
                        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
                        if (objectInputStream.available() > 0) {
                            Object object = objectInputStream.readObject();
                            ObjectAction oa = new DefaultObjectAction();
                            oa.doAction(object);
                        } else {
                            Thread.sleep(10);
                        }
                    }catch(IOException e){

                    }catch(InterruptedException e){

                    }catch(ClassNotFoundException e){

                    }
                }
                if(!running){
                    close();
                }

        }

        public void close(){
            if(this.socket!=null){
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            System.out.println("ReceiveThread socket closed");
        }
    }
}

服务端代码

实现一个守护线程进行socket监听客户端连接，每个客户端socket都会建立一个新的处理线程处理客户端的请求，并返回心跳包。


package practice;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * Created by sheng on 17/12/20.
 * 根据消息的类型,自动匹配处理器
 */
public class MyServer {
    private final int PORT = 7890;
    private boolean running = false;
    private Thread thread1;
    private Map mapping=new HashMap();
    interface ObjectAction {
        Object doAction(Object obj);
    }

    class DefaultObjectAction implements ObjectAction {
        @Override
        public Object doAction(Object object) {
            System.out.println(object);
            return object;
        }
    }

    public static void main(String[] args) {
        MyServer server = new MyServer();
        server.doStart();
    }

    public void doStart() {
        //启动accept线程,进行
        if (running) return;//确保服务器单线程启动
        running = true;
        thread1 = new Thread(new ConnWatchDogThread());
        thread1.start();
        System.out.println("server initial....");
        Scanner input=new Scanner(System.in);
        String next=input.next();
        if(next.equals("cancel")){
            doStop();
        }
        //启动socket action线程接收处理
    }

    public void doStop() {
        if (running) running = false;
    }

    /**
     * 消息-处理器模型,避免做冗余的判断
     * 通过key获取value对象处理器的方式比if..else...或设计模式都要简单便捷.
     * */
    public void addMapping(Class classes, ObjectAction oa){
        this.mapping.put(classes,oa);
    }

    public ObjectAction getAction(Class classes){
        return this.mapping.get(classes);
    }
    /**
     * 接收线程
     */
    class ConnWatchDogThread extends Thread {
        ServerSocket socket;

        @Override
        public void run() {
            try {
                socket = new ServerSocket(PORT, 5);
                while (running) {
                    Socket socket1 = socket.accept();//阻塞方法,但是只会接收一个,需要循环接收
                    System.out.println("accepted client:"+socket1.getRemoteSocketAddress());
                    Thread thread1 = new Thread(new SocketActionThread(socket1));
                    thread1.start();
                }
                if(!running)
                close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void close() {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 消息处理线程
     */
    class SocketActionThread extends Thread {
        Socket socket;
        long lastReceiveTime = System.currentTimeMillis();
        public SocketActionThread(Socket socket) {
            this.socket = socket;
        }
        private int delay = 3000;
        private boolean runnable=true;
        @Override
        public void run() {
            //长连接每隔3秒都需要心跳喂狗一次,
            while(running && runnable) {
                try {
                    if (System.currentTimeMillis() - lastReceiveTime > delay && running) {
                        executeOvertime();
                    } else {
                        //执行读写socket
                        InputStream inputStream = socket.getInputStream();
                        if (inputStream.available() > 0) {
                            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
                            Object obj = objectInputStream.readObject();
                            lastReceiveTime = System.currentTimeMillis();
                            ObjectAction oa = new DefaultObjectAction();
                            Object out = oa.doAction(obj);
                            if (out != null) {
                                //回写给客户端
                                OutputStream outputStream = socket.getOutputStream();
                                ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
                                objectOutputStream.writeObject(out);
                            }

                        } else {
                            Thread.sleep(10);
                        }
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (IOException ex) {
                    ex.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            if(!running){
                close();
            }
        }

        //超时,主动断开socket
        public void executeOvertime() {
            if(runnable)runnable=false;
            if (this.socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("client over time:"+socket.getRemoteSocketAddress());
        }

        public void close(){
            if(this.socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

实验结果

我开启了一个server，开启了5个client。client每隔2秒发送一次心跳，服务器端收到后会回复。
我并没有手动结束，但是日志提示，客户端主动断开了。
2017-12-23 11:36:19 维持连接包开始
2017-12-23 16:06:04 维持连接包结束
内存使用信息:
开启了5个java进程，占用内存分别为598MB,555MB,471MB,447MB,432MB.
手动关闭client端后，只剩下server 进程，占用48MB。

客户端哪个地方写的有bug，导致客户端内存占用率这么大，还是长连接的维持本来就占用内存较高。

———-分割线

解决思路

是什么引起内存增加? 监控到引起内存爆满?

java内存分析工具 jconsole snip

服务端正常运行
1.从上图我们可以看到每隔10分钟,JVM就会将堆内存回收一次.

服务端接收多个客户端请求
2.从上图可以看到多个客户端请求响应,服务端内存回收的频率加快了.

3.上图客户端正常运行的内存占用

当服务端意外断开,客户端运行
4.上图是当服务器端意外断开或者出现网络超时,客户端出现了OOM.

异常运行的客户端线程运行,Thread-1是发送线程
5.当出现网络超时时,发送线程并没有正常退出.
通过下面的日志输出可以看到,IOException一直在报错,我尝试在异常中增加socket关闭操作,然而并没有用.不是socket没关闭造成的.
thread-3是接收线程

IO异常产生,但是处理不正确
6.真正引起OOM的是线程处于不可控状态,while一直在循环异常.
正常处理客户端异常后
7.在发生exception时,要进行线程控制,这里设置线程的局部变量runnable=false;在异常发生时,让while循环结束,在run方法最后释放socket资源.

到此完整解决 2018-1-16

shengfq

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
一次socket长连接运行导致的性能问题

socket长连接篇客户端维持心跳导致出现性能问题客户端代码实现一个定时发送心跳包给服务端的线程，一个接收服务端返回消息的线程。package practice;import client.Client;import client.KeepAlive;import java.io.*;import java.net.Socket;import ja
复制链接

扫一扫