#include <iostream>
#include <thread>
#include <string>
#include <vector>
#include <fstream>
#include <mutex>
#include <condition_variable>

std::fstream file("file.txt", std::ios::out | std::ios::app);

/*
 * readers_count >= 0  | multiple threads can read
 * readers_count == -1 | one thread can write
 */
int readers_count = 0;
std::mutex mtx;

std::condition_variable can_write;
std::condition_variable can_read;

void read(int x)
{
    std::unique_lock<std::mutex> lock(mtx);

    while (! readers_count >= 0) can_read.wait(lock);

    ++readers_count;
    for (int i = 0; i < x; ++i)
    {
        std::string tmp;
        if (! std::getline(file, tmp))
            break;

        std::cout << "read 1 line from file" << std::endl;
    }

    if (--readers_count == 0)
    {
        can_write.notify_one();
    }
}

void write(int x)
{
    std::unique_lock<std::mutex> lock(mtx);

    while (! readers_count == 0) can_write.wait(lock);

    readers_count = -1;

    for (int i = 0; i < x; ++i)
    {
        std::cout << "wrote 1 line to file" << std::endl;
        file << std::this_thread::get_id() << " some data" << std::endl;
    }

    readers_count = 0;
    lock.unlock();

    can_read.notify_one();
    can_write.notify_one();
}

int main()
{
    std::vector<std::thread> readers;
    std::vector<std::thread> writers;

    for (int i = 0; i < 5; ++i)
    {
        readers.push_back(std::thread(read, 3));
        writers.push_back(std::thread(write, 3));
    }

    for (auto& t : readers) t.join();
    for (auto& t : writers) t.join();
}