Question

我有一个基于pthread的多线程程序，有四个线程无限期地执行这个运行循环（伪代码）：

while(keepRunning)
{
   pthread_barrier_wait(&g_stage_one_barrier);

   UpdateThisThreadsStateVariables();  

   pthread_barrier_wait(&g_stage_two_barrier);

   DoComputationsThatReadFromAllThreadsStateVariables();
}

这非常有效，因为在第一阶段，每个线程都会更新自己的状态变量，这没关系，因为在第一阶段没有其他线程正在读取任何其他线程的状态变量。然后在第二阶段，就线程读取彼此状态而言，它是一个免费的，但是没关系，因为在第二阶段没有线程正在修改它的本地状态变量，所以它们实际上是只读的。

我唯一剩下的问题是，当我的应用程序退出时，如何干净利落地关闭这些线程？（通过“干净可靠”，我的意思是不引入潜在的死锁或竞争条件，理想情况下无需发送任何UNIX信号来强制线程退出pthread_barrier_wait（）调用）

我的main（）线程当然可以为每个线程将keepRunning设置为false，但是如何为每个线程返回pthread_barrier_wait（）？ AFAICT让pthread_barrier_wait（）返回的唯一方法是同时将所有四个线程的执行位置放在pthread_barrier_wait（）中，但是当某些线程可能已经退出时，这很难做到。

调用pthread_barrier_destroy（）似乎就像我想做的那样，但是当任何线程可能在屏障上等待时，这是未定义的行为。

这个问题有一个众所周知的解决方案吗？

Answer 1

有两个标志并使用类似下面的内容应该有效：

for (;;)
{
    pthread_barrier_wait(&g_stage_one_barrier);           +
                                                          |
    UpdateThisThreadsStateVariables();                    |
                                                          |
    pthread_mutex_lock(&shutdownMtx);                     | Zone 1
    pendingShutdown = !keepRunning;                       |
    pthread_mutex_unlock(&shutdownMtx);                   |
                                                          |
    pthread_barrier_wait(&g_stage_two_barrier);           +
                                                          |
    if (pendingShutdown)                                  |
        break;                                            | Zone 2
                                                          |
    DoComputationsThatReadFromAllThreadsStateVariables(); |
}

shutdownMtx也应该保护keepRunning的设置，尽管它没有显示。

逻辑是，当pendingShutdown设置为true时，所有线程必须位于 Zone 1 内。（即使只有部分线程看到keepRunning为false，也是如此，因此keepRunning上的比赛应该没问题。）接下来它们都会到达pthread_barrier_wait(&g_stage_two_barrier)，然后当他们进入第2区时全部爆发。

还可以检查PTHREAD_BARRIER_SERIAL_THREAD - pthread_barrier_wait()对于其中一个线程返回的内容 - 并且仅对pendingShutdown中的{{1}}进行锁定和更新线程，可以提高性能。

Answer 2

你可以有一个额外的线程在同一障碍上同步，但只作为“关闭主机”存在。您的工作线程将使用您的问题中的确切代码，“shutdown master”线程将执行：

while (keepRunning)
{
    pthread_barrier_wait(&g_stage_one_barrier);

    pthread_mutex_lock(&mkr_lock);
    if (!mainKeepRunning)
        keepRunning = 0;
    pthread_mutex_unlock(&mkr_lock);

    pthread_barrier_wait(&g_stage_two_barrier);
}

当主线程希望其他线程关闭时，它只会执行：

pthread_mutex_lock(&mkr_lock);
mainKeepRunning = 0;
pthread_mutex_unlock(&mkr_lock);

（即keepRunning变量成为阶段2中只读的共享线程状态的一部分，并且在阶段1期间由关闭主线程拥有。

当然，您也可以选择其他一个线程作为“关闭主线程”，而不是为此目的使用专用线程。

Answer 3

存在需求冲突：屏障语义要求所有线程都要in继续，并且在执行块之间共享线程时，关闭需要终止（可能在不同的障碍内）。

我建议使用支持extern cancel调用的自定义实现替换屏障。

示例（可能无法运行，但想法......）：

struct _barrier_entry
{
  pthread_cond_t cond;
  volatile bool released;
  volatile struct _barrier_entry *next;
};

typedef struct
{
  volatile int capacity;
  volatile int count;
  volatile struct _barrier_entry *first;
  pthread_mutex_t lock;
} custom_barrier_t;

初始化：

int custom_barrier_init(custom_barrier_t *barrier, int capacity)
{
   if (NULL == barrier || capacity <= 0)
   {
     errno = EINVAL;
     return -1;
   }
   barrier->capacity = capacity;
   barrier->count = 0;
   barrier->first = NULL;
   return pthread_mutex_init(&barrier->lock, NULL);
   return -1;
}

助手：

static void _custom_barrier_flush(custom_barrier_t *barrier)
{
   struct _barrier_entry *ptr;
   for (ptr = barrier->first; NULL != ptr;)
   {
     struct _barrier_entry *next = ptr->next;
     ptr->released = true;
     pthread_cond_signal(&ptr->cond);
     ptr = next;
   }
   barrier->first = NULL;
   barrier->count = 0;
}

阻止等待：

int custom_barrier_wait(custom_barrier_t *barrier)
{
   struct _barrier_entry entry;
   int result;
   pthread_cond_init(&barrier->entry, NULL);
   entry->next = NULL;
   entry->released = false;

   pthread_mutex_lock(&barrier->lock);
   barrier->count++;
   if (barrier->count == barrier->capacity)
   {
     _custom_barrier_flush(barrier);
     result = 0;
   }
   else
   {
     entry->next = barrier->first;
     barrier->first = entry;
     while (true)
     {
       pthread_cond_wait(&entry->cond, &barrier->lock);
       if (entry->released)
       {
         result = 0;
         break;
       }
       if (barrier->capacity < 0)
       {
         errno = ECANCELLED;
         result = -1;
         break;
       }
     }
   }
   pthread_mutex_unlock(&barrier->lock);
   pthread_cond_destroy(&entry->cond);
   return result;
}

取消：

 int custom_barrier_cancel(custom_barrier_t *barrier)
 {
   pthread_mutex_lock(barrier->lock);
   barrier->capacity = -1;
   _custom_barrier_flush(barrier);
   pthread_mutex_unlock(barrier->lock);
   return 0;
 }

因此线程代码可以在循环中运行，直到ECANCELLED调用后出现custom_barrier_wait错误。

Answer 4

在障碍处等待的线程不是问题，它仍然运行UpdateThis...或DoComputations...的线程将延迟关闭。您可以通过定期检查UpdateThis...和DoComputations...函数内的关闭来缩短关机时间。

以下是一种可能解决方案的概要

main初始化互斥锁g_shutdown_mutex
main锁定互斥锁
main启动线程
线程在定期尝试锁定时执行其操作互斥锁，但由于main已锁定互斥锁，因此trylock功能将永远失败
当关机时间时，主要解锁互斥锁
现在trylock将成功，工作人员将提前返回
在到达第二个障碍之前，任何成功锁定互斥锁的线程都会设置全局变量g_shutdown_requested
在传递第二个障碍后，所有线程都会在g_shutdown_requested中看到相同的值并做出是否退出的相同决定

所以while循环看起来像这样

while(1)
{
    pthread_barrier_wait(&g_stage_one_barrier);

    UpdateThisThreadsStateVariables();

    if ( pthread_mutex_trylock( &g_shutdown_mutex ) == 0 )
    {
        g_shutdown_requested = true;
        pthread_mutex_unlock( &g_shutdown_mutex );
        break;
    }

    pthread_barrier_wait(&g_stage_two_barrier);

    if ( g_shutdown_requested )
        break;

    DoComputationsThatReadFromAllThreadsStateVariables();
}

工人职能看起来像这样

void UpdateThisThreadsStateVariables( void )
{
    for ( i = 0;; i++ )
    {
        // check the mutex once every 4000 times through the loop
        if ( (i & 0xfff) == 0 && pthread_mutex_trylock( &g_shutdown_mutex ) == 0 )
        {
            pthread_mutex_unlock( &g_shutdown_mutex );   // abnormal termination
            return; 
        }

        // do the important stuff here

        if ( doneWithTheImportantStuff )    // normal termination
            break;
    }
}

清除/可靠关闭使用pthread屏障进行同步的线程的好策略是什么？

4 个答案: