1.C++多线程初步：
#include <iostream> #include <thread> #include <Windows.h> using namespace std; void run() { MessageBoxA(0, "hello world", "hello china", 0); } void main0101() { //同步（阻塞） run(); run(); run(); cin.get(); } void main0102() { //并行，异步，非阻塞 thread t1(run); //根据函数初始化并执行,t1在栈上 thread t2(run); thread t3(run); thread t4(run); cin.get(); } void main0103() { //并行，异步，非阻塞 //thread t[5]{ run,run,run,run,run }; //error C2440: “初始化”: 无法从“void (__cdecl *)(void)”转换为“std::thread” thread t[5]{ thread(run),thread(run), thread(run), thread(run), thread(run) }; //初始化线程数组（线程池） cin.get(); } void main0104() { //堆上 thread *pthread1(new thread(run)); thread *pthread2(new thread(run)); thread *pthread3(new thread(run)); cin.get(); } void main() { //堆上开辟了线程数组 thread *pthread1(new thread[5]{ thread(run),thread(run), thread(run), thread(run), thread(run) }); cin.get(); }
2. 线程冻结与解冻调试：
#include <iostream> #include <thread> #include <Windows.h> #include <cstdlib> using namespace std; void test() { int i = 0; while (1) { cout << ++i << endl; Sleep(1000); } } void main() { thread *p(new thread(test)); //堆上 system("pause"); system("pause"); system("pause"); system("pause"); cin.get(); }
3. 多线程传参：
#include <iostream> #include <thread> #include <Windows.h> using namespace std; void showmsg(const char *str1, const char *str2) { MessageBoxA(0, str1, str2, 0); } void main() { thread th1(showmsg, "1", "1"); thread th2(showmsg, "111", "111"); thread th3(showmsg, "222", "222"); cin.get(); }
4. 多线程的join 和detach：
#include <iostream> #include <thread> #include <array> #include <Windows.h> using namespace std; //join让当前主线程等待所有子线程执行完成才能退出 //detach脱离主线程的绑定，主线程退出的时候，不影响子线程。 void show() { MessageBoxA(0, "1", "1", 0); } void main0401() { array<thread, 3> threads{ thread(show),thread(show),thread(show) }; for (int i = 0; i < 3; i++) { cout << threads[i].joinable() << endl; //判断是否可以join threads[i].join(); //主线程等待子线程执行完成再退出 } auto n = thread::hardware_concurrency(); //获取CPU是几核 cout << n << endl; cin.get(); } void main() { thread th(show); //th.join(); th.detach(); //脱离主线程，主线程挂了不报错 //detach以后线程无法通信 th.joinable(); }
5. 原子变量与线程安全：
#include <iostream> #include <thread> #include <mutex> //互斥量 #include <atomic> //原子变量 using namespace std; //线程安全，多线程访问不冲突就是线程安全，冲突则不安全 //int num = 0; //mutex m; //互斥，加锁解锁浪费时间 atomic_int num(0); //原子变量不会发生线程冲突，属于线程安全 void run() { for (int i = 0; i < 10000000; i++) { //m.lock(); num++; //m.unlock(); } } void main() { clock_t start = clock(); thread th1(run); thread th2(run); th1.join(); th2.join(); clock_t end = clock(); cout << num << endl; cout << end - start << "ms" << endl; cin.get(); } //全局变量，会发生冲突，结果不正确，速度快 //mutex，结果正确，速度慢 //atomic，结果正确，速度比mutex快
6. lambda 表达式与多线程：
#include <iostream> #include <thread> #include <Windows.h> #include <chrono> using namespace std; void main0701() { //auto fun = []() {MessageBoxA(0, "1", "2", 0); }; //thread th1(fun); //thread th2(fun); thread th1([]() {MessageBoxA(0, "11", "22", 0); }); thread th2([]() {MessageBoxA(0, "11", "22", 0); }); cin.get(); } void main() { //thread th1([]() {cout << this_thread::get_id() << endl; }); //获取当前线程的id //thread th2([]() {cout << this_thread::get_id() << endl; }); thread th1([]() { this_thread::sleep_for(chrono::seconds(3)); //等待3秒 this_thread::yield(); //让CPU先执行其他线程，空闲了再执行我 cout << this_thread::get_id() << endl; //获取当前线程的id //this_thread::sleep_until(); //某个时刻到来之前一直等待 }); thread th2([]() { this_thread::sleep_for(chrono::seconds(10)); //等待10秒 cout << this_thread::get_id() << endl; }); cin.get(); }
7. 伪函数与多线程：
（1）伪函数概念：
#include <iostream> using namespace std; struct func { void operator ()() //伪函数，可以将对象名当做函数名来使用 { cout << "hello china hello cpp" << endl; } void operator ()(int i) //伪函数，可以将对象名当做函数名来使用 { cout << "hello china hello cpp! " << i << endl; } }; void main() { func f1; f1(); func f2; f2(2); cin.get(); }
（2）伪函数与多线程：
#include <iostream> #include <thread> #include <Windows.h> using namespace std; struct MyStruct { MyStruct() { cout << "create" << endl; } ~MyStruct() { cout << "end" << endl; } void operator ()() //对象名当做函数名使用，重载了()，但()只适用于当前结构体对象 { MessageBoxA(0, "111", "222", 0); } }; void main() { MyStruct go1; thread t1(go1); MyStruct go2; thread t2(go2); //MyStruct()是构造函数，创建一个临时对象,匿名对象 //MyStruct()(); //thread t3(MyStruct());//匿名的对象,不适合作为多线程参数，销毁太快 //MyStruct *p = new MyStruct; MyStruct *p = new MyStruct();//多一个()就是构造函数 cin.get(); }
8. 成员函数构建多线程：
#include <iostream> #include <thread> #include <Windows.h> using namespace std; struct fun { void run1() { MessageBoxA(0, "12345", "ABCDE", 0); cout << "hello china" << endl; } void run2(const char *str) { MessageBoxA(0, str, str, 0); cout << "hello china" << endl; } }; void main() { //fun *p(nullptr); //p->run1(); //空类指针可以引用没有调用内部变量的成员函数 fun fun1; //&fun::run引用成员函数 thread th1(&fun::run1, fun1); thread th2(&fun::run1, fun1); thread th3(&fun::run2, fun1,"run2-1"); thread th4(&fun::run2, fun1, "run2-2"); cin.get(); }
9. 多线程通信future：
#include <iostream> #include <thread> #include <future> #include <string> #include <cstdlib> using namespace std; void main0401() { string str1("12345"); string str2("678910"); string str3(str1 + str2); //C++风格的字符串 cout << str3 << endl; cin.get(); } promise<string>val; //全局通信变量 void main() { thread th1([]() { future<string> fu = val.get_future();//获取未来的状态 cout << "等待中..." << endl; cout << fu.get() << endl; }); thread th2([]() { system("pause"); val.set_value("I love CPP"); system("pause"); }); th1.join(); th2.join(); }
10. 基于继承的多线程：
#include <iostream> #include <thread> using namespace std; class zhangthread :public thread //C++代码重用-->继承 { public: zhangthread() :thread() //子类调父类的构造函数 { } template <typename T, typename...Args> //子类调父类的构造函数,可变参数的构造 zhangthread(T && func,Args &&...args):thread( forward<T>(func), forward<Args>(args)... ) { } void run(const char *cmd) //新增的功能 { system(cmd); } }; void main() { zhangthread t1([](){cout << "hello this is Zhang"<<endl;}); t1.run("calc"); zhangthread t2([](int num) {cout << "hello this is Zhang"<<num<<endl; },100 ); t2.run("notepad"); cin.get(); }
11. 条件变量：
#include <iostream> #include <thread> #include <mutex> #include <condition_variable> //条件变量 using namespace std; //线程通信，结合mutex //一个线程，多个线程处于等待，通知一个或通知多个 mutex m; //线程互相排斥 condition_variable cv; //线程通信 void main() { thread **th = new thread * [10];//开辟线程的指针数组 for (int i = 0; i < 10; i++) { th[i] = new thread([](int index) { unique_lock<mutex> lck(m); //锁定 cv.wait_for(lck, chrono::hours(1000)); //一直等待 cout << index << endl; //打印编号 } , i ); //传递参数 this_thread::sleep_for(chrono::milliseconds(100)); //错开 } for (int i = 0; i < 10; i++) { lock_guard<mutex> lckg(m);//解锁向导 cv.notify_one(); //挨个通知 } for (int i = 0; i < 10; i++) { th[i]->join(); delete th[i]; } delete[]th; //释放指针数组 cin.get(); }
12. 获取线程的结果：
#include <iostream> #include <thread> #include <future>//线程将来结果 #include <chrono>//时间 #include <mutex> using namespace std; mutex g_m; void main() { auto run = [=](int index)->int { lock_guard<mutex> lckg(g_m); //加锁 cout << this_thread::get_id() << " " << index << endl; //获取线程id this_thread::sleep_for(chrono::seconds(10)); //等待10秒 return index * 1024; //返回结果 }; packaged_task<int(int)> pt1(run); packaged_task<int(int)> pt2(run); //创建两个任务包 thread t1([&]() {pt1(2); }); thread t2([&]() {pt2(3); }); //开启线程 cout << pt1.get_future().get() << endl; cout << pt2.get_future().get() << endl; //获取结果 t1.join(); t2.join(); cin.get(); }
13. 可变参数实现多线程：
#include <iostream> #include <cstdarg> #include <thread> using namespace std; //可变参数 int go(const char *fmt, ...) { va_list ap; //第一个数据（指针） va_start(ap, fmt); //开始 vprintf(fmt, ap); //调用 va_end(ap); //结束 return 0; } void main() { thread th(go, "%sABCD%d____%c____%x", "12345abc", 123, 'A', 256); cin.get(); }
14. 多线程实现并行计算：
#include <iostream> #include <thread> #include <future> #include <vector> #include <cstdlib> using namespace std; #define COUNT 1000000 //线程函数： int add(vector<int> *arr, int start, int count) { static mutex m; //静态局部变量，只会初始化一次 int sum(0);//保存结果 for (int i = 0; i < count; i++) { sum += (*arr)[start + i];//实现累加 } { //此处仅仅是计算过程中的显示，更清楚查看 lock_guard<mutex> lckg(m);//加锁,不让其他线程干涉 cout << "thread" << this_thread::get_id() << ",count=" << count << ",sum=" << sum << endl; } return sum; } void main() { vector<int> data(COUNT); //数组，100万的大小 for (int i = 0; i < COUNT; i++) { data[i] = i % 1000; //0-999 } vector< future<int> > result;//结果数组 int cpus = thread::hardware_concurrency();//CPU核心的个数 for (int i = 0; i < cpus * 2; i++) { //1000 10= 100 * 10 //1000 9 = 1000 - 111*8 int batch_each = COUNT / (cpus * 2); if (i == (cpus * 2) - 1) { batch_each = COUNT - COUNT / (cpus * 2)*i;//最后一个承担的多一点 } //不断压入结果 result.push_back(async(add, &data, i*batch_each, batch_each));//async直接返回结果 } //汇总 int lastresult(0); for (int i = 0; i < cpus * 2; i++) { lastresult += result[i].get();//汇总结果，累加 } cout << "lastresule=" << lastresult << endl; cin.get(); }