Возможно вы искали: 'Heretic 2'

November 28 2024 06:52:11

Статистика

Статей: 87772
Просмотров: 93097738

Игры

Injustice: Gods Among Us ...
Dark Souls 2 Dark Souls II - вторая часть самой хардкорной ролевой игры 2011-2012 года, с новым героем, сюжето...
Battlefield 4 Battlefield 4 - продолжение венценосного мультиплеер-ориентированного шутера от первого ли...

Кино

Steins;Gate Любители японской анимации уже давно поняли ,что аниме сериалы могут дать порой гораздо больше пи...
Ку! Кин-дза-дза Начинающий диджей Толик и всемирно известный виолончелист Владимир Чижов встречают на шумной моск...

Обзоры на игры

• Обзор Ibara [PCB/PS2]	17930
• Обзор The Walking ...	18320
• Обзор DMC: Devil M...	19459
• Обзор на игру Valk...	15461
• Обзор на игру Stars!	17309
• Обзор на Far Cry 3	17503
• Обзор на Resident ...	15545
• Обзор на Chivalry:...	17036
• Обзор на игру Kerb...	17532
• Обзор игры 007: Fr...	16144

Превью о играх

• Превью к игре Comp...	17564
• Превью о игре Mage...	14078
• Превью Incredible ...	14320
• Превью Firefall	13081
• Превью Dead Space 3	15919
• Превью о игре SimC...	14325
• Превью к игре Fuse	15030
• Превью Red Orche...	15153
• Превью Gothic 3	15880
• Превью Black & W...	17004

Главная » Статьи » Разное » Реализация multithreaded сервера на C++ (threads linux mutex)

Реализация multithreaded сервера на C++ (threads linux mutex)

Ключевые слова: threads, linux, mutex, (найти похожие документы)

Date: Tue, 10 Dec 2002 16:15:22 +0500
From: Maksym Shevchenko <r0land@r0land.kiev.ua>
Newsgroups: ftn.ru.unix.prog
Subject: Реализация multithreaded сервера на C++

Вот реализовал один алгоритм и решил поделится с уважаемым All.
Постановка задачи: Требуется принимать входящие соединения и асинхронно
обрабатывать принимаемые данные и посылать что-то в ответ. Язык - С++,
target platform = Linux RH 7.x.

Что я сделал:
Первое - врапперы для POSIX mutex & pthread (на самом деле остались от
старого проекта):

class CMutex
{
public:
CMutex ();
~CMutex ();
bool lock ();
bool unlock ();
void cond_wait();
void cond_timedwait(long utime);
void cond_broadcast();
private:
pthread_mutex_t m_mutex;
pthread_cond_t m_cv;
};

class CThread
{
public:
CThread();
~CThread();
static void* _start(void* lwp);
int start(); //start thread
void join(void *ptr); //wait for thread end
void cancel();
void detach(); //detach thread
void stop(); //join (NULL)
void exit(void *ptr); //terminate thread from itself
void kill();
pid_t get_pid(); // get thread pid
virtual void * Loop ()=0;
private:
static void* _start(void* lwp);
void set_pid(pid_t p) { pid = p; };
pthread_attr_t attr;
pthread_t thread;
pid_t pid;
};

Здесь остановлюсь только на реализации функции CThread::start():

int CThread::start ()
{
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
pthread_attr_setscope(&attr,PTHREAD_SCOPE_PROCESS);
{
int ret;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE , &ret);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &ret);
}
return pthread_create(&thread, NULL, _start, this);
}

void* CThread::_start(void* lwp)
{
((CThread*)lwp)->set_pid(getpid());
p_debug(LOG_DEBUG, "Started thread [%d]", getpid());
return ((CThread*)lwp)->Loop();
}

Скажем, мне такая реализация показалась удобной, но обсуждаемой. ;-)
Далее реализовано несколько классов:
СListener - собствеено говоря он принимает входящие соединения;
СSocket - класс отвечающий за интерфейс с открытым сокетом;
СManager - управляет жзненым циклом CListener и хранит список СSocket.

class CManager : private CMutex, public CThread
{
public:
CManager();
~CManager();
CSocket* GetSocket (const FDS& id);
void KillSocket (const FDS& id);
const FDS AddSocket (CSocket *);
void Init ();
protected:
virtual void OnNewSocket (const FDS& id, const CSocket* socketX)=0;
virtual void OnReceiveData (const FDS& id)=0;
virtual void OnCloseSocket (const FDS& id)=0;
void *Loop ();
private:
CListener* m_pListener;
map<FDS,CSocket*> m_mapSocket;
};

class CListener : public CThread
{
public:
CListener(int iPortNum, const CManager *Manager);
~CListener();
protected:
void* Loop();
int m_fds;
CManager* m_pManager;
};

class CSocket
{
public:
CSocket(int fds, const CManager* pManager );
~CSocket();
void WriteStream (string str);
string ReadStream ();
int GetFDS();
private:
int m_fds;
CManager* m_pManager;
};

Т.е. релизуется две нити: первая - для того того что бы говорить listen и
accept,
а вторая ожидать входящие данные...
и так, реализация первой:

void * CListener::Loop()
{
struct sockaddr their_addr;
int sin_size;
int new_fd;
CSocket *pSocket;

if (::setpgrp () < 0)
{
p_debug (LOG_ERR, "setpgrp(): %s", strerror (errno));
::exit (-1);
}

while ( .... )
{
::listen(m_fds, LISTEN_BACKLOGSIZE);
sin_size = sizeof(struct sockaddr_in);
new_fd = ::accept(m_fds, &their_addr, (socklen_t *)&sin_size);
if (new_fd > 0)
{
pSocket = new CSocket(new_fd, m_pManager);
if ( (new_fd = m_pManager->AddSocket(pSocket)) == 0 )
{
p_debug(LOG_WARNING, "Can't AddSocket(0x%X) fd=0x%X", pSession, new_fd);
delete pSession; /* CSocket shall close new_fd */
}
}
else
{
p_debug(LOG_WARNING, "accept(): %s", strerror(errno));
}
}
return NULL;
}

и релизация второй нити:

void * CManager::Loop()
{
while ( .... )
{
struct pollfd* pfd;
int size = 0;
map<FDS,CSocket*>::iterator itr = m_mapSocket.begin();

if ( (size = m_mapSocket.size() ) > 0 )
{
lock();
pfd = (struct pollfd[])malloc(sizeof(struct pollfd[size]));

bzero(pfd, sizeof(struct pollfd[size]));

for (struct pollfd *ptr = pfd ; itr!=m_mapSocket.end(); itr++)
{
ptr->fd = (int)(itr->first);
ptr->events = POLLIN|POLLOUT|POLLHUP|POLLERR;
ptr++;
}

unlock();

if ((poll (pfd, size, POLLTIME)) < 0)
{
p_debug (LOG_WARNING, "poll(): %s", strerror (errno));
}

for (int i=0 ; i < size; i++)
{
if ((pfd[i].fd) > 0)
{
if (pfd[i].revents & POLLHUP || pfd[i].revents & POLLERR)
/* Socket hung-up */
{
p_debug(LOG_DEBUG, "Loop() got POLLHUP||POLLERR on fds=[%d]",(FDS)pfd[i].fd);
OnKillSocket((FDS)pfd[i].fd);
KillSocket((FDS)pfd[i].fd);
}

if (pfd[i].revents & POLLIN &&
(m_mapSocket.find((FDS)pfd[i].fd) != m_mapSocket.end()))
/* Got data & CSocket exist*/
{
p_debug(LOG_DEBUG, "Loop() got POLLIN on fds=[%d]",(FDS)pfd[i].fd);
OnReceiveData((FDS)pfd[i].fd);
}
}
}
free(pfd);
}
else
{
sleep(1); /* we have no opened sockets... what about using mutex here? */
}
}
}
return NULL;
}

Ранее был реализован вариант с ожиданием изменения состояния сокета через
sigwaitinfo(...) после того как с полученым сокетом (в CSocket::CSocket)
проводились следующие манипуляции:

if (fcntl(m_fds, F_SETOWN, m_pManager->get_pid()) < 0)
{
p_debug (LOG_ERR, "fcntl(F_SETOWN) : %s", ::strerror(errno));
::exit (1);
}

if (fcntl (m_fds, F_SETSIG, SIGRTMIN) < 0)
{
p_debug (LOG_ERR, "fcntl(F_SETSIG) : %s", ::strerror(errno));
::exit (1);
}

но к превеликому сожалению этот вариант имеет несколько недостатков. Во
первых этот вариант работает только тогда, когда pthreads реализованы как в
виде отдельных процессов. Во вторых fcntl(..,F_SETOWN,..) можно сделать
только от root'а. И в третьих, как не прискорбно, тестирование на 10000 и
более входящих соединениях показало что сигнал все таки облодает свойством
терятся.

Теперь смотрите как это используется:

class CServer : public CManager
{
void OnNewSocket (const FDS& id, const CSocket* socketX)
{
cout << "incomming fds=" << id << endl;
}

void OnReceiveData (const FDS& id)
{
GetSocket(id)->WriteStream(GetSocket(id)->ReadStream() + " processed by server.");
}

void OnCloseSocket (const FDS& id)
{
cout << "gone fds=" << id << endl;
}
}

Мне понравилось.

Почему я не рализовал listen в том же poll? Очень просто - представьте что
CManager'ов несколько, а CListener делает round-robin between them. T.е.
CManager::m_pListener становится статик и в CManager добовляется static
set<CManager *> m_setManager. Из конструктора CManager добовляем this в
m_setManger, из деструктора его соответсвенно убиваем. А в CListener::Loop
добавляется set<CManager*>::iterator который говорит куда мы добавляем вновь
созданый сокет.

Ссылки

HTML:
[BB Url]:

Похожие статьи
Название	Добавил	Добавлено
• Реализация multithreaded сервера на...	Vova	08.05.2012

Ни одного комментария? Будешь первым :).

Пожалуйста, авторизуйтесь для добавления комментария.

Статьи

Рецензия на Pressure Чтобы обратить на себя внимание, начинающие маленькие разработчики, как правило, уходят в жанры, ...
Рецензия на Lost Chron... Игры, сделанные без любви и старания, похожи на воздушный шар – оболочка есть, а внутри пусто. Lo...
Рецензия на The Bridge «Верх» и «низ» в The Bridge — понятия относительные. Прогуливаясь под аркой, можно запросто перей...
Рецензия на SimCity Когда месяц назад состоялся релиз SimCity, по Сети прокатилось цунами народного гнева – глупые ош...
Рецензия на Strategy &... Название Strategy & Tactics: World War II вряд ли кому-то знакомо. Зато одного взгляда на ее скри...
Рецензия на игру Scrib... По сложившейся традиции в информационной карточке игры мы приводим в пример несколько похожих игр...
Рецензия на игру Walki... Зомби и продукция-по-лицензии — которые и сами по себе не лучшие представители игровой биосферы —...