Multi-threaded copying files using queue - c++

Question

The task:
I have many (500) .txt files. Each file contains other filenames. I have a filename to begin with. I need to copy that file and all files mentioned in it, and so on, to a subdirectory copy/. The solution must be multi-threaded.
I wrote the following code, but it executes a bit faster with one thread than with two. What's my mistake and how can I change this?
#include <iostream>
#include <fstream>
#include <string>
#include <queue>
#include <set>
#include <cassert>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <thread>
template <typename T>
class UQueue {
private:
std::queue<T> m_queue;
std::set<T> m_set;
public:
bool push(const T& t) {
if (m_set.insert(t).second) {
m_queue.push(t);
return true;
}
return false;
}
void pop() {
assert(!m_queue.empty());
m_queue.pop();
}
const T& front() const {
return m_queue.front();
}
bool empty(){
return m_queue.empty();
}
int size_of_set(){
return m_set.size();
}
};
template <class T>
class SafeQueue {
public:
SafeQueue(void)
: q()
, m()
, c()
{}
~SafeQueue(void) {}
void enqueue(T t) {
std::lock_guard<std::mutex> lock(m);
q.push(t);
c.notify_one();
}
T dequeue(void) {
std::unique_lock<std::mutex> lock(m);
while(q.empty()) {
c.wait(lock);
}
T val = q.front();
q.pop();
return val;
}
int size_of_set() {
return q.size_of_set();
}
bool empty() {
return q.empty();
}
private:
UQueue<T> q;
mutable std::mutex m;
std::condition_variable c;
};
void copyFile(std::string fromFile, std::string toFile){
std::ifstream src(fromFile, std::ios::binary);
std::ofstream dst(toFile, std::ios::binary);
dst << src.rdbuf();
}
std::set<std::string> extract( std::string file_name ) {
std::ifstream file(file_name) ;
std::string line;
std::set<std::string> temp;
while (!file.eof()){
file >> line;
temp.insert(line);
}
return temp;
}
class Crawler{
public:
void init();
void work();
void thread_init();
int processed(){return q.size_of_set();};
Crawler(std::string start, int thr);
std::string target(){return m_conf.m_targetDir;};
private:
struct Config{
int m_threads;
std::string m_startFile = "1.txt";
std::string m_targetDir = "copy";
};
Config m_conf;
SafeQueue<std::string> q;
};
void Crawler::init(){
q.enqueue(m_conf.m_startFile);
}
Crawler::Crawler(std::string start, int thr){
m_conf.m_startFile = start;
m_conf.m_threads = thr;
}
void Crawler::work(){
std::string path;
std::set<std::string> tempSet;
while (!q.empty()){
path = q.dequeue();
copyFile(path, this->target() + "/" + path);
tempSet = extract(path);
for (auto f : tempSet){
q.enqueue(f);
}
}
}
void Crawler::thread_init(){
std::vector<std::thread> workers;
for (int i = 0; i < m_conf.m_threads; ++i){
workers.push_back(std::thread(&Crawler::work, this));
}
for (auto& thr : workers){
thr.join();
}
}
int main(){
Crawler c("1.txt", 2);
auto start = std::chrono::high_resolution_clock::now();
c.init();
c.thread_init();
auto end = std::chrono::high_resolution_clock::now();
std::cout << c.processed()<<
" " << std::chrono::duration<double, std::milli>(end - start).count() << " ms\n";
}