title: How to manually send a QSignal from multiple std::threads?
body: <p>Essentially, I'm trying to add a Qt GUI onto an already existing GLUT application I made, and I'm not sure how to pass signals from the existing code into Qt, without introducing the overhead of making dozens of existing classes QObjects. Currently I'm using a QTimer and an event loop, but that isn't scaling very well, seeming to involve a lot of waiting for mutexes to then decide there's no work, with attempts to resolve this more increasing coupling than fixing it. </p>
  
  <p>The best alternate I could come up with is this:</p>
  
  <pre><code>static std::mutex relay_mutex;
  static std::condition_variable relay_condition;
  static std::queue&lt;std::pair&lt;int, void*&gt; &gt; relay_queue;
  
  extern "C"
  void passMessage(int a, void * b)
  {
      std::lock_guard&lt;std::mutex&gt; lock(relay_mutex);
      relay_queue.emplace_back(a, b);
      relay_condition.notify_all();
  }
  
  class RelayThread : public QThread
  {
      Q_OBJECT
  
  public:
      RelayThread() {}
  
  signals:
      void passMessage(int, void *);
  
  protected:
      void run() override
      {
          std::unique_lock&lt;std::mutex&gt; lock(relay_mutex);
  
          for(;;)
          {
              while(relay_queue.empty())
                  relay_condition.wait();
  
              do {
                  emit passMessage(relay_queue.front().first, relay_queue.front().second);
  
                  if(relay_queue.front().first == 0)
                      return;
  
                  relay_queue.pop()
              } while(relay_queue.size());
          }
      }
  };
  </code></pre>
  
  <p>But this will obviously incur the overhead of an extra context switch, which is no good either.  Is there a way to manually queue up a signal without going through a QThread like this?</p>