c++线程

pthread(部分内容来自菜鸟教程)

创建线程

创建一个 POSIX 线程：

#include 
pthread_create (thread, attr, start_routine, arg) 
1
2

pthread_create 创建一个新的线程，并让它可执行。

参数：

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

终止线程

#include 
pthread_exit (status) 
1
2

向线程传递参数

在线程回调中传递任意的数据类型，因为它指向 void。

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

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

连接和分离线程

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

pthread_join() 子程序阻碍调用程序，直到指定的 threadid 线程终止为止。当创建一个线程时，它的某个属性会定义它是否是可连接的（joinable）或可分离的（detached）。只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的，则它永远也不能被连接。

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

同步实现–锁

lock有很多实现的方式，linux这里使用的是mutex，由于mutex本身是结构体，所以声名的时候别忘了init一下。

#include "pthread.h"

pthread_mutex_t mutex; //这里要保证是global var，
pthread_mutex_init(&mutex, NULL); //init mutex，

pthread_mutex_lock(&mutex); //准备进入临界区

// critical section //

pthread_mutex_unlock(&mutex); //释放锁，别的线程可能要使用
pthread_mutex_destroy(&mutex); // 销毁锁，锁不能在用了
1
2
3
4
5
6
7
8
9
10
11

Condition vatiables(cv)

cv的含义其实有点偏向于MPI的思想，传递消息；可以让threads wait，也可以notify or broadcast线程让他们起来干活。主要的操作有一下三种：

phtread_cond_init();

pthread_cond_wait(&theCV,&somelock); //这里sleep线程的同时也将somelock释放掉了，要不其他线程无法取得lock就没办法执行(甚至是叫醒它了）
pthread_cond_signal(&theCV); 
pthread_cond_boardcast(&theCV);
1
2
3
4
5

在临界区中处理写share量的时候，需要保证不同线程对其的访问是可控的，否则可能在不同线程中读取到的写share量不一致进而影响CV的工作，因为一般情况下临界区中的写share量就是我们CV工作中的重要判断量。因此，虽然这个条件相对严格，但是是有必要的。

semaphore

这个东西可以看作是lock的一个自然延申。也就是一个资源可以同时被多少执行单元使用。我们之前讲到的lock就可以看做是一个binary semaphore。这里就只是简要的谈谈，因为这个东西使用的时候很让人头大，弄不好就会死锁。而且虽然semaphore属于POSIX标准，但是严格来讲的话，它不属于pthread。

#include 

sem_t sem;
sem_init(&sem);
sem_wait(&sem);

// critical section

sem_post(&sem);
sem_destroy(&sem);
1
2
3
4
5
6
7
8
9
10

semaphore可以控制同一个时间有多少thread可以访问临界区，需要注意的就是上面声明–释放的匹配关系不要忘记。

std::thread

创建线程

通过 detach() 函数，将子线程和主线分离，子线程可以独立继续运行，即使主线程结束，子线程也不会结束。

#include 
#include 
using namespace std::literals::chrono_literals;
using namespace std;

void test() {
    cout << "Hello World" << endl;
}

int main() {
    std::thread t1(test);
    t1.detach();
    this_thread::sleep_for(10ms); // c++ 17
    // 低于C++17使用这行代码  this_thread::sleep_for(chrono::milliseconds(10));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

传递参数

join() 函数可以在当前线程等待线程运行结束。

#include 
#include 
using namespace std::literals::chrono_literals;
using namespace std;

void test(int Id,string name) {
    cout << "Hello World" << endl;
        cout << "Id : " <