需求还需上报下数据，服务本身就是单进程线程安全的，不能用阻塞socket，通过getsockopt（） TCP_INFO弄了个简单判断连接存活的方法，数据不是很重要，可靠性要求不高，也可以考虑udp. 可以在优化一下重连间隔周期，本样例，send 失败就重连频率过高。
src:文章来源：https://www.toymoban.com/news/detail-584001.html
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netdb.h>
#include <queue>
#include <netinet/tcp.h>
using namespace std;
class TCPClient
{
enum class status: uint32_t {
alive = 0,
connecting = 1,
disconnect = 2,
unknown = 3
};
public:
TCPClient();
status get_tcp_status();
bool connecting();
bool setup(std::string address, int port);
bool Send(char* data);
string receive(int size = 4096);
string read();
void exit();
private:
int sock;
std::string address;
int port;
struct sockaddr_in server;
status connection_status;
};
class QualityClient : public TCPClient {
public:
QualityClient();
~QualityClient();
bool pub_quality(char* data);
private:
std::queue<char*> send_buffer;
int capacity;
int size;
};
class QualityClientInstance
{
public:
// 获取单实例对象
static QualityClient *GetInstance();
//释放单实例，进程退出时调用
static void ReleaseInstance();
private:
// 将其构造和析构成为私有的, 禁止外部构造和析构
QualityClientInstance();
~QualityClientInstance();
// 将其拷贝构造和赋值构造成为私有函数, 禁止外部拷贝和赋值
QualityClientInstance(const QualityClientInstance &signal);
const QualityClientInstance &operator=(const QualityClientInstance &signal);
private:
// 唯一单实例对象指针
static QualityClient* instance;
//static std::mutex m_Mutex;
};
TCPClient::TCPClient()
{
sock = -1;
port = 0;
address = "";
}
bool TCPClient::setup(string address , int port)
{
if(sock == -1)
{
sock = socket(AF_INET , SOCK_STREAM | SOCK_NONBLOCK , IPPROTO_TCP);
if (sock == -1)
{
cout << "Could not create socket" << endl;
return false;
}
}
if((signed)inet_addr(address.c_str()) == -1)
{
struct hostent *he;
struct in_addr **addr_list;
if ( (he = gethostbyname( address.c_str() ) ) == NULL)
{
herror("gethostbyname");
cout<<"Failed to resolve hostname\n";
return false;
}
addr_list = (struct in_addr **) he->h_addr_list;
for(int i = 0; addr_list[i] != NULL; i++)
{
server.sin_addr = *addr_list[i];
break;
}
}
else
{
server.sin_addr.s_addr = inet_addr( address.c_str() );
}
server.sin_family = AF_INET;
server.sin_port = htons( port );
return connecting();
}
bool TCPClient::connecting() {
int ret = connect(sock, (struct sockaddr *)&server, sizeof(server));
int savedErrno = ret == 0 ? 0 : errno;
std::cout << "connect... : " << ret << ":" << savedErrno << std::endl;
switch(savedErrno)
{
case 0:
case EINPROGRESS: //Operation now in progress
case EINTR: //Interrupted system call
case EISCONN: //Transport endpoint is already connected
std::cout << "connecting..." << std::endl;
break;
case EAGAIN:
case EADDRINUSE:
case EADDRNOTAVAIL:
case ECONNREFUSED:
case ENETUNREACH:
std::cout << "reSave Error. " << savedErrno;
break;
case EACCES:
case EPERM:
case EAFNOSUPPORT:
case EALREADY:
case EBADF:
case EFAULT:
case ENOTSOCK:
std::cout << "connect error in Connector::startInLoop " << savedErrno;
::close(sock);
break;
default:
std::cout << "Unexpected error in Connector::startInLoop " << savedErrno;
::close(sock);
break;
}
return false;
}
TCPClient::status TCPClient::get_tcp_status()
{
struct tcp_info info;
int len = sizeof(info);
getsockopt(sock, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&len);
if(info.tcpi_state == TCP_ESTABLISHED) {
return status::alive;
} else if (info.tcpi_state == TCP_SYN_SENT || info.tcpi_state == TCP_SYN_RECV) {
return status::connecting;
} else {
printf("connection error : info.tcpi_state = %d != %d\n",info.tcpi_state, TCP_ESTABLISHED);
return status::disconnect;
}
}
/*bool Setsocketkeepalive(int sockfd)
{
int keepAlive=1;//开启keepalive属性
int keepIdle=10;//如该连接在10秒内没有任何数据往来，则进行探测
int keepInterval=2;//探测时发包的时间间隔为2秒
int keepCount=3;//探测尝试的次数。如果第1次探测包就收到响应了，则后2次的不再发送
if(setsockopt(sockfd,SOL_SOCKET,SO_KEEPALIVE,(void *)&keepAlive,sizeof(keepAlive))!=0)//若无错误发生，setsockopt()返回值为0
{
return false;
}
if(setsockopt(sockfd, SOL_TCP, TCP_KEEPIDLE,(void *)&keepIdle, sizeof(keepIdle))!=0)
{
return false;
}
if(setsockopt(sockfd,SOL_TCP, TCP_KEEPINTVL,(void *)&keepInterval,sizeof(keepInterval))!=0)
{
return false;
}
if(setsockopt(sockfd,SOL_TCP, TCP_KEEPCNT,(void *)&keepCount,sizeof(keepCount))!=0)
{
return false;
}
return true;
}*/
bool TCPClient::Send(char* data)
{
//check_tcp_alive(sock);
auto stat = get_tcp_status();
if( stat == status::alive)
{
int ret = send(sock , data , strlen(data) , 0);
cout << "Send ret : " << ret << endl;
if( ret < 0 )
{
cout << "Send failed : " << data << endl;
return false;
} else if (ret == 0) {
cout << "connection closed : " << data << endl;
abort();
}
} else if ( stat == status::connecting) {
return false;
} else {
close(sock);
close(sock);
sock = -1;
setup("192.168.6.45", 12358);
return false;
}
return true;
}
string TCPClient::receive(int size)
{
char buffer[size];
memset(&buffer[0], 0, sizeof(buffer));
string reply;
if( recv(sock , buffer , size, 0) < 0)
{
cout << "receive failed!" << endl;
return nullptr;
}
buffer[size-1]='\0';
reply = buffer;
return reply;
}
string TCPClient::read()
{
char buffer[1] = {};
string reply;
while (buffer[0] != '\n') {
if( recv(sock , buffer , sizeof(buffer) , 0) < 0)
{
cout << "receive failed!" << endl;
return nullptr;
}
reply += buffer[0];
}
return reply;
}
void TCPClient::exit()
{
close( sock );
}
QualityClient::QualityClient() {
capacity = 256;
size = 0;
}
QualityClient::~QualityClient() {}
bool QualityClient::pub_quality(char* data) {
bool success = Send(data);
if (!success) {
if (send_buffer.size() == capacity) {
send_buffer.pop();
}
send_buffer.push(data);
}
while (success && !send_buffer.empty())
{
success = Send(send_buffer.back());
if (success) send_buffer.pop();
}
}
//初始化静态成员变量
QualityClient *QualityClientInstance::instance = nullptr;
//std::mutex QualityClientInstance::m_Mutex;
// 注意：不能返回指针的引用，否则存在外部被修改的风险！
QualityClient * QualityClientInstance::GetInstance()
{
// 这里使用了两个 if 判断语句的技术称为双检锁；好处是，只有判断指针为空的时候才加锁，
// 避免每次调用 GetInstance的方法都加锁，锁的开销毕竟还是有点大的。
//if (m_SingleInstance == nullptr)
//{
//std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
if (instance == nullptr)
{
instance = new QualityClient();
}
//}
return instance;
}
void QualityClientInstance::ReleaseInstance()
{
//std::unique_lock<std::mutex> lock(m_Mutex); // 加锁
if (instance)
{
delete instance;
instance = nullptr;
}
}
int main() {
std::cout << "start" << std::endl;
//TCPClient tcp;
QualityClient* tcp = QualityClientInstance::GetInstance();
tcp->setup("192.168.6.45", 12358);
while(1)
{
tcp->pub_quality("haapy");
sleep(1);
}
QualityClientInstance::ReleaseInstance();
}
测试服务：文章来源地址https://www.toymoban.com/news/detail-584001.html
package main
import(
"log"
"fmt"
"net"
//"time"
)
func connHandlerTcp(c net.Conn) {
//1.conn是否有效
if c == nil {
log.Panic("无效的 socket 连接")
}
//2.新建网络数据流存储结构
buf := make([]byte, 1024)
//3.循环读取网络数据流
for {
//3.1 网络数据流写入 buffer
cnt, err := c.Read(buf)
//3.2 数据读尽、读取错误 关闭 socket 连接
if cnt == 0 || err != nil {
fmt.Println("connection close")
c.Close()
break
}
fmt.Println("get msg : ", cnt , ":", string(buf[0:cnt]))
}
}
func main(){
// tcp recv serv
listen, err := net.Listen("tcp", "0.0.0.0:12358")
if err!=nil{
panic(err)
return
}
defer listen.Close() // 延时关闭listen
fmt.Println("listening success:", listen.Addr())
// 循环等待客户端来连接
fmt.Println("等待客户端来连接..")
for{
conn, err := listen.Accept()
if err!=nil{
panic(err)
}else{
fmt.Printf("客户端%s已连接..", conn.RemoteAddr().String())
}
// 准备一个协程，为客户端服务
go connHandlerTcp(conn)
}
}
到了这里，关于linux c++ 非阻塞tcp socket client简单实现的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
