长连接和短连接的使用_如何判断是长连接还是短连接[通俗易懂]

长连接和短连接的区别及原理

一、长连接与短连接：
长连接：client方与server方先建立连接，连接建立后不断开，然后再进行报文发送和接收。这种方式下由于通讯连接一直存在。此种方式常用于P2P通信。
短连接：Client方与server每进行一次报文收发交易时才进行通讯连接，交易完毕后立即断开连接。此方式常用于一点对多点通讯。

二、长连接与短连接的操作过程：
短连接的操作步骤是：建立连接——数据传输——关闭连接…建立连接——数据传输——关闭连接
长连接的操作步骤是：建立连接——数据传输…（保持连接）…数据传输——关闭连接

三、长连接与短连接的使用时机：
长连接：短连接多用于操作频繁，点对点的通讯，而且连接数不能太多的情况。每个TCP连接的建立都需要三次握手，每个TCP连接的断开要四次握手。
如果每次操作都要建立连接然后再操作的话处理速度会降低，所以每次操作下次操作时直接发送数据就可以了，不用再建立TCP连接。
例如：数据库的连接用长连接，如果用短连接频繁的通信会造成socket错误，频繁的socket创建也是对资源的浪费。
短连接：web网站的http服务一般都用短连接。因为长连接对于服务器来说要耗费一定的资源。像web网站这么频繁的成千上万甚至上亿客户端的连接用短连接更省一些资源。
试想如果都用长连接，而且同时用成千上万的用户，每个用户都占有一个连接的话，可想而知服务器的压力有多大。所以并发量大，但是每个用户又不需频繁操作的情况下需要短连接。总之：长连接和短连接的选择要视需求而定。

四、发送接收方式：
1、异步：报文发送和接收是分开的，相互独立，互不影响的。这种方式又分两种情况：异步双工：接收和发送在同一个程序中，有两个不同的子进程分别负责发送和接送。异步单工：接送和发送使用两个不同的程序来完成。
2、同步：报文发送和接收是同步进行，即报文发送后等待接送返回报文。同步方式一般需要考虑超时问题，试想我们发送报文以后也不能无限等待啊，所以我们要设定一个等待时候。超过等待时间发送方不再等待读返回报文。直接通知超时返回。

五、报文格式：
通信报文格式多样性更多，相应地就必须设计对应的读写报文的接收和发送报文函数。阻塞与非阻塞方式
1、非阻塞方式：读函数不停的进行读动作，如果没有报文接收到，等待一段时间后超时返回，这种情况一般需要指定超时时间。
2、阻塞方式：如果没有接收到报文，则读函数一直处于等待状态，直到报文到达。
循环读写方式1、一次直接读写报文：在一次接收或发送报文动作中一次性不加分别地全部读取或全部发送报文字节。
2、不指定长度循环读写：这一版发生在短连接进程中，受网络路由等限制，一次较长的报文可能在网络传输过程中被分解成很多个包，一次读取可能不能全部读完一次报文，这就需要循环读取报文，知道读完为止。
3、带长度报文头循环读写：这种情况一般在长连接中，由于在长连接中没有条件能够判断循环读写什么时候结束。必须要加长度报文头。
读函数先是读取报文头的长度，再根据这个长度去读报文，实际情况中，报头码制格式还经常不一样，如果是非ASCII的报文头，还必须转换成ASCII常见的报文头编制有：
1、n个字节的ASCII码。
2、n个字节的BCD码。
3、n个字节的网络整型码。
以上是几种比较典型的读写报文方式，可以与通信方式模板一起 预先提供一些典型的API读写函数。当然在实际问题中，可能还必须编写与对方报文格式配套的读写API. 在实际情况中，往往需要把我们自己的系统与别人的系统进行连接，有了以上模板与API,可以说连接任何方式的通信程序都不存在问题。

长连接的实现

package com.zmkj.app.test;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;


/** * * 维持连接的消息对象（心跳对象） * @author sunminghao */
public class LongLinkKeepAlive implements Serializable { 
   

    /* 覆盖该方法，仅用于测试使用。 * @see java.lang.Object#toString() */
    @Override
    public String toString() { 
   
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";
    }

}

package com.zmkj.app.test;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;

/** * C/S架构的服务端对象。 * @author sunminghao */
public class LongLinkServer { 
   

    /** * 要处理客户端发来的对象，并返回一个对象，可实现该接口。 */
    public interface ObjectAction{ 
   
        Object doAction(Object rev, LongLinkServer server);
    }

    public static final class DefaultObjectAction implements ObjectAction{ 
   
        @Override
        public Object doAction(Object rev, LongLinkServer server) { 
   
            System.out.println("处理并返回："+rev);
            return rev;
        }
    }

    public static void main(String[] args) { 
   
        int port = 65432;
        LongLinkServer server = new LongLinkServer(port);
        server.start();
    }

    private int port;
    private volatile boolean running=false;
    private long receiveTimeDelay=3000;
    private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();
    private Thread connWatchDog;

    public LongLinkServer(int port) { 
   
        this.port = port;
    }

    public void start(){ 
   
        if(running) { 
   
            return;
        }
        running=true;
        connWatchDog = new Thread(new ConnWatchDog());
        connWatchDog.start();
    }

    @SuppressWarnings("deprecation")
    public void stop(){ 
   
        if(running) { 
   
            running=false;
        }
        if(connWatchDog!=null) { 
   
            connWatchDog.stop();
        }
    }

    public void addActionMap(Class<Object> cls,ObjectAction action){ 
   
        actionMapping.put(cls, action);
    }

    class ConnWatchDog implements Runnable{ 
   
        @Override
        public void run(){ 
   
            try { 
   
                ServerSocket ss = new ServerSocket(port,5);
                while(running){ 
   
                    Socket s = ss.accept();
                    new Thread(new SocketAction(s)).start();
                }
            } catch (IOException e) { 
   
                e.printStackTrace();
                LongLinkServer.this.stop();
            }

        }
    }

    class SocketAction implements Runnable{ 
   
        Socket s;
        boolean run=true;
        long lastReceiveTime = System.currentTimeMillis();
        public SocketAction(Socket s) { 
   
            this.s = s;
        }
        @Override
        public void run() { 
   
            while(running && run){ 
   
                if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){ 
   
                    overThis();
                }else{ 
   
                    try { 
   
                        InputStream in = s.getInputStream();
                        if(in.available()>0){ 
   
                            ObjectInputStream ois = new ObjectInputStream(in);
                            Object obj = ois.readObject();
                            lastReceiveTime = System.currentTimeMillis();
                            System.out.println("接收：\t"+obj);
                            ObjectAction oa = actionMapping.get(obj.getClass());
                            oa = oa==null?new DefaultObjectAction():oa;
                            Object out = oa.doAction(obj,LongLinkServer.this);
                            if(out!=null){ 
   
                                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
                                oos.writeObject(out);
                                oos.flush();
                            }
                        }else{ 
   
                            Thread.sleep(10);
                        }
                    } catch (Exception e) { 
   
                        e.printStackTrace();
                        overThis();
                    }
                }
            }
        }

        private void overThis() { 
   
            if(run) { 
   
                run=false;
            }
            if(s!=null){ 
   
                try { 
   
                    s.close();
                } catch (IOException e) { 
   
                    e.printStackTrace();
                }
            }
            System.out.println("关闭："+s.getRemoteSocketAddress());
        }

    }
}

package com.zmkj.app.test;


import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ConcurrentHashMap;

/** * C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。 * @author sunminghao */
public class LongLinkClient { 
   
    /** * 处理服务端发回的对象，可实现该接口。 */
    public static interface ObjectAction{ 
   
        void doAction(Object obj,LongLinkClient client);
    }

    public static final class DefaultObjectAction implements ObjectAction{ 
   
        @Override
        public void doAction(Object obj, LongLinkClient client) { 
   
            System.out.println("处理：\t"+obj.toString());
        }
    }


    public static void main(String[] args) throws UnknownHostException, IOException { 
   
        String serverIp = "127.0.0.1";
        int port = 65432;
        LongLinkClient client = new LongLinkClient(serverIp,port);
        client.start();
    }

    private String serverIp;
    private int port;
    private Socket socket;
    private boolean running=false; //连接状态

    private long lastSendTime; //最后一次发送数据的时间

    //用于保存接收消息对象类型及该类型消息处理的对象
    private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();

    public LongLinkClient(String serverIp, int port) { 
   
        this.serverIp=serverIp;
        this.port=port;
    }

    public void start() throws UnknownHostException, IOException { 
   
        if(running) { 
   
            return;
        }
        socket = new Socket(serverIp,port);
        System.out.println("本地端口："+socket.getLocalPort());
        lastSendTime=System.currentTimeMillis();
        running=true;
        new Thread(new KeepAliveWatchDog()).start();  //保持长连接的线程，每隔2秒项服务器发一个一个保持连接的心跳消息
        new Thread(new ReceiveWatchDog()).start();    //接受消息的线程，处理消息
    }

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

    /** * 添加接收对象的处理对象。 * @param cls 待处理的对象，其所属的类。 * @param action 处理过程对象。 */
    public void addActionMap(Class<Object> cls,ObjectAction action){ 
   
        actionMapping.put(cls, action);
    }

    public void sendObject(Object obj) throws IOException { 
   
        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
        oos.writeObject(obj);
        System.out.println("发送：\t"+obj);
        oos.flush();
    }

    class KeepAliveWatchDog implements Runnable{ 
   
        long checkDelay = 10;
        long keepAliveDelay = 2000;
        @Override
        public void run() { 
   
            while(running){ 
   
                if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){ 
   
                    try { 
   
                        LongLinkClient.this.sendObject(new LongLinkKeepAlive());
                    } catch (IOException e) { 
   
                        e.printStackTrace();
                        LongLinkClient.this.stop();
                    }
                    lastSendTime = System.currentTimeMillis();
                }else{ 
   
                    try { 
   
                        Thread.sleep(checkDelay);
                    } catch (InterruptedException e) { 
   
                        e.printStackTrace();
                        LongLinkClient.this.stop();
                    }
                }
            }
        }
    }

    class ReceiveWatchDog implements Runnable{ 
   
        @Override
        public void run() { 
   
            while(running){ 
   
                try { 
   
                    InputStream in = socket.getInputStream();
                    if(in.available()>0){ 
   
                        ObjectInputStream ois = new ObjectInputStream(in);
                        Object obj = ois.readObject();
                        System.out.println("接收：\t"+obj);
                        ObjectAction oa = actionMapping.get(obj.getClass());
                        oa = oa==null?new DefaultObjectAction():oa;
                        oa.doAction(obj, LongLinkClient.this);
                    }else{ 
   
                        Thread.sleep(10);
                    }
                } catch (Exception e) { 
   
                    e.printStackTrace();
                    LongLinkClient.this.stop();
                }
            }
        }
    }

}

今天的文章长连接和短连接的使用_如何判断是长连接还是短连接[通俗易懂]分享到此就结束了，感谢您的阅读。