C++多线程学习笔记

头文件

#include <thread>

创建一个线程

void func()
{
    cout << "func" << endl;
    return;
}
thread thread1(func);

上述代码创建了一个线程thread1，func为该线程执行的函数，若该函数有入口参数，则在线程创建时加入一个参数，后续会介绍。

一、基础代码

创建一个线程打印 “func“ 字符串

#include <iostream>
#include <thread>
using namespace std;

void func()
{
    cout << "func" << endl;
    return;
} 
int main()
{
    thread thread1(func);
    cout << "over" << endl;
    return 0;
}

编译正确、执行错误，终端打印信息如下

(base)@auto:~/shares/cplusplus/mutl_threads$ ./mytest.o 
over
terminate called without an active exception
func
Aborted (core dumped)

原因：
main函数执行完成后，thread1线程还没执行完毕；
解决方法：利用join阻断

#include <iostream>
#include <thread>
using namespace std;

void func()
{
    cout << "func" << endl;
    return;
} 
int main()
{
    thread thread1(func);
    thread1.join();					# 改动
    cout << "over" << endl;
    return 0;
}

thread1 线程会在语句 thread1.join() 处等待，thread1结束后再执行后面的语句，终端运行结果：

(base)@auto:~/shares/cplusplus/mutl_threads$ ./mytest.o
func
over

若将thread1.join(); 放在语句cout << “over” << endl;之后，即

#include <iostream>
#include <thread>
using namespace std;

void func()
{
    cout << "func" << endl;
    return;
} 
int main()
{
    thread thread1(func);
    cout << "over" << endl;
    thread1.join();
    return 0;
}

则打印结果为

(base)@auto:~/shares/cplusplus/mutl_threads$ ./mytest.o
over
func

这是由于主程序执行到cout << “over” << endl;时，线程thread1还没打印完func；即两个线程此时同时进行，可想而知若我们打印一定长时间，则两个打印结果会交替出现，即：

#include <iostream>
#include <thread>
using namespace std;

void func()
{
    for (int i = 0; i < 1000; i++)
        cout << "a";
    return;
} 
int main()
{
    thread thread1(func);
    for (int i = 0 ; i < 1000; i++)
        cout << "b";
    thread1.join();
    cout << endl;
    return 0;
}

终端打印结果为

(base)@auto:~/shares/cplusplus/mutl_threads$ ./mytest.o
over
func
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabaaababbbbbbbbbbbbbbbbbbababababbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbaababababbbbbbbbbbbbbbbbabaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbabaababbbbbbbbbbbbbbbbbababababaabaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbbbababaaaaababbbbbbbbbbbbbbbbbabaabaaaaaaaaaaaaaaaaaabababaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaababababbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbababaaaaaaaaaaaaaaaaababaababbbbbbbbbbbbbbbbbabaaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbbbabaaaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbbabaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbababbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbababaabaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbaabaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaababbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

果然不出所料。
为了保证线程的安全性，有些线程是不能调用 join() 函数的，故需要判断函数是否可以使用 join() ，可以的情况下再调用，即：

#include <iostream>
#include <thread>
using namespace std;

void func()
{
    for (int i = 0; i < 1000; i++)
        cout << "a";
    return;
} 
int main()
{
    thread thread1(func);
    bool isjoin = thread1.joinable();
    if (isjoin)
    	thread1.join();
    for (int i = 0 ; i < 1000; i++)
        cout << "b";
    cout << endl;
    return 0;
}

二、传入函数含参数

#include <iostream>
#include <thread>
#include <string>
using namespace std;

void printhw(string s)
{
    for (int i = 0; i < 1000000000; i++)
        ;
    cout << s << endl;
    return;
} 
int main()
{
    string s = "HI";
    thread thread1(printhw, s);
    bool isjoin = thread1.joinable();
    if (isjoin)
    {
        thread1.join();
    }
    cout << "over" << endl;
    return 0;
}

2.1 传入局部变量时

#include <iostream>
#include <thread>
using namespace std;

thread t;

void foo(int& x)
{
    for (int i = 0; i < 1000000000; i++)
        ;
    x += 1;
}

int test()
{
    int x = 1;
    t = thread(foo, ref(x));

    return x;
}
int main()
{
    cout << test() << endl;
    bool isjoin = t.joinable();
    if (isjoin)
        t.join();
    return 0;
}

上述程序可以看到在主程序中test()函数已经执行完毕，而线程t还在执行，故输出值为1，为了解决此类情况，可以将join阻断加入到局部变量中

#include <iostream>
#include <thread>
using namespace std;

thread t;

void foo(int& x)
{
    for (int i = 0; i < 1000000000; i++)
        ;
    x += 1;
}

int test()
{
    int x = 1;
    t = thread(foo, ref(x));
    bool isjoin = t.joinable();
    if (isjoin)
        t.join();
    return x;
}
int main()
{
    cout << test() << endl;

    return 0;
}