5

我正在阅读一些文档并尝试了一些futex在 Linux 中发出系统调用的代码示例。我读到如果thread_a使用获取互斥锁FUTEX_LOCK_PI,并说如果另一个线程thread_b尝试获取相同的互斥锁,则后者(thread_b)在内核中被阻止。

“在内核中阻塞”到底是什么意思?是不是thread_b在用户空间中的执行没有恢复?在以下示例中,第二个线程似乎也在系统调用之后发出 printf。这不是表明它没有在内核中被阻止吗?我错过了什么?

/*
 * This example demonstrates that when futex_lock_pi is called twice, the
 * second call is blocked inside the kernel.
 */

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

int mutex = 0;

#define  __NR_futex          240
#define FUTEX_WAIT 0
#define FUTEX_WAKE 1
#define FUTEX_FD 2
#define FUTEX_REQUEUE 3
#define FUTEX_CMP_REQUEUE 4
#define FUTEX_WAKE_OP 5
#define FUTEX_LOCK_PI 6
#define FUTEX_UNLOCK_PI 7
#define FUTEX_TRYLOCK_PI 8
#define FUTEX_WAIT_REQUEUE_PI 11
#define FUTEX_CMP_REQUEUE_PI  12


void *thread(void *arg) {
  int ret = 0;
  pid_t tid = gettid();
  printf("Entering thread[%d]\n", tid);

  ret = syscall(__NR_futex, &mutex, FUTEX_LOCK_PI, 1, NULL, NULL, 0);
  printf("Thread %d returned from kernel\n", tid);
  printf("Value of mutex=%d\n", mutex);
  printf("Return value from syscall=%d\n", ret);
}

int main(int argc, const char *argv[]) {
  pthread_t t1, t2;

  if (pthread_create(&t1, NULL, thread, NULL)) {
    printf("Could not create thread 1\n");
    return -1;
  }

  if (pthread_create(&t2, NULL, thread, NULL)) {
    printf("Could not create thread 2\n");
    return -1;
  }

  // Loop infinitely
  while ( 1 ) { }

  return 0;
}

输出可以在下面找到:-

Entering thread[952]
Thread 952 returned from kernel
Entering thread[951]
Value of mutex=-2147482696
Return value from syscall=0
Thread 951 returned from kernel
Value of mutex=-1073740873
Return value from syscall=0
4

1 回答 1

0

在内核中阻塞意味着线程进入睡眠状态,直到有事件唤醒它,在你的情况下,事件是可用的互斥锁。

我改变了一点你的代码来说明:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread(void *unused) {
  printf("Entering thread %d\n", syscall(SYS_gettid));

  pthread_mutex_lock(&mutex);

  sleep(2);

  pthread_mutex_unlock(&mutex);

  return NULL;
}

int main(int argc, const char *argv[]) {
  pthread_t t1, t2;

  printf("using mutex @%p\n", &mutex);

  if (pthread_create(&t1, NULL, thread, &t1)) {
    printf("Could not create thread 1\n");
    return -1;
  }

  if (pthread_create(&t2, NULL, thread, &t2)) {
    printf("Could not create thread 2\n");
    return -1;
  }

  pthread_join(t1, NULL);
  pthread_join(t2, NULL);

  return 0;
}

代码基本相同,但我明确使用了 pthread 库的互斥锁。

如果我用 strace 运行这段代码,我会得到:

using mutex @0x6010a0
Process 19688 attached
Entering thread 19688
Process 19689 attached
Entering thread 19689
[pid 19689] futex(0x6010a0, FUTEX_WAIT_PRIVATE, 2, NULL <unfinished ...>
[pid 19688] futex(0x6010a0, FUTEX_WAKE_PRIVATE, 1) = 1
[pid 19689] <... futex resumed> )       = 0
[pid 19688] +++ exited with 0 +++
[pid 19689] futex(0x6010a0, FUTEX_WAKE_PRIVATE, 1) = 0
[pid 19689] +++ exited with 0 +++
+++ exited with 0 +++

您可能会注意到,我们没有看到第一个线程使用互斥锁,但我们可以看到下一个线程正在等待等待(FUTEX_WAIT_PRIVATE)。这是因为在使用互斥锁时 futex 不会被调用。

但是你可以看到第一个线程(这里的 id 19688)最终调用了 futex(FUTEX_WAKE_PRIVATE),它告诉内核在 utex 空闲时唤醒另一个线程。

您可能已经注意到第一次调用 [pid 19689] futex(0x6010a0, FUTEX_WAIT_PRIVATE, 2, NULL <unfinished ...> 未完成,这意味着进程被挂起,等待内核完成工作并交还手。然后[pid 19689] <... futex resumed> ) = 0画出调用最终完成的草图(显然是因为互斥锁被释放了)

于 2015-10-31T15:30:59.497 回答