用什么来在内部发出“选择”信号？

Question

I am designing a robot that runs on Linux, I want to have a telemetry only interface from the robot that runs on TCP/IP mostly for my own education about TCP but also for guaranteed packet ordering and the checksum. My current design is to have three threads:

1. Thread that listens for connections and adds new connections to the list
2. Thread that collects the telemetry from the other parts of the system and sends it to each connection in the list
3. Thread that select 's on the list and removes any clients that disconnect from the list

I'd like thread 1 to be able to signal thread 3 "Hey buddy, new connection, update your list", the obvious answer to me is create some additional file/pipe that can be added to 3 's select list and if the additional file is the one signaled update the list. I think a file or a pipe is bit of overkill for signaling though,I should think a binary semaphore would do the trick, but I don't know how to select on a binary semaphore.

I guess my question is: what thinks can you turn into a file descriptor so you can select on them?

My secondary question is: I am a "older school" Linux/C developer trying to come up to speed on more modern techniques, specifically modern c++, is there a more "modern c++" way to do this?

Answer 1

eventfd(2) is a handy Linux-specific API that is meant for this sort of notification. It creates a file descriptor that can be used to signal events by writing to it.

Example using it (And poll() , which is generally preferable to select() ):

#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <thread>

#include <unistd.h>
#include <poll.h>
#include <sys/eventfd.h>

void messenger(int efd) {
  while (1) {
    std::uint64_t i = 1;
    if (write(efd, &i, sizeof i) != sizeof i) {
      std::perror("write");
      std::exit(1);
    }
    sleep(1);
  }
}

int main() {
  int efd = eventfd(0, 0);
  if (efd < 0) {
    std::perror("eventfd");
    return 1;
  }
  std::thread messenger_thread{messenger, efd};
  struct pollfd waiter[1];

  waiter[0].fd = efd;
  waiter[0].events = POLLIN;
  
  while (poll(waiter, 1, -1) >= 0) {
    if (waiter[0].revents & POLLIN) {
      std::uint64_t i;
      if (read(efd, &i, sizeof i) != sizeof i) {
        std::perror("read");
        return 1;
      }
      std::puts("Signaled by messenger.");
    }
  }
}

---

As noted in my earlier comment, though, I think this is the wrong architecture - you really shouldn't have another thread just to detect closed connections, as those are generally signaled via a failed read or write on the socket - it's best done in the same thread that's sending data to them. And it's easy to have a non-blocking listening socket that you also poll for and accept() when readable - basically, it's easier to do everything in one thread instead of trying to split it up. Collecting the data from your robot telemetry might be suitable for a separate thread, though. Or it could be done in the same one that handles the clients that end up receiving the data. You don't give enough information to really say.