多线程变慢

#ifndef __SYNC_QUEUE_HPP__
#define __SYNC_QUEUE_HPP__

#include <queue>
#include <string>
#include <boost/shared_ptr.hpp>
#include <chrono>
#include <ctime>

using namespace std;
using boost::shared_ptr;

typedef struct ImgFeatureElement
{
    std::string m_imgPath;
    std::vector<float> m_imgFeature;
    std::string m_id;
    int m_errCode;
}ImgFeatureElement;

class ElapsedTime
{
    public:
    ElapsedTime(std::string func, int th);
    ~ElapsedTime();
    double GetElapsedTime();
    private:
        std::chrono::time_point<std::chrono::system_clock> start;
        std::chrono::time_point<std::chrono::system_clock> end;
        int thread_id;
        std::string m_func;
};

template<typename T>
class SyncQueue {
 public:
  explicit SyncQueue();

  void push(const T& t);

  T pop();

  size_t size() const;

 protected:
  class sync;
  std::queue<T> queue_;
  boost::shared_ptr<sync> sync_;

};

#endif

##########################################################################

#include <boost/thread.hpp>
#include "sync_queue.hpp"

ElapsedTime::ElapsedTime(std::string func, int th):m_func(func),thread_id(th)
{   
    start = std::chrono::system_clock::now();
}   

ElapsedTime::~ElapsedTime()
{   
    end = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
    std::cout << "finished  at " << std::ctime(&end_time) << std::endl;
    std::cout << m_func << thread_id <<"\033[33m melapsed time: " << elapsed_seconds.count() << "s\033[0m\n";
}

double ElapsedTime::GetElapsedTime()
{
    end = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    return elapsed_seconds.count();
}

template<typename T>
class SyncQueue<T>::sync {
 public:
  mutable boost::mutex mutex_;
  boost::condition_variable condition_push;  
  boost::condition_variable condition_pop;
};

template<typename T>
SyncQueue<T>::SyncQueue()
    : sync_(new sync()) {
}

template<typename T>
void SyncQueue<T>::push(const T& t) {
  boost::mutex::scoped_lock lock(sync_->mutex_);

  while (!queue_.empty()) {
    sync_->condition_push.wait(lock);
  }
  queue_.push(t);
  sync_->condition_pop.notify_one();  
  lock.unlock();

}

template<typename T>
T SyncQueue<T>::pop() {
  boost::mutex::scoped_lock lock(sync_->mutex_);

  while (queue_.empty()) {
    sync_->condition_pop.wait(lock);
  }

  T t = queue_.front();
  queue_.pop();
  sync_->condition_push.notify_one();
  return t;
}

template<typename T>
size_t SyncQueue<T>::size() const {
  boost::mutex::scoped_lock lock(sync_->mutex_);
  return queue_.size();
}

template class SyncQueue<ImgFeatureElement>;

template class SyncQueue<int>;

################################################################################

#include <iostream>
#include <thread>
#include "sync_queue.hpp"

class DeamonThread
{
    public:
        DeamonThread(){}
        ~DeamonThread(){}
        int deal_event()
        {   
            for (int i = 0; i < 1000; ++i)
            {   
                std::cout<<"      "<<i;
            }   
            std::cout<<std::endl;
        }   
        void forward(int& vecIdx)
        {   
            m_inQueue.push(1);
            deal_event();
            m_inQueue.pop();
        }   
    private:
        SyncQueue<int> m_inQueue;

};

class ThreadPool
{
    public:
       ThreadPool(int vecSize):m_dt(vecSize)
        {   
            int vecIdx = 0;
            for (vecIdx = 0; vecIdx < vecSize; ++vecIdx)
            {   
                m_dt[vecIdx] = new DeamonThread;
            }   
        }   
       ~ThreadPool()
        {   
            int vecIdx = 0;
            for(;vecIdx < m_dt.size(); ++vecIdx)
            {   
                delete m_dt[vecIdx];
            }   
        }   
       DeamonThread* sche(DeamonThread*& dt, int& arrIdx)
       {   
            arrIdx = vecCount % m_dt.size();
            dt = m_dt[arrIdx];
            ++vecCount;
            return dt;
       }   
        void forward(int& vecIdx)
        {
            DeamonThread* dt = NULL;
            sche(dt, vecIdx);
            dt->forward(vecIdx);
        }
    private:
        std::vector<DeamonThread*> m_dt;
        int vecCount;
};
void main_blockqueue_thread(ThreadPool& d, double& time)
{
    int vecIdx = 0;
    ElapsedTime et(__FUNCTION__,__LINE__);
    d.forward(vecIdx);
    time = et.GetElapsedTime();
    return ;
}

double calcAllTime(double* thtime, int th_user)
{
    double alltime = 0;

    for (int i = 0; i < th_user; ++i)
    {
        if (0==(i % 10))
        {
            std::cout <<std::endl;
        }
            std::cout<<"["<< i <<":"<< thtime[i] << "]\t";

        alltime = alltime + thtime[i];
    }
    std::cout<<std::endl<<"alltime:"<<alltime<<std::endl;
    return 0;
}

int main(int argc, char** argv)
{
    int vecSize = 0;
    std::cout<<"vecSize:"<<std::endl;
    std::cin>>vecSize;
    ThreadPool d(vecSize);
    int user = 10;
    double Etime[user] {0};
    std::thread* threads[user] = {0};
    for (int uidx = 0; uidx < user; ++uidx)
    {
        threads[uidx] = new std::thread(main_blockqueue_thread,std::ref(d),std::ref(Etime[uidx]));
    }

    for (int uidx = 0; uidx < user; ++uidx)
    {
        threads[uidx]->join();
    }

    calcAllTime(Etime, sizeof(Etime)/sizeof(Etime[0]));
    return 0;
}
                                                               

###################################################################

exec=exec
platform=linux

csrcs=$(wildcard *.c)
cobjs=$(patsubst %.c,out/$(platform)/%.o,$(csrcs))

cppsrcs=$(wildcard *.cpp)
cppobjs=$(patsubst %.cpp,out/$(platform)/%.o,$(cppsrcs))

CC= gcc
CXX= g++  -Wl,--no-as-needed
RM= rm  

BOOST_DIR=/usr/local/boost
BOOST_INC=-I$(BOOST_DIR)/include
BOOST_LIB_DIR=-L$(BOOST_DIR)/lib
BOOST_LIBS=-lboost_atomic
BOOST_LIBS+=-lboost_chrono
BOOST_LIBS+=-lboost_context
BOOST_LIBS+=-lboost_date_time
BOOST_LIBS+=-lboost_exception
BOOST_LIBS+=-lboost_filesystem
BOOST_LIBS+=-lboost_graph
BOOST_LIBS+=-lboost_iostreams
BOOST_LIBS+=-lboost_locale
BOOST_LIBS+=-lboost_math_c99
BOOST_LIBS+=-lboost_math_c99f
BOOST_LIBS+=-lboost_math_c99l
BOOST_LIBS+=-lboost_math_tr1
BOOST_LIBS+=-lboost_math_tr1f
BOOST_LIBS+=-lboost_math_tr1l
BOOST_LIBS+=-lboost_prg_exec_monitor
BOOST_LIBS+=-lboost_program_options
BOOST_LIBS+=-lboost_python
BOOST_LIBS+=-lboost_random
BOOST_LIBS+=-lboost_regex
BOOST_LIBS+=-lboost_serialization
BOOST_LIBS+=-lboost_signals
BOOST_LIBS+=-lboost_system
BOOST_LIBS+=-lboost_test_exec_monitor
BOOST_LIBS+=-lboost_thread
BOOST_LIBS+=-lboost_timer
BOOST_LIBS+=-lboost_unit_test_framework
BOOST_LIBS+=-lboost_wave

BOOST_LIBS+=-lboost_wserialization

BOOST_LIB_SO=-lboost_atomic
BOOST_LIB_SO+=-lboost_chrono
BOOST_LIB_SO+=-lboost_context
BOOST_LIB_SO+=-lboost_date_time
BOOST_LIB_SO+=-lboost_filesystem
BOOST_LIB_SO+=-lboost_graph
BOOST_LIB_SO+=-lboost_iostreams
BOOST_LIB_SO+=-lboost_locale
BOOST_LIB_SO+=-lboost_math_c99f
BOOST_LIB_SO+=-lboost_math_c99l
BOOST_LIB_SO+=-lboost_math_c99
BOOST_LIB_SO+=-lboost_math_tr1f
BOOST_LIB_SO+=-lboost_math_tr1l
BOOST_LIB_SO+=-lboost_math_tr1
BOOST_LIB_SO+=-lboost_prg_exec_monitor
BOOST_LIB_SO+=-lboost_program_options
BOOST_LIB_SO+=-lboost_python
BOOST_LIB_SO+=-lboost_random
BOOST_LIB_SO+=-lboost_regex
BOOST_LIB_SO+=-lboost_serialization
BOOST_LIB_SO+=-lboost_signals
BOOST_LIB_SO+=-lboost_system
BOOST_LIB_SO+=-lboost_thread
BOOST_LIB_SO+=-lboost_timer
BOOST_LIB_SO+=-lboost_unit_test_framework
BOOST_LIB_SO+=-lboost_wave
BOOST_LIB_SO+=-lboost_wserialization
all:out $(cppobjs)
        $(CXX) -o $(exec) $(cppobjs) $(BOOST_INC) $(BOOST_LIB_DIR) $(BOOST_LIBS) $(BOOST_LIB_SO) \
        $(OPENCV_LIB_DIR) $(OPENCV_LIBS) $(OPENCV_LIB_SO) \
        $(OPENCV_INC) $(BOOST_LIB_DIR) $(BOOST_LIBS) $(BOOST_LIB_SO) -lpython2.7 -lpthread
        #$(CC) -o $(exec) $(cobjs)

out/$(platform)/%.o:%.c
        $(CC) -o $@ -c $<

out/$(platform)/%.o:%.cpp
        $(CXX) -o $@ -c $< $(BOOST_INC) $(BOOST_LIB_DIR) $(BOOST_LIBS) $(BOOST_LIB_SO) \
        -DUSE_OPENCV -lpython2.7 -std=c++11

out:
        mkdir -p out/$(platform)/src

clean:
        $(RM) $(objs) out -rf