网络编程——阻塞TCP多线程多客户端

最新推荐文章于 2024-04-09 08:57:19 发布
最新推荐文章于 2024-04-09 08:57:19 发布
阅读量853 收藏 8
点赞数
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42109012/article/details/105358551
版权

前面已经介绍了简单TCP套接字编程：https://blog.csdn.net/weixin_42109012/article/details/105308403
但是只是实现了一对一的简单通讯，这是由于函数的阻塞机制导致的，同一时间只能一个客户端访问。

一、SOKECT操作模式

1、 SOKECT操作模式都可以看做
（1）阻塞：

默认模式
针对函数、针对线程
执行到某函数，停在那，函数有结果或者接收到数据后才执行下一条语句
当前线程会被挂起 
阻塞式函数（可设定为阻塞的函数）
阻塞函数（总是阻塞）

（2）非阻塞：

针对函数和线程
不管成功与否，函数立即返回，执行下一条语句
可能还没收到数据
可能过一会才会有结果
需要过一定时间再来查看结果或接收数据。

（3）同步：

针对事务，针对客户端与服务器端的配合，特别针对客户端。
一个事务，一端发出请求后，必须等待另一边返回结果后才会继续下一个事务。

（4）异步：

针对事务，针对客户端与服务器端的配合
客户端和服务器端各干各的
客户端发了个请求，不会等待服务器端响应，接着干别的了。
服务器端处理完客户端请求后，通知客户端接收或处理结果。
一般需要设置回调函数或构建消息机制

（5 ）操作模式关系

阻塞一定是同步
同步不一定阻塞
异步一定是非阻塞

2、Windows操作系统提供了以下几种模型。
选择（Select）
异步选择（WSAAsyncSelect）
事件选择（WSAEventSelect）
重叠I/O（Overlapped I/O）
完成端口（Completion Port)

二、阻塞模式多线程实现多客户端

1、 阻塞式函数
（1）一定阻塞

Socket、bind、listen、select

（2）不一定阻塞（可以设为非阻塞）

1、Accept
等客户端的连接（1个连接成功，返回）
2、Connect
默认超时时间：大概75秒
不断尝试连接服务器端（一旦连接成功，超时退出）
3、Send/sendto
发送缓冲区大小，1.1默认值8k，2.2为64k
发送缓冲区是否填满，（没满，完成写缓存，返回）
4、Recv/recvfrom
接收缓冲区数据是否为空（1个字节以上返回，返回同时清除缓冲区中对应数据）

2、多线程服务端程序设计
（1）线程概念
每个线程独立运行，互不干扰，一个线程阻塞，不影响其它线程执行

（2）函数介绍

_BegingThread(基本C、c++）

库文件：#include <process.h> 
创建函数：
uintptr_t _beginthread(
	void( *start_address )( void * ),	//线程函数
	unsigned stack_size,	//栈大小，0
	void *arglist	//参数，NULL
);
线程函数：void threadproc(void * param)
线程结束：_endthread();

_beginthreadex（c++、vc++）

创建函数：
unsigned long _beginthreadex( 
	void *security, 		//安全属性，NULL
	unsigned stack_size,	//堆栈的大小,0
	 unsigned ( __stdcall *start_address )( void * ), //线程函数
	void *arglist,			//参数，NULL
	 unsigned initflag,		//0立即运行
	unsigned *thrdaddr );	//线程ID
线内结束： _endthreadex 
其他同_beginthread

三、网络编程——阻塞TCP多线程多客户端

使用的是阻塞模式下多线程实现多客户端

1、服务端——server.cpp

/*****************************************************************************
* @author: ljf                                                               *
* @date  : 2020/03/17                                                        *
* @file  : Server.cpp                                                        *
* @brief : 基于TCP协议通信——服务端                                         *
*----------------------------------------------------------------------------*
*                           Change History                                   *
*----------------------------------------------------------------------------*
* Date        | Version   | Author         | Description                     *
*----------------------------------------------------------------------------*
* 2020/03/17  | 1.0       | ljf            | 创建并简单实现                  *
*----------------------------------------------------------------------------*
* 2020/03/31  | 2.0       | ljf            | 实现多客户端同时访问            *
*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <winsock.h>
#include <process.h>

#pragma comment(lib, "wsock32.lib")	//隐式加载

#define BUFF_SIZE 1024				//宏定义缓冲区大小

/*****************************************************************************
* @data  : 2020/3/31                                                         *
* @brief : 多线程实现信息交互                                                *
* @input :                                                                   *
*   *p : 客户端套接字                                                        *
* @output:                                                                   *
*   none : none                                                              *
*****************************************************************************/
void my_thread(void* p) {
	char RECV_BUFF[BUFF_SIZE];	//接收数据
	char reply[] = "已收到";

	SOCKET client_socket = *(SOCKET*)p;
	sockaddr_in client_addr;
	int client_addr_len = sizeof(client_addr);
	//获取客户端信息
	getpeername(client_socket, (sockaddr*)&client_addr, &client_addr_len);
	int client_port = ntohs(client_addr.sin_port);
	char client_ip[20];
	strcpy_s(client_ip, inet_ntoa(client_addr.sin_addr));	//将转换后的IP地址从缓冲区复制出来

	//信息交互
	while (1) {
		//清空缓冲区
		memset(RECV_BUFF, 0, BUFF_SIZE);
		//信息是否接受成功
		if (0 < recv(client_socket, RECV_BUFF, BUFF_SIZE, 0)) {
			printf("[Recv %s:%d]: %s\n", client_ip, client_port, RECV_BUFF);
			send(client_socket, reply, strlen(reply), 0);
		}
		//排除了0，负数情况下客户端已关闭
		else {
			break;
		}
	}
	printf("[%s:%d Disconnected]\n", client_ip, client_port);
	closesocket(client_socket);
	_endthread();
}

int main() {
	//初始化套接字
	WSADATA wsadata;
	if (WSAStartup(MAKEWORD(1, 1), &wsadata) != 0) {	//版本1
		printf("WSAStartup error ---- Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -1;
	}

	//创建监听套接字
	SOCKET server_socket;
	server_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == server_socket) {
		printf("create socket error ---- Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -2;
	}

	//初始化监听信息
	sockaddr_in server_addr;							//服务器地址信息
	int server_addr_len = sizeof(server_addr);
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(5678);
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);	//inet_addr("127.0.0.1")
	if (SOCKET_ERROR == bind(server_socket, (SOCKADDR*)&server_addr, server_addr_len)) {
		printf("socket bind error ---- Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -3;
	}

	//监听端口
	if (SOCKET_ERROR == listen(server_socket, 5)) {
		printf("socket listen error —— Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -4;
	}
	printf("Listening...\n");

	sockaddr_in client_addr;					//客户端地址，等待连接
	int client_addr_len = sizeof(client_addr);	//客户端地址大小
	SOCKET client_socket;						//客户端套接字

	//TCP阻塞accept，多线程接收信息
	while (1) {
		client_socket = accept(server_socket, (SOCKADDR*)&client_addr, &client_addr_len);
		printf("[%s:%d Connected]\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
		_beginthread(my_thread, 0, &client_socket);
	}

	closesocket(server_socket);				//关闭监听套接字
	WSACleanup();							//释放套接字资源
	system("pause");						//等待
	return 0;
}

2、客户端——client.cpp

/*****************************************************************************
* @author  : ljf                                                             *
* @date    : 2020/03/17                                                      *
* @file    : Client.cpp                                                      *
* @brief   : 基于TCP协议通信——客户端                                       *
*----------------------------------------------------------------------------*
*                           Change History                                   *
*----------------------------------------------------------------------------*
* Date        | Version   | Author         | Description                     *
*----------------------------------------------------------------------------*
* 2020/03/17  | 1.0       | ljf            | 创建并简单实现                  *
*----------------------------------------------------------------------------*
* 2020/03/31  | 2.0       | ljf            | 实现自己编辑发送数据            *
*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <winsock.h>

#pragma comment(lib, "wsock32.lib")	//隐式加载

#define BUFF_SIZE 1024				//宏定义缓冲区大小

int main() {
	int HOST_PORT = 5678;			//服务器端口
	char HOST_IP[20] = "127.0.0.1";	//服务器IP
	char RECV_BUFF[BUFF_SIZE];		//缓冲区
	char SEND_BUFF[BUFF_SIZE];

	//初始化套接字
	WSADATA wsadata;
	if (0 != WSAStartup(MAKEWORD(1, 1), &wsadata)) {		//版本1
		printf("WSAStartup error —— Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -1;
	}

	//创建客户端套接字
	SOCKET client_socket;
	client_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (INVALID_SOCKET == client_socket) {
		printf("create socket error —— Error Code: %d", WSAGetLastError());
		WSACleanup();
		return -2;
	}

	//初始服务器地址信息
	sockaddr_in server_socket;
	server_socket.sin_family = AF_INET;
	server_socket.sin_port = htons(HOST_PORT);
	server_socket.sin_addr.s_addr = inet_addr(HOST_IP);
	if (SOCKET_ERROR == connect(client_socket, (SOCKADDR*)&server_socket, sizeof(server_socket))) {
		printf("[%s:%d Connect failed —— Error Code: %d]\n", inet_ntoa(server_socket.sin_addr), ntohs(server_socket.sin_port), WSAGetLastError());
		WSACleanup();
		return -3;
	}
	else {
		printf("[%s:%d Connect success]\n", inet_ntoa(server_socket.sin_addr), ntohs(server_socket.sin_port));
	}

	//信息交互
	while (1) {
		//清空缓冲区
		memset(SEND_BUFF, 0, BUFF_SIZE);
		memset(RECV_BUFF, 0, BUFF_SIZE);

		printf("[Send]: ");
		//读取一行字符串，回车结束，回车会被读入
		fgets(SEND_BUFF, BUFF_SIZE, stdin);
		//处理末尾的回车
		SEND_BUFF[strlen(SEND_BUFF) - 1] = '\0';

		if (strlen(SEND_BUFF) != 0) {
			//收发数据
			send(client_socket, SEND_BUFF, strlen(SEND_BUFF), 0);
			recv(client_socket, RECV_BUFF, BUFF_SIZE, 0);
			printf("[Recv]: %s\n", RECV_BUFF);
		}
	}

	closesocket(client_socket);		//关闭客户端套接字
	WSACleanup();					//释放套接字资源
	system("pause");				//等待
	return 0;
}

四、结果

在这里插入图片描述

五、总结

1、问题
客户端同时连接
发送数据太大处理

有人_295
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ Socket 一个服务器 多个客户端 （阻塞式）
我本亲狂的博客
08-11 9808
服务端 ServerNet.h#pragma once #include <stdio.h> #include <winsock.h> #include<vector> #include<iterator> #include<iostream> #include <algorithm> #include<map> #include<string> using namespace std;#prag
tcp 同步阻塞+多线程 模型实现多客户端与服务器通信（封装好）
weixin_45178126的博客
04-03 929
服务器端 .h头文件 #ifndef CTCPNET_H #define CTCPNET_H #include <winsock2.h> #include <windows.h> #include <process.h> #include <list> #include <map> #include <iostream> #include <QDebug> using namespace std; class CTCPN
C# Socket异步、同步通信服务端、客户端源码，实现断线重连和支持多客户端连接，代码阅读易理解，附详细注释，VS2015编译通过
最新发布
WSlMUgkJw的博客
04-09 397
本文将深入探讨C# Socket异步、同步通信的实现方法，并重点介绍断线重连机制，以帮助读者更好地理解通信原理和提高编程效率。同步通信是一种阻塞型的通信模式，即在进行通信时，程序会一直等待直到通信结束。服务端和客户端都可以采用异步方式进行通信，相比于同步通信，异步通信具有更好的扩展性和稳定性。通过在服务端中采用多线程或异步方式处理客户端连接请求，可以实现多个客户端同时与服务端进行通信，提高系统的并发处理能力。本文通过详细的源码解析，深入讲解了C#中Socket异步、同步通信服务端、客户端的实现方法。
记录TCP协议使用Socket连接，客户端请求服务器read()阻塞问题
FunnyPrince_的博客
05-02 569
如图：客户端与服务端连接不上，服务端处于阻塞状态： 首先，使用FileInputStream流输入文件，使用FileInputStream.read()方法读取文件返回int型； 其次，关于read()方法的介绍：Reads up to b.length bytes of data from this input stream into an array of bytes. This method blocks until some input is available; 表明read()方式是一个阻塞式
TCP流套接字编程(模拟多个客户端与服务器交互)
Krive~Irving
07-10 802
TCP流套接字编程
c++ 之 socket udp与tcp client server实现
weixin_44834554的博客
11-14 3070
服务器开发 socket
QT/C++ TCP多线程客户端（收发线程分离，自动粘包处理，自动数据包成型）
09-03
QT/C++ TCP多线程客户端的设计是为了解决在高并发场景下可靠地收发数据的问题。TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，它确保了数据的顺序传输和错误检测。然而，当面对大量...
Linux网络编程(四)——epoll+多线程实现简单的聊天（linux 服务器端 windows客户端）
06-13
在本篇中，我们将深入探讨如何使用Linux网络编程技术，特别是epoll和多线程机制，来构建一个简单的跨平台聊天应用。这个应用涉及到Linux服务器端和Windows客户端的交互，让我们逐一解析其中的关键知识点。 首先，`...
java网络编程——网络版题库程序
08-25
总之，"java网络编程——网络版题库程序"是一个综合性的项目，它展示了如何利用Java的Socket编程实现客户端和服务器端的通信，通过多线程提升并发处理能力，并借助MySQL数据库存储和管理大量数据。这个项目对于学习...
C语言网络编程——课程设计文档
03-21
《C语言网络编程——课程设计文档》 C语言网络编程是一种基础且强大的技术，它使得开发者可以直接操作底层网络协议，实现高效、灵活的网络应用程序。本课程设计文档旨在引导学生深入理解网络编程的基本原理，通过...
Java网络编程之TCP协议下—上传文件到服务器程序
03-09
然而，这只是一个简化的示例，实际的网络编程中可能还需要处理更复杂的情况，如并发连接管理、多线程、流量控制等。对于大规模的文件服务，可能需要使用专门的文件传输协议如FTP或HTTP，或者更高级的框架如NIO（非...
Socket C++ TCP阻塞\非阻塞 服务器 客户端 开发
05-20
一个很详细的文档，基于c++ winsocket的非阻塞服务器开发
C++实现TCP Server 多线程同时连接多个客户端
Frobot的博客
04-16 6250
一、简介 本实验采用c++实现了tcp Server，采用多线程的方式可以同时与多个客户端通讯。其中主线程阻塞接收客户端连接，收到连接后开辟一个子线程做相应处理。 二、代码 #include <stdio.h> #include <winsock2.h> #include <WS2tcpip.h> #define MAXCLIENTNUM 100 //...
多线程实操&&阻塞队列
weixin_59216829的博客
09-10 295
阻塞队列是一种特殊的队列.也遵守"先进先出"的原则.阻塞队列能是一种线程安全的数据结构,并且具有以下特性:当队列满的时候,继续入队列就会阻塞,直到有其他线程从队列中取走元素.当队列空的时候,继续出队列也会阻塞,直到有其他线程往队列中插入元素.阻塞队列的一个典型应用场景就是 "生产者消费者模型".这是一种非常典型的开发模型.
【网络通信】关于TCP阻塞和非阻塞方式的总结
singularity0001的博客
11-03 4479
在网络编程时，我们需要注意创建的socket是阻塞状态还是非阻塞状态的，这两种状态在编程时，对于每一个socket系统调用函数（connect、send、sendto、recv、recvfrom）都有一定的影响，socket的阻塞和非阻塞状态可以在每一个socket系统调用调用之前设置，对应着每一个socket系统调用是否是阻塞和非阻塞的；
socket网络编程之多线程阻塞IO实例
絜矩书生的博客
04-05 3713
网络层次结构、socket与TCP/UDP之间的关系。同步、异步，阻塞、非阻塞的区别。socket多线程阻塞IO实例
多线程阻塞
hhhg1234的博客
04-21 1634
线程状态 1.New（） 新建状态 新建了一个线程对象 2.Runnable（）就绪状态 线程创建完毕后，放在可运行线程池中，等待CPU调动 3.Running（）运行状态 就绪状态的线程获取了CPU，执行程序代码 4.Blocked（） 阻塞状态 5.Dead（）死亡状态 阻塞情况 （一）等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁) （二）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。 （三）
浅析tcp中select使用(思路源于工作)
dicuibing6539的博客
09-06 493
虽然说poll和epoll要比select好很多，但是还是有很多地方select稳健运行着，而且select相关的资料也多。接下来就简单阐述下工作中route模块对这些的使用。 在服务端使用tcp的一般流程是：socket->bind->listen->select->accept->read/write ...
TCP，阻塞问题
qq_56533553的博客
11-03 194
TCP IO读写文件或文字阻塞
学习网络编程5-多线程服务器.ppt
11-12
"本资源是一份关于网络编程的学习材料，主要聚焦于多线程服务器的设计与实现，特别是针对UDP和TCP协议的循环服务器模型以及并发服务器中的多路复用I/O技术。学习内容包括以下几个关键知识点： 1. 多线程服务器模型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值