Многопоточность - в чём смысл std::thread.join()?

#include <iostream>
#include <thread>
#include <mutex>
std::mutex m_console;
void Log(){
    for( int i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << i << std::endl;
    }
}
void Lag(){
    for( char i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << i << std::endl;
    }
}
int main(int argc, char *argv[]){
    std::thread(Log).join();
    std::thread(Lag).join();
    for( int i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << "azaza" << std::endl;
    }
    system("pause");
    return 0;
}

Зависит от того, что именно вам нужно. Например, вы распараллелили какие-то вычисления - и что теперь вам делать? Например, ваши потоки каждый считает какое-то значение, которые потом нужно просуммировать. Как вы это сделаете, отправив их в detach? будете постоянно опрашивать какие-то флаги, которые эти потоки должны выставить? :)

Ваши потоки нужно было вызывать примерно так:

std::thread Lo(Log);
std::thread La(Lag);
for( int i = 0; i < 127; i++){
    std::cout << "azaza" << std::endl;
}
Lo.join();
La.join();

Только учтите, что мьютексы там не нужны, cout и так достаточно умный, и что вы при этих 127 числах просто ничего не увидите - первый поток просвистит, пока второй будет создаваться... Или сделайте их побольше, или добавьте, например, задержку небольшую...

std::thread::join нужен в двух случаях:

1. Ваша программа завершается, вы вот-тот выйдите из main(), и надо корректно завершить работу потоков (уничтожить объекты, закрыть дескрипторы, опустошить кеши и т. д.). Тогда вы сначала как-то уведомляете их о необходимости завершения, а затем вызываете для каждого из них join(). Без этого ожидания стандартная библиотека прибьёт процесс сразу же по выходу из main().

2. Вы единоразово распараллелили вычисления и теперь вам надо дождаться результатов, чтобы собрать их в кучу и продолжить выполнение.

thread.join приостанавливает выполнение текущего потока до тех пор, пока поток, для которого было вызвано join() не завершится.

Обычно потоки применяются для выполнение неблокирующей ресурсо-, время-затратной операции.Оказывается, что намного удобнее не отпускать потоки в свободное плавание, а контролировать их из одного главного потока, приостанавливая его, когда он ожидает значения из дочерних потоков (этот подход рекомендуют большинство источников).

Более того, если мы отпустим поток в свободное плавание через thread.detach() мы не сможем его контролировать и получим кучу сообщений об ошибках и утечку памяти если таких потоков будет много. Поток, для которого был вызван detach не можем быть использован в контексте функции join(). Специфика потоков такова, что они знают, какой поток является родительским для них и только родительский поток в Си и плюсах может вызвать join() и только для своих дочерних потоков.

В заключение: существует поверье, что чем меньше мютексов, тем лучше, они сильно захламляют код и делают его трудно понимаемым. Поэтому не сильно ими увлекайтесь.

В примере вашего кода все выполняется с точностью до наоборот. Вы запускаете новый поток td::thread(Log), который, как и ожидалось, будет выполнять функцию Log. Но при этом вы сразу вызываете join() который приостанавливает текущий поток до тех пор, пока поток, для которого он вызван не окончит свое выполнение. Вы делаете это два раза. И два раза вы останавливаете главный поток программы. В результате будут созданы два потока, но второй создаться и выполнится только после того, как окончится первый, поскольку для него вызван join()

Попробуйте так:

#include <iostream>
#include <thread>
#include <mutex>
std::mutex m_console;
void Log(){
    for( int i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << i << std::endl;
    }
}
void Lag(){
    for( char i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << i << std::endl;
    }
}
int main(int argc, char *argv[]){
    // don't call join
    std::thread one(Log);
    std::thread two(Lag);
    for( int i = 0; i < 127; i++){
        std::lock_guard<std::mutex> lock(m_console);
        std::cout << "azaza" << std::endl;
    }
    // but call there
    one.join();
    two.join();
    system("pause");
    return 0;
}