Boost.Thread mortos-lock e auto-exclusão

Question

Eu estou usando boost::thread_group para criar (usando thread_group::create_thread()) e expedição tópicos. A fim de limite os números de rosca max, no final de cada linha, para remover o segmento do thread_group e excluir o próprio fio (para que eu pudesse decidir se novos tópicos precisam ser criados). No entanto ele trava em algum lugar entre a criação e exclusão da última thread (dizem que o um 999 de 999 no total).

As minhas perguntas são:

• é OK para deletar o histórico da dentro de si mesmo gosto do que faço? E se não, qual é a melhor maneira de conseguir este
• Por que minha trava de código?

A seguir estão o código relacionado:

// 1- código para criar e linha expedição

 { 
        //mutex for map<thread_id, thread*> operations 
        boost::mutex::scoped_lock lk(m_mutex_for_ptr); 

        // create a thread for this->f(duplicate_hashes) 
        boost::thread* p = m_thread_group.create_thread(boost::bind( 
            &detectiveT<equal_predicate>::f, 
            this, 
            duplicate_hashes 
            )); 

        // save the <thread_id,thread pointer> map for later lookup & deletion 
        m_thread_ptrs.insert(make_pair(p->get_id(), p)); 

        // log to console for debug 
        cout << "thread created: " 
            << p->get_id() << ", " 
            << m_thread_group.size() << ", " m_thread_ptrs.size() << 
"\n";     
    }   

// 2 código da execução de thread

void f(list<map_iterator_type>& l) 
{ 
    Do_something(l);    
    boost::this_thread::at_thread_exit(boost::bind( 
        &detectiveT<equal_predicate>::remove_this_thread, 
        this 
        ));                     
} 

// 3 código para excluir o próprio fio

void remove_this_thread() 
{ 

    { 
        //mutex for map<thread_id, thread*> operations 
        boost::mutex::scoped_lock lk(m_mutex_for_ptr);                   
        boost::thread::id this_id(boost::this_thread::get_id()); 

        map<boost::thread::id, boost::thread*>::iterator itr; 

        itr = (m_thread_ptrs.find(this_id)); 

        if(m_thread_ptrs.end() != itr) 
        { 
            // remove it from the control of thread_group 
            m_thread_group.remove_thread(itr->second); 
            // delete it 
            delete itr->second; 

            // remove from the map 
            m_thread_ptrs.erase(this_id); 

            // log to console for debug 
            cout << "thread erased: " 
                << this_id << ", " 
                << m_thread_group.size() << ", " 
                << m_thread_ptrs.size() << "\n";             
        } 
    }               
}

Answer 1

Por que você não tentar reciclar os tópicos, desde a criação / destruição é caro?

tarefas

Código de classe pool de threads e enviar para ele. A piscina será ou fila as tarefas se ele não tem tópicos mais disponíveis, criar tópicos, se current_threads

implementação sugerida:

Saiba o que sua contagem da linha ideal é. Este é geralmente igual ao número de processadores. Dependendo de como complicado você quer que isso seja, você pode criar todas as threads no conjunto de uma vez ou adicionar tópicos se a corrente-thread-count

Assumindo que você está criando todos os seus segmentos de uma vez, você precisa passar uma função de trabalho para cada um dos tópicos para executar. Esta função trabalhador vai esperar para tarefas para se tornar disponível e, em seguida, executá-los. Porque a função seja executa uma tarefa ou espera para ele, ele não vai voltar e o segmento não será destruído .

O pool de threads pode manter o controle de uma fila de tarefas e gerenciar uma condição de espera que indica quando há tarefas disponíveis na fila. Cada função do trabalhador thread aguarda na condição de espera e quando há uma tarefa disponível, ela acorda e tenta fazer a tarefa. Você vai ter que fazer alguma sincronização; a maneira mais fácil seria para tentar encontrar uma implementação pool de threads disponíveis, como a do Windows (Vista + eu acho) ou o de QtConcurrent que lhe permitiria apenas passar a tarefa, run chamada e deixar o OS / preocupação biblioteca sobre tudo.

Editar Depois:

Confira http://threadpool.sourceforge.net/