c++ - lock - ¿Qué hace std:: thread.join()?

mutex coin

Question

Por definición de referencia a C ++ :

Bloquea el hilo actual hasta que el hilo identificado por *this termine su ejecución.

Entonces, ¿esto significa que cuando se usa .join() , no hay necesidad de mutex.lock() cuando ese hilo llama a alguna función? Soy nuevo en la exclusión mutua y los hilos, así que estoy un poco confundido.

Nota: Encontré un libro C ++ Concurrencia en Acción y estoy leyendo el libro. Está muy bien escrito para un principiante en multiproceso como yo.

Gracias a todos por la ayuda.

Answer 1

Bloquea el hilo actual hasta que se completa la ejecución del hilo en el que se llama join ().

Si no especifica join () o dettach () en el subproceso, se producirá un error de tiempo de ejecución, ya que el subproceso principal / actual completará su ejecución y el otro subproceso creado seguirá ejecutándose.

Answer 2

Todavía necesita mutexes y condiciones. Unir un hilo hace que un hilo de ejecución espere a que otro hilo termine de ejecutarse. Aún necesita mutexes para proteger los recursos compartidos. Permite que main () en este ejemplo espere a que todos los hilos terminen antes de cerrarse.

#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>

using namespace std;



int global_counter = 0;
std::mutex counter_mutex;

void five_thread_fn(){
    for(int i = 0; i<5; i++){
        counter_mutex.lock();
        global_counter++;
        counter_mutex.unlock();
        std::cout << "Updated from five_thread"  << endl;
        std::this_thread::sleep_for(std::chrono::seconds(5));
    }
    //When this thread finishes we wait for it to join
}

void ten_thread_fn(){
    for(int i = 0; i<10; i++){
        counter_mutex.lock();
        global_counter++;
        counter_mutex.unlock();
        std::cout << "Updated from ten_thread"  << endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    //When this thread finishes we wait for it to join
}
int main(int argc, char *argv[]) {
    std::cout << "starting thread ten..." << std::endl;
    std::thread ten_thread(ten_thread_fn);

    std::cout << "Running ten thread" << endl;
    std::thread five_thread(five_thread_fn);


    ten_thread.join();
    std::cout << "Ten Thread is done." << std::endl;
    five_thread.join();
    std::cout << "Five Thread is done." << std::endl;
}

Tenga en cuenta que la salida podría verse así:

starting thread ten...
Running ten thread
Updated frUopmd atteend_ tfhrroema df
ive_thread
Updated from ten_thread
Updated from ten_thread
Updated from ten_thread
Updated from ten_thread
Updated from five_thread
Updated from ten_thread
Updated from ten_thread
Updated from ten_thread
Updated from ten_thread
Updated from ten_thread
Updated from five_thread
Ten Thread is done.
Updated from five_thread
Updated from five_thread
Five Thread is done.

Dado que std :: cout es un acceso compartido a los recursos, su uso también debe estar protegido por mutex.

Answer 3

join () detiene el hilo actual hasta que termina otro. mutex detiene el hilo actual hasta que el propietario de mutex lo libere o se bloquee de inmediato si no está bloqueado. Así que estos chicos son bastante diferentes

Answer 4

std :: thread.join tiene tres funciones que se me ocurren de la mano y algunas otras:

a) Alienta la creación / terminación / destrucción continua de subprocesos, por lo que el rendimiento de martilleo y el aumento de la probabilidad de fugas, desbordamiento de subprocesos, pérdida de control de memoria y la pérdida general de control de su aplicación.

b) Rellena los controladores de eventos de la GUI mediante la ejecución de esperas no deseadas, lo que resulta en "aplicaciones de reloj de arena" que no responden y que tus clientes odiarán.

c) Hace que las aplicaciones no puedan cerrarse porque están esperando la terminación de un subproceso ininterrumpido y no resuelto.

d) Otras cosas malas.

Entiendo que eres nuevo en el multihilo y te deseo lo mejor. Además, ten en cuenta que he tenido muchos Adnams Broadside esta noche, pero:

Join (), y sus amigos en otros idiomas como TThread.WaitFor, (Delphi), son un subprocesamiento múltiple eficiente, como Windows ME fue para los sistemas operativos.

Intente esforzarse para progresar y comprender otros conceptos de multiproceso: grupos, tareas, subprocesos de toda la vida de la aplicación, comunicaciones entre subprocesos a través de las colas productor-consumidor. De hecho, casi cualquier cosa, excepto unirse ().