多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。

  • 基于进程的多任务处理是程序的并发执行。
  • 基于线程的多任务处理是同一程序的片段的并发执行。

多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 本教程假设您使用的是 Linux 操作系统，我们要使用 POSIX 编写多线程 C++ 程序。POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用，比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris

创建线程

下面的程序，我们可以用它来创建一个 POSIX 线程：

  1. #include <pthread.h>
  2. pthread_create (thread, attr, start_routine, arg)

在这里，pthread_create创建一个新的线程，并让它可执行。下面是关于参数的说明：

参数 描述
thread 指向线程标识符指针。
attr 一个不透明的属性对象，可以被用来设置线程属性。您可以指定线程属性对象，也可以使用默认值 NULL。
start_routine 线程运行函数起始地址，一旦线程被创建就会执行。
arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。如果没有传递参数，则使用 NULL。
  • 创建线程成功时，函数返回 0
  • 若返回值不为 0 则说明创建线程失败

终止线程

使用下面的程序，我们可以用它来终止一个 POSIX 线程：

  1. #include <pthread.h>
  2. pthread_exit (status)

在这里，pthread_exit用于显式地退出一个线程。通常情况下，pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。
如果 main() 是在它所创建的线程之前结束，并通过 pthread_exit() 退出，那么其他线程将继续执行。否则，它们将在 main() 结束时自动被终止。

以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程，每个线程输出”Hello Runoob！”:

  1. #include <iostream>
  2. #include <pthread.h> // 线程的头文件
  4. using namespace std;
  6. #define NUM_THREADS 5
  8. // 线程的运行函数
  9. void *say_hello(void *args)
  10. {
  11.   cout << "Hello 一缕清风！" << endl;
  12.   return 0;
  13. }
  15. int main()
  16. {
  17.   pthread_t threads[NUM_THREADS]; // 定义线程的 id 变量，多个变量使用数组
  18.   for (int i = 0; i < NUM_THREADS; ++i)
  19.   {
  20.     //参数依次是：创建的线程id，线程参数，调用的函数，传入的函数参数
  21.     int ret = pthread_create(&threads[i], NULL, say_hello, NULL);
  22.     if (ret != 0)
  23.     {
  24.       cout << "pthread_create error: error_code=" << ret << endl;
  25.     }
  26.   }
  27.   //等各个线程退出后，进程才结束，否则进程强制结束了，线程可能还没反应过来；
  28.   pthread_exit(NULL);
  29. }

现在，执行程序，将产生下列结果：

  1. $ g++ test.cpp -lpthread -o test.o
  2. $ ./test.o
  4. Hello 一缕清风！
  5. Hello 一缕清风！
  6. Hello 一缕清风！
  7. Hello 一缕清风！
  8. Hello 一缕清风！

以下简单的实例代码使用 pthread_create() 函数创建了 5 个线程，并接收传入的参数。每个线程打印一个 “Hello Runoob!” 消息，并输出接收的参数，然后调用 pthread_exit() 终止线程。

  1. //文件名：test.cpp
  2. #include <iostream>
  3. #include <cstdlib>
  4. #include <pthread.h>
  6. using namespace std;
  7. #define NUM_THREADS 5
  9. void *PrintHello(void *threadid)
  10. {
  11.   // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
  12.   // int *tid = (int *)threadid;
  13.   // cout << "Hello 一缕清风! 线程 ID, " << *tid << endl;
  14.   int tid = *((int *)threadid);
  15.   cout << "Hello 一缕清风! 线程 ID, " << tid << endl;
  16.   pthread_exit(NULL);
  17. }
  19. int main()
  20. {
  21.   pthread_t threads[NUM_THREADS];
  22.   int indexes[NUM_THREADS]; // 用数组来保存i的值
  24.   int i;
  25.   for (i = 0; i < NUM_THREADS; i++)
  26.   {
  27.     cout << "main() : 创建线程, " << i << endl;
  28.     indexes[i] = i; //先保存i的值
  29.     // 传入的时候必须强制转换为void* 类型，即无类型指针
  30.     int ret = pthread_create(&threads[i], NULL, PrintHello, (void *)&(indexes[i]));
  31.     if (ret)
  32.     {
  33.       cout << "Error:无法创建线程," << ret << endl;
  34.       exit(-1);
  35.     }
  36.   }
  37.   pthread_exit(NULL);
  38. }

现在编译并执行程序，将产生下列结果：

  1. $ g++ test.cpp -lpthread -o test.o
  2. $ ./test.o
  4. main() : 创建线程, 0
  5. main() : 创建线程, 1
  6. Hello 一缕清风! 线程 ID, 0
  7. Hello 一缕清风! 线程 ID, 1
  8. main() : 创建线程, 2
  9. main() : 创建线程, 3
  10. Hello 一缕清风! 线程 ID, 2
  11. main() : 创建线程, 4
  12. Hello 一缕清风! 线程 ID, 3
  13. Hello 一缕清风! 线程 ID, 4

向线程传递参数

这个实例演示了如何通过结构传递多个参数。您可以在线程回调中传递任意的数据类型，因为它指向 void，如下面的实例所示：

  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <pthread.h>
  5. using namespace std;
  6. #define NUM_THREADS 5
  8. struct thread_data
  9. {
  10.   int thread_id;
  11.   char *message;
  12. };
  14. void *PrintHello(void *threadarg)
  15. {
  16.   // struct thread_data *my_data;
  17.   // my_data = (struct thread_data *)threadarg;
  18.   struct thread_data *my_data = (struct thread_data *)threadarg;
  19.   cout << "Thread ID : " << my_data->thread_id << " Message : " << my_data->message << endl;
  20.   ;
  21.   pthread_exit(NULL);
  22. }
  24. int main()
  25. {
  26.   pthread_t threads[NUM_THREADS];
  27.   struct thread_data td[NUM_THREADS];
  28.   int i;
  30.   for (i = 0; i < NUM_THREADS; i++)
  31.   {
  32.     cout << "main() : creating thread, " << i << endl;
  33.     td[i].thread_id = i;
  34.     td[i].message = (char *)"This is message";
  35.    int ret = pthread_create(&threads[i], NULL,
  36.                         PrintHello, (void *)&td[i]);
  37.     if (ret)
  38.     {
  39.       cout << "Error:unable to create thread," << ret << endl;
  40.       exit(-1);
  41.     }
  42.   }
  43.   pthread_exit(NULL);
  44. }

当上面的代码被编译和执行时，它会产生下列结果：

  1. $ g++ -Wno-write-strings test.cpp -lpthread -o test.o
  2. $ ./test.o
  3. main() : creating thread, 0
  4. main() : creating thread, 1
  5. Thread ID : 0 Message : This is message
  6. main() : creating thread, Thread ID : 21
  7.  Message : This is message
  8. main() : creating thread, 3
  9. Thread ID : 2 Message : This is message
  10. main() : creating thread, 4
  11. Thread ID : 3 Message : This is message
  12. Thread ID : 4 Message : This is message

连接和分离线程

我们可以使用以下两个函数来连接或分离线程：

  1. pthread_join (threadid, status) 
  2. pthread_detach (threadid)

当创建一个线程时，它的某个属性会定义它是否

  • 可连接的 (joinable): pthread_join() 子程序阻碍调用程序，直到指定的 threadid 线程终止为止
  • 可分离的 (detached): 如果线程创建时被定义为可分离的，则它永远也不能被连接。

⚠️注意: 只有创建时定义为可连接的线程才可以被连接
这个实例演示了如何使用 pthread_join() 函数来等待线程的完成。

  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <pthread.h>
  4. #include <unistd.h>
  6. using namespace std;
  7. #define NUM_THREADS 5
  9. void *wait(void *t)
  10. {
  11.   // int i;
  12.   long tid = (long)t;
  14.   sleep(3);
  15.   cout << "———— Sleeping in thread ———— " << endl;
  16.   cout << "Thread with id : " << tid << endl;
  17.   pthread_exit(NULL);
  18. }
  20. int main()
  21. {
  22.   int i;
  23.   pthread_t threads[NUM_THREADS];
  24.   pthread_attr_t attr;
  25.   void *status;
  27.   // 初始化并设置线程为可连接的（joinable）
  28.   pthread_attr_init(&attr);
  29.   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  31.   for (i = 0; i < NUM_THREADS; i++)
  32.   {
  33.     cout << "main() : creating thread, " << i << endl;
  34.     int ret = pthread_create(&threads[i], NULL, wait, (void *)&i);
  35.     if (ret)
  36.     {
  37.       cout << "Error:unable to create thread," << ret << endl;
  38.       exit(-1);
  39.     }
  40.   }
  42.   // 删除属性，并等待其他线程
  43.   pthread_attr_destroy(&attr);
  44.   for (i = 0; i < NUM_THREADS; i++)
  45.   {
  46.     int ret = pthread_join(threads[i], &status);
  47.     if (ret)
  48.     {
  49.       cout << "Error:unable to join," << ret << endl;
  50.       exit(-1);
  51.     }
  52.     cout << "Main: completed thread id :" << i << "  exiting with status :" << status << endl;
  53.   }
  55.   cout << "Main: program exiting." << endl;
  56.   pthread_exit(NULL);
  57. }

当上面的代码被编译和执行时，它会产生下列结果：

  1. main() : creating thread, 0
  2. main() : creating thread, 1
  3. main() : creating thread, 2
  4. main() : creating thread, 3
  5. main() : creating thread, 4
  6. ———— Sleeping in thread ———— 
  7. ———— Sleeping in thread ———— Thread with id : ———— Sleeping in thread ———— ———— Sleeping in thread ———— 140732824192504
  9. ———— Sleeping in thread ———— Thread with id : 
  11. Thread with id : 140732824192504
  13. 140732824192504Thread with id : 140732824192504Thread with id : 
  14. Main: completed thread id :
  15. 0  exiting with status :0x0
  16. 140732824192504
  17. Main: completed thread id :1  exiting with status :0x0
  18. Main: completed thread id :2  exiting with status :0x0
  19. Main: completed thread id :3  exiting with status :0x0
  20. Main: completed thread id :4  exiting with status :0x0
  21. Main: program exiting.

[

](https://www.runoob.com/cplusplus/cpp-web-programming.html)

c++ 11 之后有了标准的线程库

  1. #include <iostream>
  2. #include <thread>
  4. using namespace std;
  5. #define NUM_THREADS 3
  7. thread::id main_thread_id = this_thread::get_id();
  11. void hello()
  12. {
  13.   if (main_thread_id == this_thread::get_id())
  14.     cout << "hello():This is the main thread.\n";
  15.   else
  16.     cout << "hello(): This is not the main thread.\n";
  17. }
  19. void pause_thread(int n)
  20. {
  21.   this_thread::sleep_for(chrono::seconds(n));
  22.   cout << "pause of " << n << " seconds ended\n";
  23. }
  25. int main()
  26. {
  27.   thread t(hello);
  28.   cout << t.hardware_concurrency() << endl;              //可以并发执行多少个(不准确)
  29.   cout << "native_handle " << t.native_handle() << endl; //可以并发执行多少个(不准确)
  30.   printf("_____________________________________\n");
  32.   hello();
  34.   thread j(hello);
  35.   j.join();
  37.   thread d(hello);
  38.   d.detach();
  40.   thread threads[NUM_THREADS]; // 默认构造线程
  41.   cout << "Spawning " << NUM_THREADS << " threads...\n";
  42.   for (int i = 0; i < NUM_THREADS; ++i)
  43.     threads[i] = thread(pause_thread, i + 1); // move-assign threads
  45.   cout << "Done spawning threads. Now waiting for them to join:\n";
  46.   for (auto &thread : threads)
  47.     thread.join();
  49.   cout << "All threads joined!\n";
  50. }
  52. /* 
  53. hello(): This is not the main thread.
  54. native_handle 0x700006420000
  55. _____________________________________
  56. hello():This is the main thread.
  57. hello(): This is not the main thread.
  58. Spawning 3 threads...
  59. hello(): This is not the main thread.
  60. Done spawning threads. Now waiting for them to join:
  61. pause of 1 seconds ended
  62. pause of 2 seconds ended
  63. pause of 3 seconds ended
  64. All threads joined!
  65. libc++abi.dylib: terminating
  66. Abort trap: 6
  67. */

之前一些编译器使用 C++11 的编译参数是 -std=c++11

  1. g++ -std=c++11 test.cpp -lpthread && ./a.out

⚠️注意: 要注意内存泄露问题。如果设置为 PTHREAD_CREATE_JOINABLE，就继续用 pthread_join() 来等待和释放资源，否则会内存泄露。