boost TCP-Server Thread sicher machen?

Hi,
mein boost TCP-Server läuft ganz gut.
Blos wie mache ich das ganze jetzt Thread sicher?
So initialisiere ich meinen TCP-Server:

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

Tachyon

Das hängt davon ab, ob Du mehrere io_service -Objekte mit jeweils einem Thread benutzt, oder ein io_service -Objekt mit Threadpool.

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

Tachyon

gandime schrieb:

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.

Wie würde ich dann das ganze bei z.B. der map machen und wie sieht das ganze mit anderen Member-Variablen aus?
Bei Google hab ich bis jetzt noch kein passendes Beispeil dazu gefunden!

Tachyon

Guck Dir mal die boost.asio Beispiele an. Da wirst Du fündig werden.
Hier zum Beispiel.

Link korrigiert...

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

a schrieb:

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

Fail. Epic fail.

ja von Tachyon

Wer im inet suchen kann der findet das dann schon^^
Aber ich hab das Bsp leider absolut nicht verstanden
Ich verstehe nicht was das ganze da macht

hustbaer

gandime schrieb:

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.

Ich werde jetzt ganz bestimmt nicht noch eine andere Komponennte o.ä. benutzen!
Wie sehe ich denn welches Threading-Modell ich benutze?

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