【C++】 多线程_c#线程执行完之后会释放吗

1 创建线程

std::thread类中的成员函数：

#include <thread>
int mfunction(const char *name, bool flag)
{
    int i = 0;
    while (i < 5)
    {
        std::cout << __func__ << ":" << name << " @thread " << this_thread::get_id() << endl;
        Sleep(1000);
        i++;
    }

    return flag;
}

int main(int, char **)
{
    std::cout << "======boot======" << endl;
    std::cout << "i am main thread:" << this_thread::get_id() << endl;

    thread *th1 = new thread(mfunction, "zhuangjuan", true); //创建线程，并立刻执行传入的函数.

    if (th1->joinable())
        th1->join(); //阻塞当前线程,直到th1线程执行完毕
    std::cout << "======over======" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

注意事项

• 线程实在thread对象被定义的时候开始执行的，而不是在调用join函数时才执行的，调用join函数只是阻塞等待线程结束并回收资源。
• 分离的线程（执行过detach的线程）会在调用它的线程结束或者自己结束时释放资源。
• 线程会在函数允许完毕后自动释放，不推荐利用其他方法强制结束线程，可能会因资源未释放而导致内存泄漏。
• 没有执行join或detach的线程在程序结束时会引发异常。

2 std::async

std::async定义在future头文件中。

thread可以快速、方便的创建线程，但在async面前，就是小巫见大巫了。async可以根据情况选择同步执行或创建新线程来异步执行，当然也可以手动选择。对于async的返回值操作也比thread更加方便。

int mfunction(const char *name, bool flag)
{
    int i = 0;
    while (i < 5)
    {
        std::cout << __func__ << ":" << name << " @thread " << this_thread::get_id() << endl;
        Sleep(1000);
        i++;
    }

    return flag;
}

void yfunction(const char *name)
{
    int i = 0;
    while (i < 5)
    {
        std::cout << __func__ << ":" << name << " @thread " << this_thread::get_id() << endl;
        Sleep(1000);
        i++;
    }
}

int main(int, char **)
{
    std::cout << "========boot=======" << endl;

    //第一个参数表示执行方法的类型
    //第二个参数表示方法名
    //后面是调用方法的参数
    //并且由future类型参数接收返回值
    std::future<int> fu = std::async(std::launch::async, mfunction, "hello world!!!", true);
    int ret = fu.get();//该方法阻塞直到异步方法执行完,并且返回异步方法的返回值
    std::cout << "ret:" << ret << endl;
    
    //该异步方法返回值类型为void
    std::future<void> fut = std::async(std::launch::async, yfunction, "hello world!!!");
    fut.wait();//调用wait方法阻塞知道异步方法执行完.
    std::cout << "========over=======" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

注意，如果需要执行的方法是一个成员函数，或者需要执行的方法中有引用参数，那么处理方法和thread是一样的。thread的处理方法见：stdref和stdcref_目标：MVP-CSDN博客

typedef struct
{
    int mfunction(const char *name, bool flag)
    {
        int i = 0;
        while (i < 5)
        {
            std::cout << __func__ << ":" << name << " @thread " << this_thread::get_id() << endl;
            Sleep(1000);
            i++;
        }

        return flag;
    }

    void yfunction(const char *name)
    {
        int i = 0;
        while (i < 5)
        {
            std::cout << __func__ << ":" << name << " @thread " << this_thread::get_id() << endl;
            Sleep(1000);
            i++;
        }
    }

    void sfunction(int &num)
    {
        num += 100;
    }
} foo;

int main(int, char **)
{
    std::cout << "========boot=======" << endl;
    foo f;
    //第一个参数表示执行方法的类型
    //第二个参数表示方法名
    //后面是调用方法的参数
    //并且由future类型参数接收返回值
    std::future<int> fu = std::async(std::launch::async, foo::mfunction, &f, "hello world!!!", true);
    int ret = fu.get(); //该方法阻塞直到异步方法执行完,并且返回异步方法的返回值
    std::cout << "ret:" << ret << endl;

    //该异步方法返回值类型为void
    std::future<void> fut = std::async(std::launch::async, foo::yfunction, &f, "hello world!!!");
    fut.wait(); //调用wait方法阻塞知道异步方法执行完.

    int a = 10;
    std::future<void> fut = std::async(std::launch::async, foo::sfunction, &f, std::ref(a));
    fut.wait(); //调用wait方法阻塞知道异步方法执行完.

    std::cout << "========over=======" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54