ich habe einen TCP-Server der mehrere Sockets verwalten kann, da klappt alles super, nun habe ich ein TTL (Time To Live) eingebaut, der angibt, wie lange ein Socket unbenutzt leben darf. Klappt auch alles soweit ganz gut nur habe ich das Problem den Socket nach ablauf des TTL "sauber" runter zu fahren. Habe ehr den eindruck das ich den "hart" abstürzen lasse. Hier mal mein Code:

connection::~connection()
{
    log& log_ = log::getInstance(server_settings_);
    log_.write("connection closed: "+unique_id_, log::DEBUG);
}

void connection::handle_read(const boost::system::error_code& error, std::size_t bytes_transferred)
{
    ttl_is_running_ = true;
    ttl_thread_.interrupt();
    ttl_thread_ = boost::thread(boost::bind(&connection::run_ttl, shared_from_this()));
}
void connection::stop()
{
    log& log_ = log::getInstance(server_settings_);
    log_.write("stop have been called: "+unique_id_, log::DEBUG);
    ttl_is_running_ = false;
    boost::lock_guard<boost::mutex> lock(ttl_mutex_);
    ttl_break_condition_.notify_one();
    ttl_thread_.join();
    socket_.close();
}

void connection::run_ttl()
{
    boost::unique_lock<boost::mutex> lock(ttl_mutex_);
    log& log_ = log::getInstance(server_settings_);
    try {
        do {
	    log_.write("ttl have been started: "+unique_id_, log::DEBUG);
	    ttl_is_running_ = false;
	} while (!ttl_break_condition_.timed_wait(lock, boost::posix_time::seconds(15)) && ttl_is_running_);
        log_.write("ttl have been expired: "+unique_id_, log::DEBUG);
	connection_manager_.stop(shared_from_this());
    } catch (boost::thread_interrupted&) {
        log_.write("ttl have been aborted: "+unique_id_, log::DEBUG);
    }
}

run_ttl: <-- ist die funktion des TTL die via Thread ausgeführt wird.
stop: <-- schließt den Socket
connection_managet_: <-- hält alle Sockets in einem Container

Die ist mal ein ausschnitt von einem Socket. Immer wenn man etwas an den Server schickt, wird der aktuelle boost::thread angehalten und neu gestared, damit bezwecke ich das der TTL von vorne beginnt. Dies passiert in der handle_read - Funktion

Wenn der TTL abgelaufen ist, soll der Socket geschlossen werden und saubet entfernt werden, das bedeutet das ich das über meinen Connection Manager macher da dieser den Socket aus dem Container schmeißt und die stop funktion aufruft.

Das Problem ist, das ich in dem Thread eine Blockierende Methode aufrufe (connection_manager_.stop(shared_from_this());) Das blockiert das Programm und nix geht mehr, was auch logish ist da in der stop - Funktion der Mutex noch garnicht freigegeben ist.

Hat jemand eine Idee wie ich das Problem lösen kann oder eine ist ein thread hier die flasche vorgehensweise? Wichtig ist der TTL muss Non-Blocking sein (ist ja klar)

Oder wie kann ich den Socket aus einem parallelen programmablauf runter fahren? Der thread muss as irgendwie automatisch machen ich kann keine blockierende "while is thread running" schleife einbauen da ich dann den kompletten Socket blockiere.

Dank für eure Hilfe

so long
jd