Pthreads 信号量，路障，条件变量

▶ 使用信号量来进行线程间信息传递

● 代码

 #include <stdio.h>
 #include <pthread.h>
 #include <semaphore.h>
 #pragma comment(lib, "pthreadVC2.lib")

 const int thread = , messageSize = ;
 char messageList[thread][messageSize];  // 全局信息列表
 sem_t sem[thread];                      // 各线程信号量，注意每个线程都有一个

 void* sendMessage(void* rank)
 {
     const long long localRank = (long long)rank, dest = (localRank + ) % thread;
     int i;
     sprintf_s(messageList[dest], messageSize, "Hello from %2d to %2d.", localRank, dest);
     sem_post(&sem[dest]);               // 解锁 dest 的信号量，因为上一行低吗已经完成了写入，注意每次执行完函数 sem_post() 后 sem[dest] 的值增加 1
     sem_wait(&sem[localRank]);          // 等待自己编号的信号量解锁，注意每次执行完函数 sem_wait() 后 sem[localRank] 的值减小 1（但不会小于0）
     printf("Thread %2d > %s\n", localRank, messageList[localRank]);
     return nullptr;
 }

 int main()
 {
     pthread_t pth[thread];
     int i;
     long long list[thread];

     for (i = ; i < thread; i++)
     {
         sem_init(&sem[i], , );        // 依次初始化信号量
         list[i] = i;
         pthread_create(&pth[i], nullptr, sendMessage, (void *)list[i]);
     }
     for (i = ; i < thread; i++)
     {
         pthread_join(pth[i], nullptr);
         sem_destroy(&sem[i]);           // 销毁信号量
     }
     printf("\nfinish.\n");
     getchar();
     return ;
 }

● 输出结果

 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .
 Thread   > Hello from   to  .

 finish.

● 用到的定义，注意信号量不是由 phread.h 提供的，而是 semaphore.h

 typedef struct sem_t_ * sem_t;

 PTW32_DLLPORT int __cdecl sem_init(sem_t * sem, int pshared, unsigned int value);
     // 初始化信号量，输入一个已经声明的信号量的指针，第二个参数不明，第三个参数为 0 表示初始化完成后信号量为上锁状态

 PTW32_DLLPORT int __cdecl sem_destroy(sem_t * sem);// 销毁信号量

 PTW32_DLLPORT int __cdecl sem_wait(sem_t * sem);   // 等待信号量为解锁状态再向下运行

 PTW32_DLLPORT int __cdecl sem_post(sem_t * sem);   // 解锁信号量

▶ 使用忙等待和互斥量来实现路障

● 代码

 #include <stdio.h>
 #include <pthread.h>
 #pragma comment(lib, "pthreadVC2.lib")

 const int thread = ;
 int count;
 pthread_mutex_t pmt;

 void* work(void* rank)
 {
     const long long localRank = (long long)rank, dest = (localRank + ) % thread;
     pthread_mutex_lock(&pmt);   // 进入读写区，上锁，计数器加一，解锁
     printf("Thread %2d reached the barrier.\n", localRank); fflush(stdout);
     count++;
     pthread_mutex_unlock(&pmt);
     while (count < thread);     // 使用忙等待来等所有的线程都达到栅栏
     printf("Thread %2d passed the barrier.\n", localRank); fflush(stdout);
     return nullptr;
 }

 int main()
 {
     pthread_t pth[thread];
     int i;
     long long list[thread];
     pthread_mutex_init(&pmt, nullptr);
     for (i = count = ; i < thread; i++)
     {
         list[i] = i;
         pthread_create(&pth[i], nullptr, work, (void *)list[i]);
     }
     for (i = ; i < thread; i++)
         pthread_join(pth[i], nullptr);
     pthread_mutex_destroy(&pmt);
     printf("\nfinish.\n");
     getchar();
     return ;
 }

● 输出结果

 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   reached the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.
 Thread   passed the barrier.

 finish.

▶ 使用信号量来实现路障

● 代码

 #include <stdio.h>
 #include <pthread.h>
 #include <semaphore.h>
 #pragma comment(lib, "pthreadVC2.lib")

 const int thread = ;
 int count;
 sem_t sem_count, sem_barrier;

 void* work(void* rank)
 {
     const long long localRank = (long long)rank, dest = (localRank + ) % thread;
     printf("Thread %2d reached the barrier.\n", localRank); fflush(stdout);
     sem_wait(&sem_count);       // 等待允许访问计数器 count，注意执行完该语句时 sem_count 值减 1，自动上锁
     if (count == thread - )    // 最后一个到达进入的线程
     {
         count = ;              // 计数器清零，以后可以重复使用
         sem_post(&sem_count);   // 计数器解锁，sem_count 值加 1
         for (int i = ; i < thread - ; sem_post(&sem_barrier), i++);// 解锁整个栅栏，
     }                                                                // 每有一个线程通过后面的语句 sem_wait(&sem_barrier);，
     else                        // 前面到达的线程                     // sem_barrier 的值就减 1，所以这里要为该变量加上 thread - 1
     {
         count++;                // 计数器加一
         sem_post(&sem_count);   // 解锁计数器
         sem_wait(&sem_barrier); // 等待栅栏解锁
     }
     printf("Thread %2d passed the barrier.\n", localRank); fflush(stdout);
     return nullptr;
 }

 int main()
 {
     pthread_t pth[thread];
     int i;
     long long list[thread];

     sem_init(&sem_count, , );     // 计数器锁初始化为 1，开锁状态
     sem_init(&sem_barrier, , );   // 栅栏初始化为 0，关锁状态
     for (i = count = ; i < thread; i++)
     {
         list[i] = i;
         pthread_create(&pth[i], nullptr, work, (void *)list[i]);
     }
     for (i = ; i < thread; i++)
         pthread_join(pth[i], nullptr);
     sem_destroy(&sem_count), sem_destroy(&sem_barrier);
     printf("\nfinish.\n");
     getchar();
     return ;
 }

● 输出结果

Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.

finish.

▶ 使用条件变量来实现路障

 #include <stdio.h>
 #include <pthread.h>
 #include <semaphore.h>
 #pragma comment(lib, "pthreadVC2.lib")

 const int thread = ;
 int count;
 pthread_mutex_t mutex;
 pthread_cond_t cond;

 void* work(void* rank)
 {
     const long long localRank = (long long)rank, dest = (localRank + ) % thread;
     printf("Thread %2d reached the barrier.\n", localRank); fflush(stdout);
     pthread_mutex_lock(&mutex);         // 上锁
     count++;
     if (count == thread)                // 最后一个进入的线程
     {
         count = ;                      // 计数器清零
         pthread_cond_broadcast(&cond);  // 广播所有线程继续向下执行
     }
     else
         for (; pthread_cond_wait(&cond, &mutex) != ;);// 等待其他线程
     pthread_mutex_unlock(&mutex);       // 条件变量阻塞解除后会自动将互斥量上锁，需要手工解除    

     printf("Thread %2d passed the barrier.\n", localRank); fflush(stdout);
     return nullptr;
 }

 int main()
 {
     pthread_t pth[thread];
     int i;
     long long list[thread];
     pthread_mutex_init(&mutex, nullptr);
     pthread_cond_init(&cond, nullptr);
     for (i = count = ; i < thread; i++)
     {
         list[i] = i;
         pthread_create(&pth[i], nullptr, work, (void *)list[i]);
     }
     for (i = ; i < thread; i++)
         pthread_join(pth[i], nullptr);
     pthread_mutex_destroy(&mutex);
     pthread_cond_destroy(&cond);
     printf("\nfinish.\n");
     getchar();
     return ;
 }

● 输出结果

Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   reached the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.
Thread   passed the barrier.

finish.

● 用到的定义，pthread.h

 typedef struct pthread_cond_t_ * pthread_cond_t;

 PTW32_DLLPORT int PTW32_CDECL pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr);// 初始化已经声明了的条件变量，第二个参数为属性指针

 PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy(pthread_cond_t * cond);                              // 销毁条件变量

 PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t * mutex);        // 阻塞线程以等待 signal 或 brocast

 PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal(pthread_cond_t * cond);                               // 解锁一个线程

 PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast(pthread_cond_t * cond);                            // 解锁所有的线程