题目1：子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码
代码1：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 using namespace std; 5 6 const int count = 50; 7 int flag = 10; 8 std::mutex mtex; 9 10 void fun(const int num, const string &str) { 11 for(int i = 0; i < count; ++i) { 12 while(num != flag) std::this_thread::yield(); 13 mtex.lock(); 14 for(int j = 0; j < num; ++j) { 15 cout << str << endl; 16 } 17 std::this_thread::sleep_for(std::chrono::seconds(1)); 18 flag = (flag == 10 ? 100 : 10); 19 mtex.unlock(); 20 } 21 } 22 23 int main(void) { 24 auto start = std::chrono::high_resolution_clock::now(); 25 thread child(fun, 10, "child"); 26 fun(100, "father"); 27 child.join(); 28 auto end = std::chrono::high_resolution_clock::now(); 29 std::chrono::duration<double, std::milli> elapsed = end - start; 30 cout << elapsed.count() << endl; 31 32 return 0; 33 }
代码2：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <condition_variable> 5 using namespace std; 6 7 const int count = 50; 8 int flag = 10; 9 condition_variable cv; 10 std::mutex mtex; 11 12 void fun(const int num, const string &str) { 13 for(int i = 0; i < count; ++i) { 14 unique_lock<std::mutex> lk(mtex); 15 cv.wait(lk, [&]{ 16 return num == flag; 17 }); 18 for(int j = 0; j < num; ++j) { 19 cout << str << endl; 20 } 21 std::this_thread::sleep_for(std::chrono::seconds(1)); 22 flag = (flag == 10 ? 100 : 10); 23 mtex.unlock(); 24 cv.notify_one(); 25 } 26 } 27 28 int main(void) { 29 auto start = std::chrono::high_resolution_clock::now(); 30 thread child(fun, 10, "child"); 31 fun(100, "father"); 32 child.join(); 33 auto end = std::chrono::high_resolution_clock::now(); 34 std::chrono::duration<double, std::milli> elapsed = end - start; 35 cout << elapsed.count() << endl; 36 37 return 0; 38 }
题目2：编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推
代码1：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 using namespace std; 5 6 int main(void) { 7 std::mutex mtex; 8 int cnt = 0; 9 auto work = [&](char ch, int num) { 10 while(num--) { 11 while(ch != cnt + 'A') std::this_thread::yield(); 12 std::unique_lock<std::mutex> lk(mtex); 13 cout << ch; 14 cnt = (cnt + 1) % 3; 15 lk.unlock(); 16 } 17 }; 18 thread t1(work, 'A', 10); 19 thread t2(work, 'B', 10); 20 work('C', 10); 21 22 t1.join(); 23 t2.join(); 24 25 return 0; 26 }
代码2：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <chrono> 5 #include <condition_variable> 6 using namespace std; 7 8 condition_variable cv; 9 std::mutex mtex; 10 int cnt = 0; 11 12 void work(char ch, int num) { 13 while(num--) { 14 std::this_thread::sleep_for(std::chrono::seconds(1)); 15 unique_lock<std::mutex> lk(mtex); 16 cv.wait(lk, [&]{ 17 return 'A' + cnt == ch; 18 }); 19 cout << ch; 20 cnt = (cnt + 1) % 3; 21 lk.unlock(); 22 cv.notify_one(); 23 } 24 } 25 26 int main(void) { 27 thread t1(work, 'A', 10); 28 thread t2(work, 'B', 10); 29 work('C', 10); 30 31 t1.join(); 32 t2.join(); 33 34 return 0; 35 }
题目3：(google笔试题)：有四个线程1、2、3、4。线程 1 的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2....
B：2 3 4 1 2 3....
C：3 4 1 2 3 4....
D：4 1 2 3 4 1....
代码：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <fstream> 5 #include <condition_variable> 6 using namespace std; 7 8 const string filename = "D://code//c++//ac36"; 9 condition_variable cv; 10 std::mutex mtex; 11 12 int vis[] = {4, 1, 2, 3};//四个文件上一次分别写入的值 13 14 ofstream f1(filename + "_A.txt"); 15 ofstream f2(filename + "_B.txt"); 16 ofstream f3(filename + "_C.txt"); 17 ofstream f4(filename + "_D.txt"); 18 19 ofstream *file[4]; 20 21 void solve(const int x, int gg) { 22 while(gg--){ 23 for(int i = 0; i < 4; ++i) { 24 25 std::unique_lock<std::mutex> lk(mtex); 26 27 if(x == 1) { 28 cv.wait(lk, [&]{ 29 return vis[i] == 4; 30 }); 31 (*file[i]) << 1; 32 vis[i] = 1; 33 lk.unlock(); 34 cv.notify_all(); 35 }else if(x == 2) { 36 cv.wait(lk, [&]{ 37 return vis[i] == 1; 38 }); 39 (*file[i]) << 2; 40 vis[i] = 2; 41 lk.unlock(); 42 cv.notify_all(); 43 }else if(x == 3) { 44 cv.wait(lk, [&]{ 45 return vis[i] == 2; 46 }); 47 (*file[i]) << 3; 48 vis[i] = 3; 49 lk.unlock(); 50 cv.notify_all(); 51 }else { 52 cv.wait(lk, [&]{ 53 return vis[i] == 3; 54 }); 55 (*file[i]) << 4; 56 vis[i] = 4; 57 lk.unlock(); 58 cv.notify_all(); 59 } 60 } 61 } 62 } 63 64 int main(void) { 65 file[0] = &f1; 66 file[1] = &f2; 67 file[2] = &f3; 68 file[3] = &f4; 69 70 thread t1(solve, 1, 10); 71 thread t2(solve, 2, 10); 72 thread t3(solve, 3, 10); 73 solve(4, 10); 74 75 t1.join(); 76 t2.join(); 77 t3.join(); 78 79 for(int i = 0; i < 4; ++i) { 80 file[i]->close(); 81 } 82 return 0; 83 }
题目4：有一个写者很多读者，多个读者可以同时读文件，但写者在写文件时不允许有读者在读文件，同样有读者读时写者也不能写
代码：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <fstream> 5 #include <stdio.h> 6 #include <condition_variable> 7 using namespace std; 8 9 const string filename = "D://code//c++//ac36.txt"; 10 std::condition_variable cv; 11 std::mutex mtx; 12 int cnt = 0; 13 14 ifstream in(filename); 15 ofstream out(filename, ios::app); 16 17 void write() { 18 char ch; 19 while(true) { 20 std::unique_lock<std::mutex> lk(mtx); 21 ch = getchar(); 22 out << ch; 23 ++cnt; 24 lk.unlock(); 25 cv.notify_all(); 26 } 27 } 28 29 void read() { 30 char ch; 31 while(true) { 32 std::unique_lock<std::mutex> lk(mtx); 33 cv.wait(lk, [&]{ 34 return cnt > 0; 35 }); 36 in >> ch; 37 cout << "cout: " << ch << endl; 38 --cnt; 39 } 40 } 41 42 int main(void) { 43 cnt = in.tellg(); 44 45 std::thread tw(write); 46 std::thread tr1(read); 47 std::thread tr2(read); 48 std::thread tr3(read); 49 50 tw.join(); 51 tr1.join(); 52 tr2.join(); 53 tr3.join(); 54 55 in.close(); 56 out.close(); 57 58 return 0; 59 }
题目5：
线程安全的 queue
STL 中的 queue 是非线程安全的，一个组合操作：front(); pop() 先读取队首元素然后删除队首元素，若是有多个线程执行这个组合操作的话，可能会发生执行序列交替执行，导致一些意想不到的行为。因此需要重新设计线程安全的 queue 的接口
代码：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <queue> 5 #include <chrono> 6 #include <condition_variable> 7 using namespace std; 8 9 template <typename T> 10 class thread_safe_queue{ 11 private: 12 std::condition_variable cv; 13 std::queue<T> que; 14 std::mutex mtx; 15 16 public: 17 thread_safe_queue() = default; 18 thread_safe_queue(const std::queue<T> q) : que(q) {} 19 thread_safe_queue(const thread_safe_queue &tsf) { 20 std::unique_lock<std::mutex> lk(mtx); 21 que = tsf.que; 22 } 23 ~thread_safe_queue() = default; 24 25 void push(const T &value) { 26 std::unique_lock<std::mutex> lk(mtx); 27 que.push(value); 28 lk.unlock(); 29 cv.notify_all(); 30 } 31 32 T pop(void) { 33 std::unique_lock<std::mutex> lk(mtx); 34 cv.wait(lk, [&]{ 35 return bool(!que.empty()); 36 }); 37 T value = que.front(); 38 que.pop(); 39 return value; 40 } 41 42 bool empty(void) { 43 std::unique_lock<std::mutex> lk(mtx); 44 return que.empty(); 45 } 46 }; 47 48 thread_safe_queue<int> q; 49 std::mutex mtx; 50 51 int main(void) { 52 53 auto push_value = [&]{ 54 for(int i = 0; i < 100; ++i) { 55 q.push(i); 56 std::this_thread::sleep_for(std::chrono::seconds(1)); 57 } 58 }; 59 60 auto pop_value = [&]{ 61 while(1) { 62 while(!q.empty()) { 63 std::unique_lock<std::mutex> lk(mtx); 64 cout << q.pop() << ' '; 65 } 66 } 67 }; 68 69 thread push_thread1(push_value); 70 thread pop_thread1(pop_value); 71 thread pop_thread2(pop_value); 72 thread pop_thread3(pop_value); 73 74 push_thread1.join(); 75 pop_thread1.join(); 76 pop_thread2.join(); 77 pop_thread3.join(); 78 79 return 0; 80 }
题目6：编写程序完成如下功能：
1）有一int型全局变量g_Flag初始值为0
2） 在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
3） 在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
4） 线程序1需要在线程2退出后才能退出
5） 主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出
代码1：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <condition_variable> 5 using namespace std; 6 7 std::condition_variable cv; 8 std::mutex metx; 9 int g_Flag = 0; 10 int cnt = 0; 11 bool flag = false; 12 13 int main(void) { 14 thread t1([&]{ 15 std::unique_lock<std::mutex> lk(metx); 16 cout << "this is thread1 "; 17 g_Flag = 1; 18 ++cnt; 19 cv.wait(lk, [&]{{ 20 return flag; 21 }}); 22 cout << "thread1 exit "; 23 }); 24 25 thread t2([&]{ 26 std::unique_lock<std::mutex> lk(metx); 27 cout << "this is thread2 "; 28 g_Flag = 2; 29 cnt++; 30 flag = true; 31 cv.notify_all(); 32 cout << "thread2 exit "; 33 }); 34 35 t1.detach();//分离线程 36 t2.detach(); 37 38 std::unique_lock<std::mutex> lc(metx); 39 cv.wait(lc, [&]{ 40 return cnt >= 2; 41 }); 42 cout << "main thread exit "; 43 44 return 0; 45 }
代码2：
1 #include <iostream> 2 #include <thread> 3 #include <mutex> 4 #include <atomic> 5 #include <future> 6 using namespace std; 7 8 atomic<int> g_Flag(0), cnt(0); 9 10 void thread1(std::future<int> fu) { 11 cout << "this is thread1 "; 12 g_Flag = 1; 13 ++cnt; 14 fu.get();//线程1阻塞至线程2设置共享状态, get等待异步操作结束并返回结果 15 cout << "thread1 exit "; 16 } 17 18 void thread2(std::promise<int> pro) { 19 cout << "this is thread2 "; 20 g_Flag = 2; 21 ++cnt; 22 cout << "thread2 exit "; 23 pro.set_value(1);//设置共享值 24 } 25 26 int main(void) { 27 std::promise<int> prom;//创建一个promise对象 28 std::future<int> fu = prom.get_future();//获得promise内部的future,fut将和prom共享prom中的共享状态 29 30 std::thread t1(thread1, std::move(fu));//通过fut在线程1中得到线程2的状态 31 std::thread t2(thread2, std::move(prom));//通过prom设置线程2中的共享状态 32 33 t1.detach(); 34 t2.detach(); 35 36 while(cnt < 2); 37 cout << "main thread exit "; 38 39 return 0; 40 }