关于Socket长连接异步单工

原创 2015年11月17日 16:28:15

1.关于异步单工长连接的概念问题,百度上有很多大牛给出了解释,在这边就不进行说明了,直接来代码

2.长连接异步单工 保持心跳,15秒发送一个心跳,服务器端60秒接收一次心跳,以此来判断两条链路是否在线

package com.credit.alive;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


import org.apache.log4j.Logger;


import com.credit.entity.ISO8583Utils;
import com.credit.utils.ByteUtils;


public class Client {


private String serverIp;
private int port;
private Socket socket;
private ServerSocket serverSocket;
private Socket serverSoc;
private int serverPort;
private boolean running = false;
private long lastSendTime;
private long lastReceTime;
OutputStream stream;
InputStream input;

Logger logger = Logger.getLogger(Client.class);
public static ConcurrentHashMap<String, Object> actionMapping = new ConcurrentHashMap<String, Object>();
private static Client client = null;


private Client() {
}


public void stop() {
if (running)
running = false;
try {
if(socket!=null)           socket.close();
if(stream!=null)          stream.close();
if(serverSoc !=null)     serverSoc.close();
if(input !=null)           input.close();
if(serverSocket!=null) serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}



private Client(String serverIp, int port, int serverPort) {
this.serverIp = serverIp;
this.serverPort = serverPort;
this.port = port;
}


public static Client getInstance(String serverIp, int port, int serverPort) throws UnknownHostException, IOException {
if (client == null) {
client = new Client(serverIp, port, serverPort);
client.start();
}
return client;
}

public static Client getInstance(){
return client;
}


public void start() throws UnknownHostException, IOException {
if (running)
return;
socket = new Socket(serverIp, port);
stream = socket.getOutputStream();
serverSocket = new ServerSocket(serverPort);
socket.setSoTimeout(60000);
lastSendTime = System.currentTimeMillis();
running = true;
Thread keepAliveWatch = new Thread(new KeepAliveWatchDog());
keepAliveWatch.setDaemon(true);
keepAliveWatch.start();
serverSoc = serverSocket.accept();
input = serverSoc.getInputStream();
new Thread(new ReceiveWatchDog()).start();
lastReceTime = System.currentTimeMillis();
}


public void reconnect() throws IOException{
logger.info("进入了重连方法:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
stop();
socket = new Socket(serverIp, port);
stream = socket.getOutputStream();
serverSocket = new ServerSocket(serverPort);
socket.setSoTimeout(60000);
lastSendTime = System.currentTimeMillis();
running = true;
serverSoc = serverSocket.accept();
input = serverSoc.getInputStream();
lastReceTime = System.currentTimeMillis();

logger.info("重连成功...");
}

public synchronized void sendObject(byte[] data)  {
System.out.println("发送数据:" + ByteUtils.getHexStr(data));//
try {
stream.write(data);
stream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}


class KeepAliveWatchDog implements Runnable {
long checkDelay = 10;
long keepAliveDelay = 15000;
public void run() {
while (true) {
if (System.currentTimeMillis() - lastSendTime > keepAliveDelay) {
sendObject("0000".getBytes());
lastSendTime =System.currentTimeMillis();
} else {
try {
Thread.sleep(checkDelay);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class ReceiveWatchDog implements Runnable {
long keepAliveDelay = 60000;
ReceiveWatchDog(){}
public void run() {
while (running) {
try {
if(System.currentTimeMillis() - lastReceTime  > keepAliveDelay && input.available() <= 0){
logger.info("lastReceTime:"+lastReceTime+ "   System.currentTimeMillis()"+System.currentTimeMillis() +"   掉线");
reconnect();
}
ByteArrayOutputStream outAr = null;
if (input.available() > 0) {
lastReceTime = System.currentTimeMillis();
outAr = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
input.read(bytes);
byte[] Datalen = new byte[] { bytes[0], bytes[1],
bytes[2], bytes[3] };// 获取长度
int readLen = ByteUtils.bytesToIntLen(Datalen);
logger.info("读取的长度:"+readLen);
if (readLen != 0) {
outAr.write(ByteUtils.subArray(bytes, 0, readLen + 4));
byte[] result = ByteUtils.subArray(
outAr.toByteArray(), 4, -1);// 去除长度
Map<Integer, String> str = new ISO8583Utils().fromISO8583(result);
logger.info("str:"+str);
Client.actionMapping.put(str.get(11), str);
}
} else {
Thread.sleep(10);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Java Socket长连接异步单工保持心跳

Socket异步单工长连接心跳机制

C语言 Socket入门示例1—— 单工通信(客户端向服务器发送消息)

如果对Windows API不太熟悉、对TCP/IP通信协议不太熟悉,或者对C语言本身不太熟悉的话,学习Socket会有点难受的。以前学习操作系统的时候,被API吓怕了,很多莫名其妙的API有着多如牛...

关于长链接,短链接,异步,同步,单工,双工的定义

长连接:指在一个TCP连接上可以连续发送多个数据包,在TCP连接保持期间,如果没有数据包发送,需要双方发检测包以维持此连接,一般需要自己做在线维持。  短连接:是指通信双...

java server 多client异步socket通信demo

本demo打包下载,请点击这里 本demo主要用java实现了服务器监听多客户端登录,并实现了客户端与服务器的异步socket通信,通信过程采用了消息队列缓冲机制(生产者消费者模式)。 登录过程是...

.net 中socket的异步长连接实例

最近在熟悉socket通讯,写一个简单的聊天实例,希望对以后的初学者有帮助..... 服务器端的界面    public partial class ClientSeverForm : Form  ...

异步同步,长连接短连接,半双工全双工单工看这一篇就够了

关于异步同步,长连接短连接,半双工全双工单工概念的整理 同步:如:三次握手,需要请求-响应配对,才进行下一个请求-响应; 异步:如:UDP会话,只管自己做自己的,至于对端是否处理成功,没有关...

Java Socket长链接 异步读写 实例

1.Server端 package com.bestpay.internet.server; import java.io.DataInputStream; import java.io.DataO...

【python网络编程】利用select实现socket全双工异步通信

在上一篇博文中,我们实现了tcp客户端与服务器的通信,但是功能十分局限,发送消息与接收消息不能同时进行。 接下来我将通过select这个模块,来实现全双工通信(随时可以接收信息以及发送信息)...

socket 异步双工

socket 异步双工之前没接触过,最近遇到了,看了别人的代码才明白什么意思:发送一次交易数据完成后不用等待这次的响应的返回,另外起一个异步的接收线程处理对方响应的数据,这就是异步;发送和接受使用同一...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)