Написать программу с двумя потоками

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <functional>
#include <fstream>
#include <cmath>
 
using namespace std;
mutex mtx;
 
void writePrimesToFile(unsigned int begin, unsigned int end)
{
 for (unsigned int i = begin; i <= end; i++)
 {
  for (unsigned int j = 2; j < i; j++)
  {
   if (i % j == 0)
   {
    break;
   }
   else if (j + 1 == i)
   {
    mtx.lock();
    cout << i << endl;
    mtx.unlock();
   }
  }
 }
}
 
void callWritePrimesMultipleThreads(unsigned int begin, unsigned int end, unsigned int N)
{
 clock_t startTimer, stopTimer;
 
 startTimer = clock();
 
 vector<thread> arr;
 unsigned int each = end / N;
 unsigned int start = begin;
 unsigned int finish = start + each - 1;
 for (unsigned int i = 0; i < N; i++)
 {
  arr.emplace_back(writePrimesToFile, start, finish);
  start += each;
  finish += each;
 }
 for (auto& thread : arr)
 {
  thread.join();
 }
 
 stopTimer = clock();
 cout << "The time that takes is: " << (double)(stopTimer - startTimer) / CLOCKS_PER_SEC << endl;
}
 
 
int main()
{
 callWritePrimesMultipleThreads(1, 1000, 100);
 cin.get();
 return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
 
 
std::mutex mtx1, mtx2;
std::condition_variable cv1, cv2;
int pn;
std::atomic<bool> cont = true, printReady = false;
 
// возвращает true если n - простое
bool prime(int const n) 
{
    bool ret = true;
    for (int i = 2; i * i <= n; ++i)
    {
        if (n % i == 0)
        {
            ret = false;
            break;
        }
    }
    return (n == 1 ? false : ret);
}
 
// ищет все простые в интервале от beg до end
void search(int const beg, int const end)
{
    while (!printReady)
    {
        std::this_thread::yield();
    }
    for (int i = beg; i <= end; ++i)
    {
        if (prime(i))
        {
            while(!mtx2.try_lock())
            {
                std::this_thread::yield();
            }
            mtx2.unlock();
            pn = i;
            std::unique_lock<std::mutex> lck(mtx1);
            cv2.notify_one();
            cv1.wait(lck);
        }
    }
}
 
void print()
{
    while (cont)
    {
        std::unique_lock<std::mutex> lck(mtx2);
        if (cont && pn != 0)
        {
            std::cout << pn << "  ";
        }
        printReady = true;
        cv1.notify_one();
        cv2.wait(lck);
    }
}
 
 
int main()
{
    std::thread ts(search, 2, 10000);
    std::thread tp(print);
    ts.join();
    cont = false;
    cv2.notify_one();
    tp.join();
}