How to use std::thread().detach() with Emscripten?

[Fevola]

I am learning multithreading with Emscripten and using the following compilation flags:

-JSPI=1
-pthread
-sPTHREAD_POOL_SIZE=5
-sOFFSCREENCANVAS_SUPPORT=1
-sOFFSCREENCANVASES_TO_PTHREAD=#canvas

I encountered an issue when compiling the following code:

void Test(int id)
{
    emscripten_run_script(("console.log('[work " + std::to_string(id) + "] Start');").c_str());
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}

void TestThread()
{
    std::thread t1([this](){ Test(1); });
    std::thread t2([this](){ Test(2); });
    std::thread t3([this](){ Test(3); });
    std::thread t4([this](){ Test(4); });
    std::thread t5([this](){ Test(5); });

    t1.join();
    t2.join();
    t3.join();
    t4.join();
    t5.join();

    std::this_thread::sleep_for(std::chrono::milliseconds(5000));

    std::thread t6([this](){ Test(6); });
    std::thread t7([this](){ Test(7); });
    std::thread t8([this](){ Test(8); });
    std::thread t9([this](){ Test(9); });
    std::thread t10([this](){ Test(10); });

    t6.join();
    t7.join();
    t8.join();
    t9.join();
    t10.join();

    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    emscripten_run_script("console.log('TestThread End');");
}

When using join(), the program behaves as expected: it prints [work 1/2/3/4/5] Start, waits for a while, then prints [work 16/7/8/9/10] Start and TestThread End. However, when I replace join() with detach(), the program prints [work 1/2/3/4/5] Start, waits for a while, prints TestThread End, and then no further output is shown. It seems that threads 6, 7, 8, 9, and 10 are not executing properly. Do I need to handle thread cleanup manually or adjust any compilation settings when using detach? Any help would be greatly appreciated!

the version of Emscripten is 4.0.10.

[sbc100]

I'm having trouble reproducing, at least using node.

Here is my complete program based on your code above:

#include <thread>                                                                    
#include <emscripten/emscripten.h>                                                   
#include <emscripten/console.h>                                                      
                                                                                     
void Test(int id)                                                                    
{                                                                                    
    emscripten_dbgf("[work %d] Start", id);                                          
    std::this_thread::sleep_for(std::chrono::milliseconds(100));                     
}                                                                                    
                                                                                     
int main()                                                                           
{                                                                                    
    std::thread t1([](){ Test(1); });                                                
    std::thread t2([](){ Test(2); });                                                
    std::thread t3([](){ Test(3); });                                                
    std::thread t4([](){ Test(4); });                                                
    std::thread t5([](){ Test(5); });                                                
                                                                                     
    t1.detach();                                                                     
    t2.detach();                                                                     
    t3.detach();                                                                     
    t4.detach();                                                                     
    t5.detach();                                                                     
                                                                                     
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));                    
                                                                                     
    std::thread t6([](){ Test(6); });                                                
    std::thread t7([](){ Test(7); });                                                
    std::thread t8([](){ Test(8); });                                                
    std::thread t9([](){ Test(9); });                                                
    std::thread t10([](){ Test(10); });                                              
                                                                                     
    t6.detach();                                                                     
    t7.detach();                                                                     
    t8.detach();                                                                     
    t9.detach();                                                                     
    t10.detach();                                                                    
                                                                                     
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));                    
    emscripten_dbg("TestThread End");                                                
}                                                                                    

Here is it running under node:

$ ./emcc test.cc -pthread -sPTHREAD_POOL_SIZE=5 
$ node ./a.out.js
w:1,t:0x00054d10: [work 5] Start
w:4,t:0x00023180: [work 2] Start
w:2,t:0x000443e0: [work 4] Start
w:3,t:0x00033ab0: [work 3] Start
w:5,t:0x00012850: [work 1] Start
w:7,t:0x00075260: [work 7] Start
w:6,t:0x00064fb8: [work 6] Start
w:9,t:0x000957b0: [work 9] Start
w:8,t:0x00085508: [work 8] Start
w:10,t:0x000a5a58: [work 10] Start
w:0,t:0x00011640: TestThread End

[Fevola]

Thank you for your response! I tried again and found that the issue may have been caused by calling the TestThread function multiple times like this:

int main()                                                                           
{                                                                                    
    for (int i = 0; i < 5; i++) {
        std::thread t1([]() { Test(1); });
        std::thread t2([]() { Test(2); });
        std::thread t3([]() { Test(3); });
        std::thread t4([]() { Test(4); });
        std::thread t5([]() { Test(5); });
    
        t1.detach();
        t2.detach();
        t3.detach();
        t4.detach();
        t5.detach();
    
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    
        std::thread t6([]() { Test(6); });
        std::thread t7([]() { Test(7); });
        std::thread t8([]() { Test(8); });
        std::thread t9([]() { Test(9); });
        std::thread t10([]() { Test(10); });
    
        t6.detach();
        t7.detach();
        t8.detach();
        t9.detach();
        t10.detach();
    
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        emscripten_run_script("console.log('TestThread end');");
    }
}

After threads 1, 2, 3, 4, and 5 print their results, "TestThread end" will be printed five times , and the execution of the remaining threads 6, 7, 8, 9, and 10, along with the rest of the threads. the output will be: 12345-TestThread end-TestThread end-TestThread end-TestThread end-TestThread end-678910-12345....

At the same time, I noticed a phenomenon: This problem only occurs the first time it's triggered. I bound TestThread to a button using embind. When clicking the button the second time, the output works as expected: 12345-678910-TestThread end-12345-678910-TestThread end....

[sbc100]

Can you reproduce under node?