Server::Server(unsigned short pPort) : mAcceptor(mIo_service, tcp::endpoint(tcp::v4(), pPort))
{
	UID BindedSocket = AddNewSession(&mIo_service);
	mAcceptor.async_accept(mSessionMap[BindedSocket]->GetSocket(),
		boost::bind(&Server::handle_accept, this, mSessionMap[BindedSocket],
		boost::asio::placeholders::error));
	mIo_service.run();    
}

UID Server::AddNewSession(boost::asio::io_service* pIo_service)
{
	UID CurrentCount = mCounter++;
	mSessionMap[CurrentCount] = new Session(*pIo_service,CurrentCount,this->HandlePackage,this->DeleteClient);
	return CurrentCount;
}

void Server::handle_accept(Session* new_session,
      const boost::system::error_code& error)
{
	if (!error)
	{
		new_session->start();
		UID BindedSocket = AddNewSession(&mIo_service);
    	mAcceptor.async_accept(mSessionMap[BindedSocket]->GetSocket(),
       		boost::bind(&Server::handle_accept, this, mSessionMap[BindedSocket],
          	 boost::asio::placeholders::error));
	}
	else
	{
		delete new_session;
	}
}

Session:

void Session::start()
  {
    socket.async_read_some(boost::asio::buffer(mData, MAX_LENGTH),
		boost::bind(&Session::HandleRead, this,
    boost::asio::placeholders::error));
  }

void Session::HandleRead(const boost::system::error_code& pError)
  {
    if (!pError)
    {
	    socket.async_read_some(boost::asio::buffer(mData, MAX_LENGTH),
			boost::bind(&Session::HandleRead, this,
            boost::asio::placeholders::error));
    }
    else
    {
      delete this;
    }
  }

tcp::socket& Session::GetSocket()
{
    return socket;
}

void Session::HandleWrite(const boost::system::error_code& pError,
		size_t pBytes_transferred)
{
	if (pError)
		delete this;
}

Jetzt ist ja in jeder Session ein aktiver Thread wenn ich das richtig sehe!?
Es wird dann im anschließenden auf verschiene Objektvariablen und static Funktionen zum Ver- und Entschlüsseln von strings zugegriffen.
Was muss ich alles Thread sicher machen, damit es keine Probleme gibt?
Meines wissens muss ich doch alle Objekt und Member-Variablen zugriffe Thread-sicher machen. Weiterhin kann ich doch normale static funktionen, welche temorär variablen erstellt nicht extra sichern oder?

mfg
gandime

Ich habe genau ein io_service-Objekt.
Also wohl einen Threadpool.

Dann solltest Du die Zugriffe auf Deine Session-Map mit einem strand -Objekt absichern. Das heisst, alle asynchronen Handler, die auf die Session-Map zugreifen, sollten mit einem strand::wrap vorbehandelt werden.

Innerhalb einer Session musst Du gucken, ob Deine Handler in der Session sequentiell ausgeführt werden, oder ob potentiell mehrere Handler auf die gleichen Ressourcen zugreifen können. Zum Beispiel, wenn zwei asynchrone Operationen einen Buffer benutzen. Dann musst Du auch deren Handler wieder mit einem strand wrappen.
Bei ausschließlich sequentieller Ausführung von Handlern musst Du Dir eigentlich keine Gedanken machen.

Link korrigiert...

file:///E:/devel/extern/boost_1_39_0/doc/html/boost_asio/tutorial/tuttimer5.html

Fail. Epic fail.

Jetzt ist ja in jeder Session ein aktiver Thread wenn ich das richtig sehe!?

Wenn du nichtmal weisst welches Threading-Modell du verwendest, wie soll das dann überhaupt jemals irgendwas werden?

gandime schrieb:

Aber ich hab das Bsp leider absolut nicht verstanden
Ich verstehe nicht was das ganze da macht

Wundert mich garnicht. Die ASIO ist nicht gerade einfach. Sieht oberflächlich vielleicht einfach und kuhl aus, issi dann aber nicht. Also kuhl vielleicht, aber nicht einfach.

Nimm am besten was anderes als Basis für deinen Server.

edit:
ist es nicht einfach durch mutex möglich die zugriffe sicher zu machen?

boost::mutex::scoped_lock lock(mutex);
...
lock.unlock();

Oder kann es damit zu Problemen kommen?
Ich hab zwar ein paar Testläufe durchlaufen lassen aber wie man wissen sollte ist testen != verifikation!
Außerdem möchte ich langsam etwas profesioneller werden