Help c ++ threads Pause and Resume

With all due respect, your code is chaotic. An example:

int numeroint = 4;
int porcentajetotal = 100 / numeroint; // ¿Por qué no poner directamente 25?
porcentajeA = porcentajetotal;
porcentajeB = porcentajetotal;
porcentajeA = porcentajeB; // ¿Por qué esta asignación?

And another one:

cout <<"\nPorcentaje de realización del Hilo B : " <<porcentajeA<<"% \n"; // ¿No debería ser B?
porcentajeA =porcentajeA + porcentajeTempDos; // ¿No debería ser B?
cout<<"fin del hilo B\n";

If you have not received more answers at this point it is because your code is complicated to read and follow. It needs a deep refactoring to be minimally readable. I give you some tips:

Global variables

The first problem that your program has is the abusive use of global variables. The variables must have the shortest possible life ... and declaring by default the variables as global can give you many problems ... especially if you work with threads (basically because the same variable can be modified by two different threads if you do not realize) . The global variables should cease to exist in your program (at most it would leave mu , cv and ready .) Are you able to know what value is, for example, j in each moment? there are more elegant and secure ways to share information between threads.

Function prime ()

On the other hand, prime() should return a boolean, since it can only return two possible results: 1 (it's a prime) and 0 (it's not a prime):

bool prime(long int pr) {
  long int j = static_cast<long int>(sqrt(pr));
  for (long int i = 2; i <= j; i++) {
    if (pr % i == 0)
      return false;
  }
  return true;
}

This allows you to simplify the code and move from, for example, this:

flag = prime(i);
if (flag == 1 && i != p && i != q)

To this:

if (prime(i) && i != p && i != q)

Threads with parameters

The thread class allows you to send values to threads through parameters ... you can use this feature to share variables:

void ThreadB_Activity(int porcentaje);

std::thread ThreadB(ThreadB_Activity,porcentajeA);

You could even pass references to share values:

void ThreadB_Activity(int& porcentaje);

std::thread ThreadB(ThreadB_Activity,std::ref(porcentajeA));

Conversions

To make conversions it is preferable to use the C ++ ones. They are safer and easier to locate in code:

Change this:

srand((unsigned int) time((time_t *) NULL));

Because of this:

srand(static_cast<unsigned_int>(time(NULL)));    // C++99
srand(static_cast<unsigned_int>(time(nullptr))); // C++11 (Recomendado)

Data types

long int is equivalent to long , shorter and readable.

If a division involves, for example, a double with a int the result will always be double : double x = static_cast<double>(rand) / INT_MAX;

If the calculations are generally with strictly positive numbers, it would be better to use unsigned long or unsigned long long a long int .

For arrays it is preferable to use std::array<long,100> m to long m[100] . std::array has many features that a raw array does not and the performance penalty tends to zero.

Return values

If a function had to return two or more values you can use std::pair or std::tuple (the latter if you compile with C ++ 11 or later). It is always better than using global variables. You can store your individual elements in independent variables using the function std::tie . As always, this is preferable to using global variables:

std::pair<int,char> func()
{
  return std::make_pair(10,'f');
}

int main()
{
  int numero;
  char c;

  std::tie(numero,c) = func();
  std::cout << numero << ' ' << c << '\n';
}

Thread lock

And well, as regards the issue of the threads ... the waits you are commenting on are already being implemented:

Block until another thread notifies:

std::unique_lock<std::mutex> lk(mu);
cv.wait(lk, []{return ready;});

Notification of a thread:

std::lock_guard<std::mutex> lk(mu);
ready = true;
cv.notify_one(); // notificamos que el valor de 'ready' ha cambiado

By the way, the block could leave it like this:

std::unique_lock<std::mutex> lk(mu);
cv.wait(lk);

And then it would no longer be necessary to use ready . The thread would wait for someone to call cv.notify_one() or cv.notify_all() . In your case it does not make sense to use ready since whenever you call cv.notify_one() you are modifying true the value of ready . This block is designed for those cases in which the notification does not need to be paired with the change of the variable (for example if the value of ready depends on an external process).

If it does not work at any point in the code it is preferable to focus the question only at that point ... if what you expect is that someone debug the entire program for you perhaps you should consider offering a payment for these services.

In the following code you have two threads working alternately, in that example protecting a shared resource. More examples and that you can find in my article on condition_variable

std::mutex alternateThreadsMutex;
std::condition_variable runThread1condition;
std::atomic<bool> runThread1 = false;
std::atomic<bool> runThread2 = false;
std::condition_variable runThread2condition;
std::vector<int> threadWork;

void thread1()
{
    while (true)
    {
        std::unique_lock<std::mutex> lock(alternateThreadsMutex);
        runThread1condition.wait(lock, []() { return runThread1.load(); });
        auto workSize = threadWork.size();
        if (workSize < 1000)
            threadWork.push_back(1);

        runThread1 = false;
        runThread2 = true;
        lock.unlock();

        runThread2condition.notify_one();
        if (++workSize >= 1000)
        {
            break;
        }
    }
}

void thread2()
{
    while (true)
    {
        std::unique_lock<std::mutex> lock(alternateThreadsMutex);
        runThread2condition.wait(lock, []() { return runThread2.load(); });
        auto workSize = threadWork.size();
        if (workSize < 1000)
            threadWork.push_back(1);

        runThread2 = false;
        runThread1 = true;
        lock.unlock();
        runThread1condition.notify_one();
        if (++workSize >= 1000)
        {
            break;
        }
    }
}


void alternateThreads()
{
    std::thread t1(thread1);
    std::thread t2(thread2);

    runThread2 = true;
    runThread2condition.notify_one();

    t1.join();
    t2.join();

    cout << threadWork.size() << el;
}

From what you tell me, I can tell you that you use Sleep(); but in reality you would be pausing it for a while in milliseconds, now if you want to do it as if it were a boolean because you say you want to do it when an event happens what I see, then you should use the threads creator of the standard library of <windows.h>

Example:

#include <iostream>
#include <windows.h>

using namespace std;

HANDLE tha; // nuevo handle para el thread

DWORD WINAPI threada(LPVOID arg)
{
    cout << "Me ejecuto sin problemas!" << endl;
    SuspendThread(tha); // auto suspencion
    cout << "Continua la ejecucion de tha!" << endl;
    return 0;
}



int main()
{

    tha = CreateThread(NULL,0,threada,NULL,0,NULL);

    Sleep(10000); // thread principal main(); durmiendo por 10 segundos!

    ResumeThread(tha); // continua tha! - se levanta la suspensión


    system("pause");
    return 0;
}

P.S: Sleep(); is just an example, you can call the function ResumeThread(); before any event you want.