devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux之线程控制

作者：Cpp五条 | 2024-03-17 12:00:09

赞

踩

Linux之线程控制

目录

一、POSIX线程库

二、线程的创建

三、线程等待

四、线程终止

五、分离线程

六、线程ID：pthread_t

1、获取线程ID

2、pthread_t

七、线程局部存储：__thread

一、POSIX线程库

由于Linux下的线程并没有独立特有的结构，所以Linux并没有提供线程相关的接口。

而我们所说的，pthread线程库是应用层的原生线程库。这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的。

1、与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
2、要使用这些函数库，要通过引入头文<pthread.h>
3、链接这些线程函数库时要使用编译器命令的“-lpthread”选项

二、线程的创建

pthread_create：其功能就是创建线程。

  1. NAME
  2.        pthread_create - create a new thread
  3.  
  4. SYNOPSIS
  5.        #include <pthread.h>
  6.  
  7.        int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
  8.                           void *(*start_routine) (void *), void *arg);
  9.  
  10.        Compile and link with -pthread.

参数说明：

thread：获取创建成功的线程ID，该参数是一个输出型参数。

attr：用于设置创建线程的属性，传入nullptr表示使用默认属性。(我们一般不关心，直接设为nullptr)

start_routine：该参数是一个函数指针，表示线程启动后要执行的函数。

arg：传给线程执行函数的参数。

返回值：线程创建成功返回0，失败返回错误码。返回值也可以自己设置，返回给主线程。主线程通过pthread_join获取。

主线程：当一个程序启动时，就有一个进程被操作系统创建，与此同时一个线程也立刻运行，这个线程就叫做主线程。

下面我们让主线程调用pthread_create函数创建一个新线程：

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <pthread.h>
  4.  
  5. using namespace std;
  6.  
  7. void *thread_run(void *argc)
  8. {
  9.     cout << "new thread pid: " << getpid() << "\n"
  10.          << endl;
  11.  
  12.     sleep(20);
  13.     return nullptr;
  14. }
  15.  
  16. int main()
  17. {
  18.     pthread_t tid;
  19.     pthread_create(&tid, nullptr, thread_run, (void *)"thread 1");
  20.  
  21.     while (true)
  22.     {
  23.         cout << "main thread pid: " << getpid() << endl;
  24.         sleep(1);
  25.     }
  26.  
  27.     return 0;
  28. }

 

使用ps -aL命令，可以显示当前的轻量级进程。

从上图，我们看到两个线程的PID相同，说明他们属于同一个进程。但是他们的LWP值不同，说明他们是两个不同的线程。LWP就是轻量级进程的ID。

注：在Linux中，线程与内核的LWP是一一对应的，实际上操作系统调度的时候是根据LWP调度的，而不是PID，只不过我们之前接触到的都是单线程进程，其PID和LWP是相等的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。

我们也可以让一个主线程创建多个新线程

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     string name = (char *)argc;
  11.     while (true)
  12.     {
  13.         cout << name << "---"
  14.              << "pid: " << getpid() << "\n"
  15.              << endl;
  16.         sleep(1);
  17.     }
  18. }
  19.  
  20. int main()
  21. {
  22.     pthread_t tid[5];
  23.     char name[64];
  24.     for (int i = 0; i < 5; i++)
  25.     {
  26.         snprintf(name, sizeof(name), "%s-%d", "thread", i);
  27.         pthread_create(tid + i, nullptr, thread_run, (void *)name);
  28.         sleep(1);
  29.     }
  30.  
  31.     while (true)
  32.     {
  33.         cout << "main thread pid: " << getpid() << endl;
  34.         sleep(3);
  35.     }
  36.  
  37.     return 0;
  38. }

因为主线程和五个新线程都属于同一个进程，所以它们的PID都是一样的。 

三、线程等待

一个线程被创建出来，那么这个线程就如同进程一般，也是需要被等待的。如果主线程不对新线程进行等待，那么这个新线程的资源也是不会被回收的。如果不等待会产生类似于“僵尸进程”的问题，也就会造成内存泄漏。所以线程需要被等待。

pthread_join：其功能就是进行线程等待

  1. NAME
  2.        pthread_join - join with a terminated thread
  3.  
  4. SYNOPSIS
  5.        #include <pthread.h>
  6.  
  7.        int pthread_join(pthread_t thread, void **retval);
  8.  
  9.        Compile and link with -pthread.

参数说明：

thread：被等待线程的ID。
retval：线程退出时的退出码信息。

返回值：线程等待成功返回0，失败返回错误码。

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     int count = 10;
  11.     while (true)
  12.     {
  13.         sleep(1);
  14.         if (count++ == 10)
  15.             break;
  16.     }
  17.  
  18.     cout << "new thread  done ... quit" << endl;
  19.     return nullptr;
  20. }
  21.  
  22. int main()
  23. {
  24.     pthread_t tid;
  25.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  26.     pthread_join(tid, nullptr);
  27.     cout << "main thread wait done ... quit" << endl;
  28.  
  29.     return 0;
  30. }

第二个参数是用来获取新线程返回值的。主线程可以通过新线程的返回值拿到新线程的计算结果（该结果也可以保存在堆空间上）

  1. include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     int count = 10;
  11.     while (true)
  12.     {
  13.         sleep(1);
  14.         if (count++ == 10)
  15.             break;
  16.     }
  17.  
  18.     cout << "new thread  done ... quit" << endl;
  19.     return (void *)10;
  20. }
  21.  
  22. int main()
  23. {
  24.     pthread_t tid;
  25.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  26.     void *ret = nullptr;
  27.     pthread_join(tid, &ret);
  28.     cout << "main thread wait done ... quit"
  29.          << " " << (long long)ret << endl;
  30.  
  31.     return 0;
  32. }

四、线程终止

return：最简单的终止线程的方式，就是使用return返回一个返回值来终止线程。

pthread_exit：其功能就是终止一个线程。（终止线程不能使用exit，因为它是用来终止进程的）

参数，retval：设置退出结果。

  1. NAME
  2.        pthread_exit - terminate calling thread
  3.  
  4. SYNOPSIS
  5.        #include <pthread.h>
  6.  
  7.        void pthread_exit(void *retval);
  8.  
  9.        Compile and link with -pthread.
  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     int count = 10;
  11.     while (true)
  12.     {
  13.         sleep(1);
  14.         if (count++ == 10)
  15.             break;
  16.     }
  17.  
  18.     cout << "new thread  done ... quit" << endl;
  19.     pthread_exit((void*)17);
  20. }
  21.  
  22. int main()
  23. {
  24.     pthread_t tid;
  25.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  26.     void *ret = nullptr;
  27.     pthread_join(tid, &ret);
  28.     cout << "main thread wait done ... quit"
  29.          << " " << (long long)ret << endl;
  30.  
  31.     return 0;
  32. }

 

pthread_cancel：其功能是取消一个线程。

参数，thread：线程ID。

  1. NAME
  2.        pthread_cancel - send a cancellation request to a thread
  3.  
  4. SYNOPSIS
  5.        #include <pthread.h>
  6.  
  7.        int pthread_cancel(pthread_t thread);
  8.  
  9.        Compile and link with -pthread.
  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     string name = (char *)argc;
  11.     int count = 10;
  12.     while (true)
  13.     {
  14.         sleep(1);
  15.         if (count++ == 10)
  16.             break;
  17.     }
  18.  
  19.     cout << "new thread  done ... quit" << endl;
  20. }
  21.  
  22. int main()
  23. {
  24.     pthread_t tid;
  25.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  26.     void *ret = nullptr;
  27.     pthread_cancel(tid);
  28.     pthread_join(tid, &ret);
  29.     cout << "main thread wait done ... quit"
  30.          << " " << (long long)ret << endl;
  31.  
  32.     return 0;
  33. }

 

线程被取消，线程等待时获取的退出码为-1。 

五、分离线程

新线程退出后，主线程需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
但如果主线程不关心新线程的返回值，此时我们可以将该新线程进行分离，后续当新线程退出时就会自动释放线程资源。

一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程内运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时系统会自动回收该线程所对应的资源。

pthread_detach：其功能就是进行分离线程。一般是线程自己分离。

int pthread_detach(pthread_t thread);

参数说明：thread：被分离线程的ID。

返回值说明：

线程分离成功返回0，失败返回错误码。

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <string>
  4. #include <pthread.h>
  5.  
  6. using namespace std;
  7.  
  8. void *thread_run(void *argc)
  9. {
  10.     pthread_detach(pthread_self());
  11.     int count = 10;
  12.     while (true)
  13.     {
  14.         sleep(1);
  15.         if (count++ == 10)
  16.             break;
  17.     }
  18.  
  19.     cout << "new thread  done ... quit" << endl;
  20.     pthread_exit((void*)17);
  21. }
  22.  
  23. int main()
  24. {
  25.     pthread_t tid;
  26.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  27.     void *ret = nullptr;
  28.     cout << "main thread wait done ... quit"
  29.          << " " << (long long)ret << endl;
  30.  
  31.     return 0;
  32. }

 如果我们在线程分离了之后，任然等待，会怎么样呢？

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <cerrno>
  4. #include <cstring>
  5. #include <pthread.h>
  6.  
  7. using namespace std;
  8.  
  9. void *thread_run(void *argc)
  10. {
  11.     pthread_detach(pthread_self());
  12.     int count = 9;
  13.     while (true)
  14.     {
  15.         sleep(1);
  16.         if (count++ == 10)
  17.             break;
  18.     }
  19.  
  20.     cout << "new thread  done ... quit" << endl;
  21.     pthread_exit((void *)17);
  22. }
  23.  
  24. int main()
  25. {
  26.     pthread_t tid;
  27.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  28.     sleep(2);
  29.     int n = pthread_join(tid, nullptr);
  30.     cout << "n: " << n << "errstring: " << strerror(n) << endl;
  31.  
  32.     return 0;
  33. }

六、线程ID：pthread_t

pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中，该线程ID和内核中的LWP是完全不一样的。内核中的LWP属于进程调度的范畴，需要一个数值来唯一表示该线程。

那么pthread_t到底是什么类型呢？

1、获取线程ID

pthread_self：获取线程的ID。

  1. #include <iostream>
  2. #include <unistd.h>
  3. #include <cerrno>
  4. #include <cstring>
  5. #include <pthread.h>
  6.  
  7. using namespace std;
  8.  
  9. void *thread_run(void *argc)
  10. {
  11.     int count = 9;
  12.     while (true)
  13.     {
  14.         sleep(1);
  15.         if (count++ == 10)
  16.             break;
  17.     }
  18.  
  19.     cout << "new thread  done ... quit"
  20.          << "new thread ID: " << pthread_self() << endl;
  21.     pthread_exit((void *)17);
  22. }
  23.  
  24. int main()
  25. {
  26.     pthread_t tid;
  27.     pthread_create(&tid, nullptr, thread_run, (void *)"thread1");
  28.     void *ret = nullptr;
  29.     sleep(2);
  30.     cout << "main thread ID: " << pthread_self() << endl;
  31.     pthread_join(tid, &ret);
  32.  
  33.     return 0;
  34. }

为什么线程的ID数值这么大呢？下面我们就来讲一讲。 

2、pthread_t

进程运行时线程动态库被加载到内存，然后通过页表映射到进程地址空间中的共享区，此时该进程内的所有线程都是能看到这个动态库的。

其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是由线程库帮我们在共享区中开辟的。

线程库给每个新线程提供属于自己的struct pthread，当中包含了对应线程的各种属性；每个线程还有自己的线程局部存储，当中包含了对应线程被切换时的上下文数据。其中，还有线程栈。如下图：

所以，线程ID本质就是进程地址空间共享区上对应的struct pthread的虚拟地址。 

七、线程局部存储：__thread

假设有一个全局变量：g_val。我们知道，各个线程是共享全局变量的。不同的线程可以对同一个全局变量进行操作。那么如果我们想让每个线程都拥有属于自己的g_val，那么我们可以加上关键字：__thread。这种现象就叫做线程局部存储。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/255921
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号