进击的小白Day017——基于TCP的Socket编程（七）（完结）

其他 2018-12-17 13:28:32 阅读次数: 0

在之前的基础上做了一点优化，代码量少了200多行，这次可以跑的通，这个程序终于完成了。不多说，直接贴代码。

#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib,"ws2_32.lib")
#define PORT 8888  /*定义端口*/
#define MODE 1  /*定义服务端（1）/客户端（2）*/
#define MAXDATA 100  /*定义最大传输数量*/
#define T 100
#define MAX_MAIN 10
#define MAX_RUN 3
#define MAX_MESSAGE 20
#include <windows.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>

/*定义时间结构体*/
struct Time
{
	long int modeTime;
	long int connectTime;
	long int messageTime;
	long int allowTime[MAX_RUN];
	long int exeTime[MAX_RUN];
	long int calTime[MAX_RUN];
	long int waitTime[MAX_RUN];
};

/*微秒计时函数*/
int gettimeofday(struct timeval *tp, void *tzp)
{

	time_t clock;
	struct tm tm;
	SYSTEMTIME wtm;
	GetLocalTime(&wtm);
	tm.tm_year = wtm.wYear - 1900;
	tm.tm_mon = wtm.wMonth - 1;
	tm.tm_mday = wtm.wDay;
	tm.tm_hour = wtm.wHour;
	tm.tm_min = wtm.wMinute;
	tm.tm_sec = wtm.wSecond;
	tm.tm_isdst = -1;
	clock = mktime(&tm);
	tp->tv_sec = clock;
	tp->tv_usec = wtm.wMilliseconds * 1000;
	return 0;
}

/*执行算法*/
int exe(void)
{
	long i = 10000000L;
	while (i--);
	return 0;
}

/*模式选择函数*/
int modeChoose(void)
{
	int mode;

	/*选择服务端或客户端*/
	printf("Please choose server of client.		1.Server  2.Client\n");
	/*scanf_s("%d", &mode);
	getchar();*/
	mode = MODE;

	return mode;
}

/*创建套接字*/
SOCKET creatSocket(void)
{
	SOCKET Socket = socket(AF_INET, SOCK_STREAM, 0);
	if (Socket == -1)
	{
		printf("Socket error !");
		getchar();
		exit(1);
	}
	return Socket;
}

/*绑定IP端口*/
void bindIP(SOCKET Socket, struct sockaddr_in Socketaddr)
{
	/*绑定IP和端口*/
	Socketaddr.sin_family = AF_INET;  /*定义家族协议*/
	Socketaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  /*定义主机地址*/
	Socketaddr.sin_port = htons(PORT);  /*定义主机端口*/
	if (bind(Socket, (struct sockaddr *)&Socketaddr, sizeof(Socketaddr)) == -1)  /*绑定成功返回0*/
	{
		printf("Bind error !");
		getchar();
		exit(1);
	}
}

/*监听*/
void listenSocket(SOCKET Socket)
{
	/*开始监听*/
	if (listen(Socket, 20) == -1)
	{
		printf("Listen error !");
		getchar();
		exit(1);
	}
}

SOCKET acceptSocket(SOCKET Socket_1, struct sockaddr_in Socketaddr_2)
{
	int len = sizeof(struct sockaddr_in);
	SOCKET Socket_2 = accept(Socket_1, (SOCKADDR *)&Socketaddr_2, &len);
	if (Socket_2 == -1)
	{
		printf("Accept error !");
		getchar();
		exit(1);
	}

	return Socket_2;
}

void connentSocket(SOCKET Socket, struct sockaddr_in Socketaddr)
{
	int con;
	/*连接服务端*/
	con = -1;
	while (con == -1)
	{
		con = connect(Socket, (struct sockaddr*)&Socketaddr, sizeof(Socketaddr));
		if (con == -1)
		{
			printf("Connect error!\n");
		}
	}
}

void sendMessage(SOCKET Socket, char *Msg, int len)
{
	/*发送准备信息*/
	if (send(Socket, Msg, len, 0) < 0)
	{
		printf("\n\nSend error or connection interruption !\n");
		getchar();
		exit(1);
	}
}

char *receiveMessage(SOCKET Socket)
{
	int ret;
	char receiveData[MAXDATA];

	/*接收准备信息*/
	ret = recv(Socket, receiveData, MAXDATA, 0);
	if (ret > 0)
	{
		receiveData[ret] = 0x00;
	}
	/*接收不到客户端数据时中断循环*/
	else
	{
		printf("\n\nReceive error or connection interruption !\n");
		getchar();
		exit(1);
	}

	return receiveData;
}

/*字符串转换*/
char *charChange(double d)
{
	int dec_1, sign_1, dec_2, sign_2;
	char *c;
	_ecvt(d, 10, &dec_1, &sign_1);
	c = _ecvt(d, dec_1, &dec_2, &sign_2);
	return c;
}

int compareTime(int a, int b)
{
	int t;
	if (a >= b)
	{
		t = a;
	}
	else
	{
		t = b;
	}

	return t;
}

struct Time run(void)
{
	/*各种定义声明*/
	SOCKET server;
	SOCKET client;
	struct sockaddr_in serveraddr;
	struct sockaddr_in clientaddr;
	WSADATA wsaData;
	struct Time allTime;

	int len = sizeof(struct sockaddr_in);
	int exeTime, serverTime_i, clientTime_i, ret_time_server, ret_time_client;
	int t = T, waitTime;
	int mode, i;
	char receiveData[MAXDATA];
	char *runData;
	char test[MAXDATA];
	char byeData[MAXDATA];
	char *serverTime_c = NULL, *serverTime_c_server, *clientTime_c = NULL, *clientTime_c_client;
	double serverTime_d, clientTime_d;
	clock_t startTime, endTime;
	struct timeval start, end;
	long int allowSum = 0, exeSum = 0, calSum = 0, waitSum = 0, runSum = 0;
	int waitTime_0[MAX_RUN];

	/*微妙计时开始*/
	gettimeofday(&start, NULL);

	mode = modeChoose();
	Sleep(1);

	/*微妙计时结束，计算连接时间*/
	gettimeofday(&end, NULL);
	allTime.modeTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

	/*服务端*/
	if (mode == 1)
	{
		/*微妙计时开始*/
		gettimeofday(&start, NULL);

		/*启动windows的socket服务，初始化WSA*/
		WSAStartup(0x101, &wsaData);

		/*创建服务端，初始化服务端地址*/
		memset((void*)&serveraddr, 0, sizeof(serveraddr));

		server = creatSocket();

		bindIP(server, serveraddr);

		listenSocket(server);

		client = acceptSocket(server, serveraddr);

		/*微妙计时结束，计算连接时间*/
		gettimeofday(&end, NULL);
		allTime.connectTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

		/*微妙计时开始*/
		gettimeofday(&start, NULL);

		for (i = 0; i < MAX_MESSAGE; i++)
		{
			sendMessage(client, "I'm ready !", 11);
			receiveMessage(client);
		}

		/*微妙计时结束，计算消息时间*/
		gettimeofday(&end, NULL);
		allTime.messageTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

		for (i = 0; i < MAX_RUN; i++)
		{
			/*微妙计时开始*/
			gettimeofday(&start, NULL);

			/*发：第一次握手*/
			sendMessage(client, "First:Run !", 11);

			/*收：第二次握手*/
			runData = receiveMessage(client);
			strcpy(test, runData);

			if (strcmp(test, "Second:Run !") == 0)
			{
				/*发：第三次握手*/
				sendMessage(client, "Third:Run !", 11);

				/*微妙计时结束，计算运行时间*/
				gettimeofday(&end, NULL);
				allTime.allowTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
				allowSum = allowSum + allTime.allowTime[i];

				/*运行时间大于周期时间，则直接运行运行*/
				if (t >= T)
				{
					/*微妙计时开始*/
					gettimeofday(&start, NULL);

					/*计时开始*/
					startTime = clock();

					exe();

					/*计时结束*/
					endTime = clock();

					/*微妙计时结束，计算运行时间*/
					gettimeofday(&end, NULL);
					allTime.exeTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
					exeSum = exeSum + allTime.exeTime[i];

					/*微妙计时开始*/
					gettimeofday(&start, NULL);

					/*服务端运行用时*/
					serverTime_d = (double)(endTime - startTime);

					serverTime_c_server = charChange(serverTime_d);

					sendMessage(client, serverTime_c_server, strlen(serverTime_c_server));

					clientTime_c = receiveMessage(client);

					/*字符串转整形*/
					serverTime_i = atoi(serverTime_c_server);
					clientTime_i = atoi(clientTime_c);

					t = compareTime(serverTime_i, clientTime_i);

					/*微妙计时结束，计算运行时间*/
					gettimeofday(&end, NULL);
					allTime.calTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
					calSum = calSum + allTime.calTime[i];

					/*运行总时长小于周期时间，挂起*/
					if (t <= T)
					{
						waitTime_0[i] = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;

						Sleep(waitTime_0[i]);
						t = T;

						allTime.waitTime[i] = waitTime_0[i] * 1000;
						waitSum = waitSum + allTime.waitTime[i];
					}
					else
					{
						allTime.waitTime[i] = 0;
					}
				}
			}
		}

		closesocket(server);
		WSACleanup();

		printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
		printf("allowTime=%ld, exeTime=%ld, calTime=%ld, waitTime=%ld\n\n", allowSum / MAX_RUN, exeSum / MAX_RUN, calSum / MAX_RUN, waitSum / MAX_RUN);
	}

	/*客户端*/
	else
	{
		/*微妙计时结束，计算连接时间*/
		gettimeofday(&end, NULL);
		allTime.modeTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

		/*微妙计时开始*/
		gettimeofday(&start, NULL);

		/*启动windows的socket服务，初始化WSA*/
		WSAStartup(0x101, &wsaData);

		/*创建客户端，初始化客户端地址*/
		memset((void*)&clientaddr, 0, sizeof(clientaddr));

		client = creatSocket();

		/*绑定IP和端口*/
		clientaddr.sin_family = AF_INET;  /*定义家族协议*/
		clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  /*定义主机地址*/
		clientaddr.sin_port = htons(PORT);  /*定义主机端口*/

		connentSocket(client, clientaddr);

		/*微妙计时结束，计算连接时间*/
		gettimeofday(&end, NULL);
		allTime.connectTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

		/*微妙计时开始*/
		gettimeofday(&start, NULL);

		for (i = 0; i < MAX_MESSAGE; i++)
		{
			receiveMessage(client);
			sendMessage(client, "I'm ready too !", 15);
		}

		/*微妙计时结束，计算消息时间*/
		gettimeofday(&end, NULL);
		allTime.messageTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;

		/*检验运行许可指令并开始执行*/

		for (i = 0; i < MAX_RUN; i++)
		{
			/*微妙计时开始*/
			gettimeofday(&start, NULL);

			/*收：第一次握手*/
			runData = receiveMessage(client);
			strcpy(test, runData);
			if (strcmp(test, "First:Run !") == 0)
			{
				/*发：第二次握手*/
				sendMessage(client, "Second:Run !", 12);
			}

			/*微妙计时结束，计算运行时间*/
			gettimeofday(&end, NULL);
			allTime.allowTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
			allowSum = allowSum + allTime.allowTime[i];

			/*收：第三次握手*/
			runData = receiveMessage(client);
			strcpy(test, runData);

			if (strcmp(test, "Third:Run !") == 0)
			{
				/*运行时间大于周期时间，则直接运行运行*/
				if (t >= T)
				{
					/*微妙计时开始*/
					gettimeofday(&start, NULL);

					/*计时开始*/
					startTime = clock();

					exe();

					/*计时结束*/
					endTime = clock();

					/*微妙计时结束，计算运行时间*/
					gettimeofday(&end, NULL);
					allTime.exeTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
					exeSum = exeSum + allTime.exeTime[i];

					/*微妙计时开始*/
					gettimeofday(&start, NULL);

					/*客户端运行用时*/
					clientTime_d = (double)(endTime - startTime);

					clientTime_c_client = charChange(clientTime_d);

					sendMessage(client, clientTime_c_client, strlen(clientTime_c_client));

					serverTime_c = receiveMessage(client);

					/*字符串转整形*/
					serverTime_i = atoi(serverTime_c);
					clientTime_i = atoi(clientTime_c_client);

					t = compareTime(serverTime_i, clientTime_i);

					/*微妙计时结束，计算运行时间*/
					gettimeofday(&end, NULL);
					allTime.calTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
					calSum = calSum + allTime.calTime[i];

					/*运行总时长小于周期时间，挂起*/
					if (t <= T)
					{
						waitTime_0[i] = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;

						Sleep(waitTime_0[i]);
						t = T;

						allTime.waitTime[i] = waitTime_0[i] * 1000;
						waitSum = waitSum + allTime.waitTime[i];
					}
					else
					{
						allTime.waitTime[i] = 0;
					}
				}
			}
		}

		closesocket(client);
		WSACleanup();

		printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
		printf("allowTime=%ld, exeTime=%ld, calTime=%ld, waitTime=%ld\n\n", allowSum / MAX_RUN, exeSum / MAX_RUN, calSum / MAX_RUN, waitSum / MAX_RUN);
	}
	return allTime;

}

int main(void)
{
	/*各种定义*/
	struct Time pTime[MAX_MAIN];
	int i, j, k, l;
	long int modeTimeMax, connectTimeMax, messageTimeMax, allowTimeMax, exeTimeMax, calTimeMax, waitTimeMax;
	long int modeTimeSum, connectTimeSum, messageTimeSum, allowTimeSum, exeTimeSum, calTimeSum, waitTimeSum;
	long int modeTimeAve, connectTimeAve, messageTimeAve, allowTimeAve, exeTimeAve, calTimeAve, waitTimeAve;

	/*运行程序*/
	for (i = 0; i < MAX_MAIN; i++)
	{
		pTime[i] = run();
	}

	/*计算选择模式的最大时间*/
	for (j = 1, modeTimeMax = 0; j < MAX_MAIN; j++)
	{
		if (modeTimeMax < pTime[j].modeTime)
		{
			modeTimeMax = pTime[j].modeTime;
		}
	}

	/*计算连接的最大时间*/
	for (j = 1, connectTimeMax = 0; j < MAX_MAIN; j++)
	{
		if (connectTimeMax < pTime[j].connectTime)
		{
			connectTimeMax = pTime[j].connectTime;
		}
	}

	/*计算发送接收消息的最大时间*/
	for (j = 1, messageTimeMax = 0; j < MAX_MAIN; j++)
	{
		if (messageTimeMax < pTime[j].messageTime)
		{
			messageTimeMax = pTime[j].messageTime;
		}
	}

	/*计算三次握手的最大时间*/
	for (k = 1, allowTimeMax = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			if (allowTimeMax < pTime[k].allowTime[l])
			{
				allowTimeMax = pTime[k].allowTime[l];
			}
		}
	}

	/*计算执行算法的最大时间*/
	for (k = 1, exeTimeMax = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			if (exeTimeMax < pTime[k].exeTime[l])
			{
				exeTimeMax = pTime[k].exeTime[l];
			}
		}
	}

	/*计算时间汇总的最大时间*/
	for (k = 1, calTimeMax = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			if (calTimeMax < pTime[k].calTime[l])
			{
				calTimeMax = pTime[k].calTime[l];
			}
		}
	}

	/*计算等待的最大时间*/
	for (k = 1, waitTimeMax = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			if (waitTimeMax < pTime[k].waitTime[l])
			{
				waitTimeMax = pTime[k].waitTime[l];
			}
		}
	}

	/*计算选择模式的平均时间*/
	for (j = 1, modeTimeSum = 0; j < MAX_MAIN; j++)
	{
		modeTimeSum += pTime[j].modeTime;
	}
	modeTimeAve = modeTimeSum / (MAX_MAIN - 1);

	/*计算连接的平均时间*/
	for (j = 1, connectTimeSum = 0; j < MAX_MAIN; j++)
	{
		connectTimeSum += pTime[j].connectTime;
	}
	connectTimeAve = connectTimeSum / (MAX_MAIN - 1);

	/*计算发送接收消息的平均时间*/
	for (j = 1, messageTimeSum = 0; j < MAX_MAIN; j++)
	{
		messageTimeSum += pTime[j].messageTime;
	}
	messageTimeAve = messageTimeSum / (MAX_MAIN - 1);

	/*计算执行算法的平均时间*/
	for (k = 1, allowTimeSum = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			allowTimeSum += pTime[k].allowTime[l];
		}
	}
	allowTimeAve = allowTimeSum / ((MAX_MAIN - 1) * MAX_RUN);

	/*计算执行算法的平均时间*/
	for (k = 1, exeTimeSum = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			exeTimeSum += pTime[k].exeTime[l];
		}
	}
	exeTimeAve = exeTimeSum / ((MAX_MAIN - 1) * MAX_RUN);

	/*计算时间汇总的平均时间*/
	for (k = 1, calTimeSum = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			calTimeSum += pTime[k].calTime[l];
		}
	}
	calTimeAve = calTimeSum / ((MAX_MAIN - 1) * MAX_RUN);

	/*计算等待的平均时间*/
	for (k = 1, waitTimeSum = 0; k < MAX_MAIN; k++)
	{
		for (l = 0; l < MAX_RUN; l++)
		{
			waitTimeSum += pTime[k].waitTime[l];
		}
	}
	waitTimeAve = waitTimeSum / ((MAX_MAIN - 1) * MAX_RUN);

	/*输出结果*/
	printf("modeTimeMax=%ld, modeTimeAve=%ld\n", modeTimeMax, modeTimeAve);
	printf("connectTimeMax=%ld, connectTimeAve=%ld\n", connectTimeMax, connectTimeAve);
	printf("messageTimeMax=%ld, messageTimeAve=%ld\n", messageTimeMax, messageTimeAve);
	printf("allowTimeMax=%ld, allowTimeAve=%ld\n", allowTimeMax, allowTimeAve);
	printf("exeTimeMax=%ld, exeTimeAve=%ld\n", exeTimeMax, exeTimeAve);
	printf("calTimeMax=%ld, calTimeAve=%ld\n", calTimeMax, calTimeAve);
	printf("waitTimeMax=%ld, waitTimeAve=%ld\n", waitTimeMax, waitTimeAve);

	Sleep(10000000000);

	return 0;
}

收获：
之前主程序循环的时候总会出现断连的情况，偶然清理了一下项目，再运行发现断连情况少了很多，看来“清理——重新生成”有时候会有奇效。

猜你喜欢

转载自blog.csdn.net/u011232393/article/details/84979021
今日推荐
数学建模Matlab之数据预处理方法
充电桩---ISO15118协议详细介绍
对话Kaldi之父、小米首席语音科学家Daniel Povey：开源环境比金钱和荣誉更吸引我 | AGI技术50人...
Hugging Face全攻略：轻松下载Llama 3模型，探索NLP的无限可能！【实操】
阅读送书抽奖？玩转抽奖游戏，js-tool-big-box工具库新上抽奖功能
百度发布Comate代码知识增强2.0，国内首个支持实时检索智能代码助手
黑客利用扫雷游戏 Python 克隆隐藏恶意脚本，攻击欧洲和美国金融机构
微软对开源字体 Cascadia Code 进行重大更新
好书推荐《ChatGPT原理与架构：大模型的预训练、迁移和中间件编程 》
Baidu Comate 智能编码助手：编程新伙伴，效率新飞跃
AI时代：人工智能大模型引领科技创造新时代
百篇博客 · 千里之行
周排行
WebSocket、HTTP 与 TCP
private,public,protected的区别
Python用了这么多年，总结出超实用的功能和特点
dgwp笔记
ModuleNotFoundError: No module named 'gdbm'
数组的去重方法
Ternsorflow 学习：005-MNIST 实现模型
SpringBoot 2 源码学习笔记（二）
jaxws-spring 搭建Web Services笔记
读取properties文件并获取属性值
每日归档
更多
2024-05-27(56)
2024-05-26(6)
2024-05-25(68)
2024-05-24(65)
2024-05-23(9)
2024-05-22(41)
2024-05-21(8)
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022