C 如何判断线程是否响应了叫醒电话？

我想直接从输入设备读取键盘输入。从这样一个文件中读取需要root权限，我不需要，也不想，在程序的其余部分

我的计划是以root权限启动程序，然后启动工作线程，最后在主线程中删除root权限。然后，主线程可以发送请求，要求工作线程处理下一个键盘输入

我构建了一个最小的示例：

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <threads.h>

cnd_t wakeup;
mtx_t mutex;

enum request {
  REQUEST_NOTHING,
  REQUEST_PING,
  REQUEST_TERMINATION
} request;

int daemon(void *arg) {
  (void)arg;

  int retval;

  retval = mtx_lock(&mutex);
  assert(retval == thrd_success);

  for(;;) {
    request = REQUEST_NOTHING;

    retval = cnd_wait(&wakeup, &mutex);
    assert(retval == thrd_success);

    switch(request) {
      case REQUEST_NOTHING:
        break;

      case REQUEST_PING:
        puts("pong.");
        break;

      case REQUEST_TERMINATION:
        retval = mtx_unlock(&mutex);
        assert(retval == thrd_success);
        return 0;

      default:
        assert(false);
    }
  }
}

void send(enum request req) {
  int retval;

  retval = mtx_lock(&mutex);
  assert(retval == thrd_success);

  request = req;

  retval = mtx_unlock(&mutex);
  assert(retval == thrd_success);

  // TODO race condition: worker thread my not be listening yet

  retval = cnd_signal(&wakeup);
  assert(retval == thrd_success);
}

int main() {
  int retval;

  retval = mtx_init(&mutex, mtx_plain);
  assert(retval == thrd_success);

  retval = cnd_init(&wakeup);
  assert(retval == thrd_success);

  thrd_t thread;
  retval = thrd_create(&thread, daemon, NULL);
  assert(retval == thrd_success);

  puts("ping.");
  send(REQUEST_PING);

  // TODO wait for the worker thread to complete

  send(REQUEST_TERMINATION);
  retval = thrd_join(thread, NULL);
  assert(retval == thrd_success);

  cnd_destroy(&wakeup);
  mtx_destroy(&mutex);
}

#包括

这会导致竞争条件，因为主线程需要在写入
请求之前锁定互斥体，而工作线程也需要在等待信号之前锁定互斥体

主线程不会等待工作线程完成。在本例中，这不是问题，因为（1）主线程在发送下一个请求之前必须等待获得锁，并且（2）可以在退出之前简单地加入线程

但在我的实际程序中，我需要等待。显而易见的解决方案是引入另一对
cnd\u t
和
mtx\u t
，允许工作线程唤醒主线程。但对于这样一个简单的问题来说，这似乎过于复杂了

我找不到太多的资源来演示C11线程库的使用，而且可能都走错了方向。我希望您能提供一些反馈意见，或许能找到上述问题的解决方案。
在您的情况下，您不必在流程中永久保留
root
权限。
从输入设备读取数据不需要
root
。只有在打开时才检查权限

打开设备后，您的进程可以放弃
root
权限并继续执行其工作，以非特权用户的身份从打开的文件描述符中读取，因此您不需要单独的进程或线程

尽早放弃扩展特权是实现对特殊资源的访问的标准过程，同时将安全风险降至最低

另见

在其他情况下，您可能需要永久保留特权。在这种情况下，您将需要提升权限的任务与其他任务分离的想法很好，但您必须使用单独的进程而不是线程。
免责声明：而@dunes已经解决了我的问题，我了解到权限是在进程的基础上处理的（感谢@solomon），我发现这个问题没有一个解决比赛条件本身的答案是令人愤怒的


事实证明，我只是误解了如何使用这些
cnd\t
变量。诀窍是在启动工作线程之前锁定互斥体，并在等待信号时让它解锁互斥体。当给线程发信号时，锁在给线程发信号之前被获得，并且在请求发出之前不会被释放
已经发出信号了，信号熄灭了

此程序不再具有竞赛条件：

#include <assert.h>
#include <threads.h>

mtx_t mx_wakeup;
cnd_t cd_wakeup;

enum request {
  REQ_NOTHING,
  REQ_TERMINATE
} request;

int daemon(void *arg) {
  (void)arg;

  for(;;) {
    request = REQ_NOTHING;

    int retval = cnd_wait(&cd_wakeup, &mx_wakeup);
    assert(retval == thrd_success);

    if(request == REQ_TERMINATE) {
      return 0;
    }
  }
}

void send(enum request request_) {
  int retval;

  // The worker thread will unlock the mutex implicitly when
  // waiting for a signal, block until that happens.
  retval = mtx_lock(&mx_wakeup);
  assert(retval == thrd_success);

  request = request_;

  retval = cnd_signal(&cd_wakeup);
  assert(retval == thrd_success);

  // The worker thread needs to lock the mutex before waking up,
  // this ensures that it doesn't before receiving the signal.
  retval = mtx_unlock(&mx_wakeup);
  assert(retval == thrd_success);
}

int main() {
  int retval;

  retval = mtx_init(&mx_wakeup, mtx_plain);
  assert(retval == thrd_success);

  retval = cnd_init(&cd_wakeup);
  assert(retval == thrd_success);

  // The mutex will be unlocked by the worker thread when listening.
  retval = mtx_lock(&mx_wakeup);
  assert(retval == thrd_success);

  thrd_t thread;
  retval = thrd_create(&thread, daemon, NULL);
  assert(retval == thrd_success);

  send(REQ_TERMINATE);

  retval = thrd_join(thread, NULL);
  assert(retval == thrd_success);

  cnd_destroy(&cd_wakeup);
  mtx_destroy(&mx_wakeup);
}

#包括
#包括
mtx_t mx_唤醒；
cnd_t cd_唤醒；
枚举请求{
什么都不需要，
请求终止
}请求；
int守护进程（void*arg）{
（无效）arg；
对于（；；）{
请求=不需要任何东西；
int retval=cnd_wait（&cd_唤醒，&mx_唤醒）；
断言（retval==thrd_success）；
如果（请求==请求终止）{
返回0；
}
}
}
无效发送（枚举请求）{
内部检索；
//工作线程将在以下情况下隐式解锁互斥锁：
//等待信号，封锁直到发生。
retval=mtx_锁定（&mx_唤醒）；
断言（retval==thrd_success）；
请求=请求；
retval=cnd_信号（和cd_唤醒）；
断言（retval==thrd_success）；
//工作线程需要在唤醒前锁定互斥锁，
//这可确保在接收信号之前不会发生任何故障。
retval=mtx_解锁（&mx_唤醒）；
断言（retval==thrd_success）；
}
int main（）{
内部检索；
retval=mtx_init（&mx_唤醒，mtx_普通）；
断言（retval==thrd_success）；
retval=cnd_init（&cd_唤醒）；
断言（retval==thrd_success）；
//侦听时，工作线程将解锁互斥锁。
retval=mtx_锁定（&mx_唤醒）；
断言（retval==thrd_success）；
螺纹；
retval=thrd_create（&thread，daemon，NULL）；
断言（retval==thrd_success）；
发送（请求终止）；
retval=thrd_join（线程，NULL）；
断言（retval==thrd_success）；
cnd_销毁（和cd_唤醒）；
mtx_销毁（和mx_唤醒）；
}

等待工作线程现在只是添加另一个条件变量。只有终止代码
必须采用释放互斥锁，否则主线程将永远等待锁

#include <assert.h>
#include <threads.h>

mtx_t mx_wakeup;
cnd_t cd_wakeup, cd_complete;

enum request {
  REQ_NOTHING,
  REQ_TERMINATE
} request;

int daemon(void *arg) {
  (void)arg;
  int retval;

  for(;;) {
    request = REQ_NOTHING;

    retval = cnd_wait(&cd_wakeup, &mx_wakeup);
    assert(retval == thrd_success);

    // The request can be processed here.

    // Inform the main thread that the request was completed. The main
    // thread can choose to wait or not.
    retval = cnd_signal(&cd_complete);
    assert(retval == thrd_success);

    // Termination is different because the mutex wouldn't be released
    // by the next `cnd_wait`, and must happend after the signal was send.
    if(request == REQ_TERMINATE) {
      retval = mtx_unlock(&mx_wakeup);
      assert(retval == thrd_success);
      return 0;
    }
  }
}

void send(enum request request_) {
  int retval;

  retval = mtx_lock(&mx_wakeup);
  assert(retval == thrd_success);

  request = request_;

  retval = cnd_signal(&cd_wakeup);
  assert(retval == thrd_success);

  // This unlocks the mutex thus allowing the worker thread to process the
  // request, thus the mutex can be reused here.
  retval = cnd_wait(&cd_complete, &mx_wakeup);
  assert(retval == thrd_success);

  retval = mtx_unlock(&mx_wakeup);
  assert(retval == thrd_success);
}

int main() {
  int retval;

  retval = mtx_init(&mx_wakeup, mtx_plain);
  assert(retval == thrd_success);

  retval = cnd_init(&cd_wakeup);
  assert(retval == thrd_success);

  // Remember to initialize the new conditional variable.
  retval = cnd_init(&cd_complete);
  assert(retval == thrd_success);

  retval = mtx_lock(&mx_wakeup);
  assert(retval == thrd_success);

  thrd_t thread;
  retval = thrd_create(&thread, daemon, NULL);
  assert(retval == thrd_success);

  send(REQ_TERMINATE);

  retval = thrd_join(thread, NULL);
  assert(retval == thrd_success);

  cnd_destroy(&cd_wakeup);
  mtx_destroy(&mx_wakeup);
}

#包括
#包括
mtx_t mx_唤醒；
cnd_t cd_唤醒，cd_完成；
枚举请求{
什么都不需要，
请求终止
}请求；
int守护进程（void*arg）{
（无效）arg；
内部检索；
对于（；；）{
请求=不需要任何东西；
retval=cnd_wait（&cd_唤醒，&mx_唤醒）；
断言（retval==thrd_success）；
//请求可以在这里处理。
//通知主线程请求已完成。主线程
//线程可以选择等待或不等待。
retval=cnd_信号（&cd_完成）；
断言（retval==thrd_success）；
//终止是不同的，因为互斥锁不会被释放
//在下一个“cnd_wait”之前，必须在信号发送后发生。
如果（请求==请求终止）{
retval=mtx_解锁（&mx_唤醒）；
断言（retval==thrd_success）；
返回0；
}
}
}
无效发送（枚举请求）{
内部检索；
retval=mtx_锁定（&mx_唤醒）；
断言（retval==thrd_success）；
请求=请求；
retval=cnd_信号（和cd_唤醒）；
断言（retval==thrd_success）；
//这将解锁互斥锁，从而允许工作线程处理
//请求，因此可以在此处重用互斥体。
retval=cnd_wait（&cd_complete，&mx_wakeup）；
断言（retval==thrd_su