网络计算机模拟实现
今天给大家说说前几天完成的一个模拟的网络计算机吧，虽然计算机的模拟实现的原理很简单，但是如果要想写乘网络的，个人认为是不简单的。基本上算是包涵了套接字编程的三分之一的知识点，此处的套接字编程指的是在理解TCP/IP五层协议的基础上，如果不算理解这些协议的话，那么我感觉实现这个，应该是包含了多半的套接字编程。下面就让我们看看代码吧！
#pragma once
#include
#include
#include
#include
#include
#include "deal.hpp"
#define PTHREAD_NUM 6
#define TASKNUM 5
template
class pthreadPool;
template
struct data
{
std::string _name;
pthreadPool *_str;
data(pthreadPool *str) : _str(str)
{
}
};
template
class pthreadPool
{
public:
friend data;
static pthreadPool *get()
{
return _str;
}
void run(const T &x, int sock)
{
_task = x;
_sock = sock;
}
void start()
{
for (size_t i = 0; i < PTHREAD_NUM; i++)
{
data *p = new data(this);
if (i % 2 == 0)
p->_name = "product";
else
p->_name = "consumer";
pthread_create(tid + i, nullptr, enter, p);
}
std::cout << "wancheng" << std::endl;
}
~pthreadPool()
{
pthread_mutex_destroy(&_pmtx);
pthread_mutex_destroy(&_cmtx);
sem_destroy(&_p);
sem_destroy(&_c);
for (size_t i = 0; i < PTHREAD_NUM; i++)
pthread_join(tid[i], nullptr);
}
private:
int _sock = 0;
T _task = T();
pthread_t tid[PTHREAD_NUM];
pthread_mutex_t _pmtx;
pthread_mutex_t _cmtx;
sem_t _p;
sem_t _c;
int _pp = 0;
int _cc = 0;
std::vector _v;
static pthreadPool *_str;
pthreadPool()
{
_v.resize(TASKNUM);
sem_init(&_p, 0, TASKNUM);
sem_init(&_c, 0, 0);
pthread_mutex_init(&_cmtx, nullptr);
pthread_mutex_init(&_pmtx, nullptr);
}
void product(const T x)
{
// 生产数据
sem_wait(&_p);
pthread_mutex_lock(&_pmtx);
_v[_pp++] = x;
_pp = _pp % TASKNUM;
_task = T();
pthread_mutex_unlock(&_pmtx);
sem_post(&_c);
}
void consumer()
{
T x;
// 消费数据
sem_wait(&_c);
pthread_mutex_lock(&_cmtx);
x = _v[_cc++];
_cc = _cc % TASKNUM;
pthread_mutex_unlock(&_cmtx);
sem_post(&_p);
// 处理数据
deal(x, _sock);
}
static void *enter(void *args)
{
data *p = reinterpret_cast *>(args);
while (true)
{
if (strcmp(p->_name.c_str(), "product") == 0 && p->_str->_task != T())
p->_str->product(p->_str->_task);
else if (strcmp(p->_name.c_str(), "consumer") == 0)
p->_str->consumer();
//std::cout << "xiuxi" << std::endl;
continue;
}
delete p;
return nullptr;
}
};
template
pthreadPool *pthreadPool::_str = new pthreadPool(); #pragma once
#include
#include
#include
#include
#include
#include
#include
#include
void deal(std::string &data, int sock)
{
// 反序列化
std::string respon;
int x = 0;
int y = 0;
char op = '\0';
int lpos = data.find(" ");
int rpos = data.rfind(" ");
// std::cout< #include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "pthreadPool.hpp"
#define NUMSIZE 1024
const int listen_queue_flag = 20;
void func(pthreadPool &pt, int sock)
{
char buffer[NUMSIZE];
memset(buffer, 0, NUMSIZE);
ssize_t s = recv(sock, buffer, NUMSIZE, 0);
std::cout << buffer << std::endl;
if (s > 0)
{
std::string bufe = buffer;
pt.run(bufe, sock);
}
}
// 主函数
int main(int argc, char *argv[])
{
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
if (argc != 2)
{
std::cout << "格式错误" << std::endl;
exit(1);
}
// 创建套接字
int listensock = socket(AF_INET, SOCK_STREAM, 0);
if (listensock < 0)
{
std::cout << "socket enrro" << std::endl;
exit(1);
}
// 开始绑定
sockaddr_in local;
local.sin_addr.s_addr = inet_addr("0.0.0.0");
local.sin_family = AF_INET;
local.sin_port = htons(atoi(argv[1]));
int ret = bind(listensock, (sockaddr *)&local, sizeof(local));
if (ret < 0)
{
std::cout << "bind enrro" << std::endl;
exit(2);
}
// 监听
int listens = listen(listensock, listen_queue_flag);
if (listens < 0)
{
std::cout << "listen enrro" << std::endl;
exit(3);
}
// 建立线程池
pthreadPool *pstr = pthreadPool::get();
pstr->start();
// 建立链接
while (true)
{
sockaddr_in client;
socklen_t len = sizeof(client);
int sersock = accept(listensock, (sockaddr *)&client, &len);
if (sersock < 0)
{
std::cout << "accept enrro" << std::endl;
continue;
}
func(*pstr, sersock);
}
return 0;
} #include
#include
#include
#include
#include
#include
#include
#define NUM 10
int main(int argc, char *argv[])
{
if (argc != 3)
{
std::cout << "格式错误" << std::endl;
exit(1);
}
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
std::cout << "socket enrro" << std::endl;
exit(2);
}
sockaddr_in serve;
memset(&serve, 0, sizeof(serve));
serve.sin_addr.s_addr = inet_addr(argv[1]);
serve.sin_family = AF_INET;
serve.sin_port = htons(atoi(argv[2]));
int ret = connect(sock, (sockaddr *)&serve, sizeof(serve));
// std::cout<= 0)
{
// 连接成功
std::string buffer;
getline(std::cin, buffer);
// std::cout< 以上就是代码，代码量不大，但是主要是考虑的比较多。我又加了个线程池。如果是单生产者还好，但是我写成了多生产者和多消费者，这里就有好多问题，困扰了我很久，这个计算机我大概写了有半个月左右吧，难就难在了这个线程池的地方。下面先说说他的问题吧。
1.
首先就是我在服务端创建线程池的时候，迷糊了很久，刚开始我是在服务端创建了一个新线程，让这个新线程去调用线程池的函数，但是后来我发现不行，因为当时我是把关闭套接字的文件写到了服务端，这就导致一个问题，线程创建完成之后，线程池中的线程回去执行任务，但是，服务端的线程出来之后，就直接关闭文件了，导致无法发送。所以我就想了很长时间，最后把这个操作写到了处理函数的那里，这样就避免了连接错误以及服务端创建线程的问题，减少了消耗。
2.
其次而来的问题就是，因为这个线程池是多生产者多消费者的，所以我就想的是提高一点效率，携程了可以并发执行的模型，但是问题又来了，他们怎么插入任务，要知道的是服务端可不是生产者的角色，他只是负责把读取的人插到线程池，这就引发了一个问题，怎么插，所以我想了想，便在县城的私有成员变量中，写了一个任务和套接字的文件描述符。但是这样还有问题，不知道大家注意到了我的线程池中的插入，我没有用引用，这样会造成拷贝构造，但是这样可以大大降低错误发生概率，是的，解决不了(我没有想到解决方法)，这样写的目的是，在一个客户端访问时，我先运行run函数，然后我的生产者会插入任务，但是如果刚好在插入任务的之前，又有一个客户端访问时，此时的线程中的任务变量就会改变。所以我没有用引用，这样的话就可以在一定概率上解决这个问题，但是还是彻底解决不了。
3.
其次就是我写的是短连接，这个可以保证多人同时访问服务端不崩。
如果上面的实现用单生产者，多消费者的话，就可以解决，此方法如果用小伙伴知道解决的方法，希望告知，谢谢。