Многопоточность

#include <string>
#include <vector>
#include <iostream>
#include <queue>
#include <sstream>
#include <fstream>
#include <thread>
#include <mutex>
using namespace std;
 
mutex lockqueue;
mutex lock_td;
 
struct mark
{
    string name;
    string position; //Должность: уровень 1 - директор, уровень 2 - менеджер, уровень 3 - рабочий
    string datebirth;
};
struct TreeNode
{
    vector<TreeNode*> broth;
    vector<TreeNode*> children;
    mark value;
};
class TreeDictionary
{
    TreeNode *root;
public:
    TreeDictionary()
    {
        root =  NULL;
    }
    void insert(mark data){
        if(root == NULL){
            if(data.position == "директор"){
                root  = CreateNode(data);
            } else return;
        } else{
            if(data.position == "директор"){
                insert_broth(root, data);
            } else if(data.position == "менеджер"){
                if(root->broth.size() != 0)
                    insert_child(root->broth.back(), data);
                else
                    insert_child(root, data);
            } else if(data.position == "рядовой рабочий"){
                if(root->broth.size() != 0){
                    if((root->broth.back())->children.size() != 0)
                        insert_child((root->broth.back())->children.back(), data );
                } else{
                    if(root->children.size() != 0){
                        insert_child(root->children.back(), data);
                    }
                }
 
            }
 
        }
    }
    void insert_child(TreeNode * parent, mark n){
        TreeNode *temp = CreateNode(n);
        parent -> children.push_back(temp);
    }
    void insert_broth(TreeNode * broth, mark n){
        TreeNode *temp = CreateNode(n);
        broth -> broth.push_back(temp);
    }
    TreeNode * CreateNode(mark data){
        TreeNode *newNode = new TreeNode;
        newNode->value = data;
        return newNode;
    }
    void traveler(TreeNode * root, ostream &out){
        if(root == NULL)
            return;
        out << root->value.name << ',' << root->value.position << ',' << root->value.datebirth << '\n';
        for (int i = 0; i < root->children.size() && root->children[i]; i++)
            traveler(root->children[i], out);
    }
    void print(ostream& out){
        traveler(root, out);
        for (int i = 0; i < root->broth.size(); i++){
            traveler(root->broth[i],out);
        }
    }
    TreeNode * getroot() const{
        return root;
    }
 
};
void read_data(queue<string>& inputdata, TreeDictionary & tree){
    cout << "start1";
    while(!inputdata.empty()){
        mark man;
        stringstream ss(inputdata.front());
        getline(ss, man.name, ',');
        cout << man.name << endl;
        getline(ss, man.position, ',');
        getline(ss, man.datebirth);
        lockqueue.lock();
        inputdata.pop();
        lockqueue.unlock();
        lock_td.lock();
        tree.insert(man);
        lock_td.unlock();
    }
}
void write_data(string filename, TreeDictionary &tree){
    ofstream output(filename, ios::app);
    if(output.is_open()){
        cout << "start2";
        lock_td.lock();
        tree.print(output);
        lock_td.unlock();
    }
 
}
int main()
{
    queue<string> inputdata;
    TreeDictionary td;
    string infilename = "indata.txt";
    string outfilename = "outdata1.txt";
    auto td_a = ref(td);
    thread t1(read_data, ref(inputdata), td_a);
    thread t2(write_data, outfilename, td_a);
    ifstream input(infilename);
    if(input.is_open()){
        string data;
        while(getline(input, data)){
            lockqueue.lock();
            inputdata.push(data);
            //cout << inputdata.back();
            lockqueue.unlock();
            }
    }
    t1.join();
    t2.join();
    return 0;
}