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

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.

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

6.真正引起OOM的是线程处于不可控状态,while一直在循环异常.

7.在发生exception时,要进行线程控制,这里设置线程的局部变量runnable=false;在异常发生时,让while循环结束,在run方法最后释放socket资源.

到此完整解决 2018-1-16