基本使用

  1. #include <string>
  2. #include <pthread.h>
  3. #include <unistd.h>
  4. #include "testThread.h"
  5. #include "mylog.h"
  7. using namespace std;
  9. //自定义一个函数，异步任务使用
  10. void *customPThreadMethod(void *value) {
  12.     int tempValue = *static_cast<int *>(value);  //接收从外部传入的值
  14.     LOG("accept value from out method is %d", tempValue);
  15.     for (int i = 0; i < 10; ++i) {
  16.         sleep(1);
  17.         LOG("customPThreadMethod:%d", i + 1);
  18.     }
  20.     return 0;
  21. }
  23. void main_testThread() {
  25.     //线程基本使用
  26. //    int pthread_create(pthread_t *__pthread_ptr, pthread_attr_t const *__attr,
  27. //                       void *(*__start_routine)(void *), void *);
  28.     pthread_t pThreadID; //函数指针
  29.     int value = 1000;
  30.     pthread_create(&pThreadID, 0, customPThreadMethod, &value);
  32.     pthread_join(pThreadID, 0);  //会等待线程执行完毕之后，才会执行后面的代码
  34.     LOG("after thread");
  37. }

使用升级

分离线程和非分离线程 非分离线程，要等到耗时任务执行全部完成以后，先执行异步任务，才会执行join后面关联的代码逻辑

分离线程，各玩各的，老死不相往来，所以就造成了，不管异步任务是否执行完毕，该结束就结束

  1. #include <string>
  2. #include <pthread.h>
  3. #include <unistd.h>
  4. #include "testThread.h"
  5. #include "mylog.h"
  7. using namespace std;
  9. //自定义一个函数，异步任务使用
  10. void *customPThreadMethod(void *value) {
  12.     int tempValue = *static_cast<int *>(value);
  13. //    int tempValue = *((int *)value);
  15.     LOG("accept value from out method is %d", tempValue);
  16.     for (int i = 0; i < 10; ++i) {
  17.         sleep(1);
  18.         LOG("customPThreadMethod:%d", i + 1);
  19.     }
  21.     return 0;  //必须返回一个值，不然程序会闪退
  22. }
  24. void main_testThread() {
  26.     pthread_t pThreadID;  //线程ID，允许有野指针
  27.     pthread_attr_t pThreadAttr; //线程属性，不允许有野指针 有坑
  29.     //初始化：线程属性
  30.     pthread_attr_init(&pThreadAttr);
  32.     //开启分离线程，pthread_join就失效了
  33. //    pthread_attr_setdetachstate(&pThreadAttr, PTHREAD_CREATE_DETACHED);
  34.     //开启非分离线程和pthread_join关联起来了
  35.     pthread_attr_setdetachstate(&pThreadAttr, PTHREAD_CREATE_JOINABLE);
  37.     int value = 1000;
  38.     pthread_create(&pThreadID, &pThreadAttr, customPThreadMethod, &value);
  40.     //会等待线程执行完毕之后，才会执行后面的代码
  41.     pthread_join(pThreadID, 0);
  43.     //线程属性，进行回收
  44.     pthread_attr_destroy(&pThreadAttr);
  46.     LOG("after thread");
  47. }

线程安全互斥锁

  1. #include <string>
  2. #include <pthread.h>
  3. #include <unistd.h>
  4. #include <queue>
  5. #include "mylog.h"
  6. #include "testUpdateThread.h"
  8. using namespace std;
  10. queue<int> saveAllData;
  11. pthread_mutex_t mutex; //互斥锁
  13. //自定义一个函数，异步任务使用
  14. void *customPThreadUpdateMethod(void *value) {
  16.     //线程加锁
  17.     pthread_mutex_lock(&mutex);
  19.     int tempValue = *static_cast<int *>(value);
  20. //    int tempValue = *((int *)value);
  22.     LOG("accept value from out method is %d", tempValue);
  24.     if (!saveAllData.empty()) {
  25.         LOG("获取队列的数据:%d\n", saveAllData.front());
  26.         saveAllData.pop(); // 把数据弹出去，删除的意思
  27.     } else {
  28.         LOG("队列中没有数据了\n");
  29.     }
  31.     // 解除锁定，是为了让其他多线程，可以进来的操作，这就是解锁的目的
  32.     pthread_mutex_unlock(&mutex);
  34.     return 0;  //必须返回一个值，不然程序会闪退
  35. }
  37. void main_testUpdateThread(){
  39.     pthread_mutex_init(&mutex, nullptr);
  41.     for (int i = 1000; i < 10010; ++i) {
  42.         saveAllData.push(i);
  43.     }
  45.     pthread_t pThreadID[10];
  46.     for (int i = 0; i < 10; ++i) {
  47.         pthread_create(&pThreadID[i], 0, customPThreadUpdateMethod, &i);
  48.         pthread_join(pThreadID[i], 0);
  49.     }
  51.     LOG("函数已经执行到了这里");
  53.     //回收互斥锁
  54.     pthread_mutex_destroy(&mutex);
  55. }