valgrind 中的 helgrind 抱怨简单的互斥锁

Question

我正在调试一些线程代码，并且正在使用 valgrind --tool=helgrind，出于某种原因，helgrind 不喜欢下面的简单示例。

在启动线程之前，我锁定了互斥体。在线程结束时，我正在解锁，从而确保一次只有一个线程可以运行，假设互斥量将被锁定直到线程完成。

根据 valgrind 为什么这无效？

这是一个更大程序的一部分，我的主程序是 reading/parsing 数据，它将启动一个分析线程，但我一次只需要一个分析线程运行ning。

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;

void *inner(void *ptr){
  size_t threadid=(size_t)ptr;
  int sleepval = lrand48() % 5 +1;
  fprintf(stderr,"thread: %lu will wait:%d\n",threadid,sleepval);fflush(stderr);  
  sleep(sleepval);
  pthread_mutex_unlock(&mutex);
}




int outer(size_t ntimes){
  pthread_t thread1;
  size_t i;
  for(i=0;i<ntimes;i++){
    pthread_mutex_lock(&mutex);
    if(pthread_create( &thread1, NULL, inner, (void*) i))
      fprintf(stderr,"Problems creating thread\n");
  }
    pthread_mutex_lock(&mutex);
    pthread_mutex_unlock(&mutex);
}


int main(){
  pthread_mutex_init(&mutex, NULL);
  outer(3);
  return 0;
}

==8326== Helgrind, a thread error detector
==8326== Copyright (C) 2007-2013, and GNU GPL'd, by OpenWorks LLP et al.
==8326== Using Valgrind-3.10.0.SVN and LibVEX; rerun with -h for copyright info
==8326== Command: ./a.out
==8326== 
thread: 0 will wait:1
==8326== ---Thread-Announcement------------------------------------------
==8326== 
==8326== Thread #1 is the program's root thread
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #1: Attempt to re-lock a non-recursive lock I already hold
==8326==    at 0x4C32010: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400959: outer (threadTest.c:21)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326==  Lock was previously acquired
==8326==    at 0x4C32145: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400959: outer (threadTest.c:21)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== ---Thread-Announcement------------------------------------------
==8326== 
==8326== Thread #2 was created
==8326==    at 0x515543E: clone (clone.S:74)
==8326==    by 0x4E44199: do_clone.constprop.3 (createthread.c:75)
==8326==    by 0x4E458BA: pthread_create@@GLIBC_2.2.5 (createthread.c:245)
==8326==    by 0x4C30C90: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400976: outer (threadTest.c:22)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #2 unlocked lock at 0x6010A0 currently held by thread #1
==8326==    at 0x4C325C0: pthread_mutex_unlock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400937: inner (threadTest.c:11)
==8326==    by 0x4C30E26: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4E45181: start_thread (pthread_create.c:312)
==8326==    by 0x515547C: clone (clone.S:111)
==8326==   Lock at 0x6010A0 was first observed
==8326==    at 0x4C31DDA: pthread_mutex_init (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4009D0: main (threadTest.c:31)
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #1: Bug in libpthread: recursive write lock granted on mutex/wrlock which does not support recursion
==8326==    at 0x4C32145: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400959: outer (threadTest.c:21)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
thread: 1 will wait:4
==8326== ---Thread-Announcement------------------------------------------
==8326== 
==8326== Thread #3 was created
==8326==    at 0x515543E: clone (clone.S:74)
==8326==    by 0x4E44199: do_clone.constprop.3 (createthread.c:75)
==8326==    by 0x4E458BA: pthread_create@@GLIBC_2.2.5 (createthread.c:245)
==8326==    by 0x4C30C90: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400976: outer (threadTest.c:22)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #3 unlocked lock at 0x6010A0 currently held by thread #1
==8326==    at 0x4C325C0: pthread_mutex_unlock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400937: inner (threadTest.c:11)
==8326==    by 0x4C30E26: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4E45181: start_thread (pthread_create.c:312)
==8326==    by 0x515547C: clone (clone.S:111)
==8326==   Lock at 0x6010A0 was first observed
==8326==    at 0x4C31DDA: pthread_mutex_init (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4009D0: main (threadTest.c:31)
==8326== 
thread: 2 will wait:1
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #1: Attempt to re-lock a non-recursive lock I already hold
==8326==    at 0x4C32010: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4009B1: outer (threadTest.c:25)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326==  Lock was previously acquired
==8326==    at 0x4C32145: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400959: outer (threadTest.c:21)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== ---Thread-Announcement------------------------------------------
==8326== 
==8326== Thread #4 was created
==8326==    at 0x515543E: clone (clone.S:74)
==8326==    by 0x4E44199: do_clone.constprop.3 (createthread.c:75)
==8326==    by 0x4E458BA: pthread_create@@GLIBC_2.2.5 (createthread.c:245)
==8326==    by 0x4C30C90: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400976: outer (threadTest.c:22)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #4 unlocked lock at 0x6010A0 currently held by thread #1
==8326==    at 0x4C325C0: pthread_mutex_unlock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x400937: inner (threadTest.c:11)
==8326==    by 0x4C30E26: ??? (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4E45181: start_thread (pthread_create.c:312)
==8326==    by 0x515547C: clone (clone.S:111)
==8326==   Lock at 0x6010A0 was first observed
==8326==    at 0x4C31DDA: pthread_mutex_init (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4009D0: main (threadTest.c:31)
==8326== 
==8326== ----------------------------------------------------------------
==8326== 
==8326== Thread #1: Bug in libpthread: recursive write lock granted on mutex/wrlock which does not support recursion
==8326==    at 0x4C32145: pthread_mutex_lock (in /usr/lib/valgrind/vgpreload_helgrind-amd64-linux.so)
==8326==    by 0x4009B1: outer (threadTest.c:25)
==8326==    by 0x4009DA: main (threadTest.c:32)
==8326== 
==8326== 
==8326== For counts of detected and suppressed errors, rerun with: -v
==8326== Use --history-level=approx or =none to gain increased speed, at
==8326== the cost of reduced accuracy of conflicting-access information
==8326== ERROR SUMMARY: 9 errors from 7 contexts (suppressed: 104 from 61)

Answer 1

来自 pthread_mutex_lock 的手册页：

If a thread attempts to unlock a mutex that it has not locked or a mutex which is unlocked, undefined behavior results.

所以你必须在同一个线程中锁定和解锁互斥锁。

您的函数还应该 return 一个与原型匹配的值。

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

pthread_mutex_t mutex;

void *inner(void *ptr){
  size_t threadid = *(size_t *)ptr;
  int sleepval = rand() % 5 +1;
  pthread_mutex_lock(&mutex);
  fprintf(stderr,"thread: %lu will wait:%d\n",threadid,sleepval);
  fflush(stderr);
  sleep(sleepval);
  pthread_mutex_unlock(&mutex);
  return NULL;
}

int outer(size_t ntimes){
  pthread_t thread[ntimes];
  size_t i, id[ntimes];
  for(i=0;i<ntimes;i++){
    id[i] = i;
    if(pthread_create(thread + i, NULL, inner, &id[i]))
      fprintf(stderr,"Problems creating thread\n");
  }

  for(i=0;i<ntimes;i++)
    pthread_join(thread[i], NULL);
  return 0;
}

int main(void){

  pthread_mutex_init(&mutex, NULL);
  outer(3);
  return 0;
}

这对我有用。我还添加了缺失的 headers 并更改了函数参数以符合新要求。

旁注：outer 函数现在使用可变长度数组，因此它仅适用于 C99，不适用于 C++（问题被标记为两者）。

Answer 2

眼前的问题是您在一个线程中锁定了一个互斥锁，而在另一个线程中将其解锁。您还尝试在同一个线程中两次锁定同一个非递归互斥体。因为只有获得锁的线程才能释放它，所以不会是死锁。

要实现您可能想要的 senantic，您可以只加入新创建的线程：加入将阻塞，直到相应的线程退出。

或者，您可以保护活动线程数，该线程数在创建线程时增加，在线程完成时减少。完成线程也会发出条件变量信号。如果计数太高，创建线程将检查计数并等待条件变量。

拥有一个使用并可能阻塞作业队列的处理器线程可能是限制工作线程数量的最简单和最有效的方法。

valgrind 中的 helgrind 抱怨简单的互斥锁

helgrind in valgrind complains with simple mutex

c

c++

mutex

pthreads