如果你使用过gui工具包，你知道有一个事件循环/主循环应该在一切完成后执行，这将使应用程序保持活跃并响应不同的事件。例如，对于Qt，您可以在main（）中执行此操作：
int main() {
QApplication app(argc, argv);
// init code
return app.exec();
}
在这种情况下，app.exec（）是应用程序的主循环。
实现这种循环的显而易见的方法是：
void exec() {
while (1) {
process_events(); // create a thread for each new event (possibly?)
}
}
但是这会将CPU限制在100％并且实际上是无用的。现在，我怎样才能实现这样一个响应的事件循环，而不必完全占用CPU？
Python和/或C ++中的答案很受欢迎。感谢。
脚注：为了学习，我将实现自己的信号/插槽，我会使用它们来生成自定义事件（例如go_forward_event(steps)）。但是如果你知道如何手动使用系统事件，我也想知道这一点。
答案 0 :(得分：70)
我过去常常想到很多相同的事情！
GUI主循环在伪代码中如下所示：
void App::exec() {
for(;;) {
vector<Waitable> waitables;
waitables.push_back(m_networkSocket);
waitables.push_back(m_xConnection);
waitables.push_back(m_globalTimer);
Waitable* whatHappened = System::waitOnAll(waitables);
switch(whatHappened) {
case &m_networkSocket: readAndDispatchNetworkEvent(); break;
case &m_xConnection: readAndDispatchGuiEvent(); break;
case &m_globalTimer: readAndDispatchTimerEvent(); break;
}
}
}
什么是“等待”？嗯，这取决于系统。在UNIX上，它被称为“文件描述符”，“waitOnAll”是:: select系统调用。所谓的vector<Waitable>在UNIX上是::fd_set，实际上是通过FD_ISSET查询“whatHappened”。实际的waitable-handles以各种方式获取，例如m_xConnection可以从:: XConnectionNumber（）中获取。 X11还为此提供了一个高级的可移植API - :: XNextEvent（） - 但是如果你使用它，你将无法等待多个事件源同时。
阻止如何工作？ “waitOnAll”是一个系统调用，告诉操作系统将您的进程置于“睡眠列表”中。这意味着在其中一个等待事件发生之前，您不会获得任何CPU时间。这意味着您的进程处于空闲状态，消耗0％的CPU。当事件发生时，您的进程将对其作出短暂反应，然后返回空闲状态。 GUI应用程序几乎花费所有时间闲置。
睡觉时所有CPU周期会发生什么？要看。有时另一个过程会对它们有用。如果没有，您的操作系统将忙于循环CPU，或将其置于临时低功耗模式等。
请询问更多详情！
答案 1 :(得分：21)
的Python：
您可以查看Twisted reactor的实现，这可能是python中事件循环的最佳实现。 Twisted中的反应器是接口的实现，您可以指定要运行的类型反应器：select，epoll，kqueue（所有基于使用这些系统调用的ac api），还有基于QT和GTK工具包的反应器。
一个简单的实现方法是使用select：
#echo server that accepts multiple client connections without forking threads
import select
import socket
import sys
host = ''
port = 50000
backlog = 5
size = 1024
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((host,port))
server.listen(backlog)
input = [server,sys.stdin]
running = 1
#the eventloop running
while running:
inputready,outputready,exceptready = select.select(input,[],[])
for s in inputready:
if s == server:
# handle the server socket
client, address = server.accept()
input.append(client)
elif s == sys.stdin:
# handle standard input
junk = sys.stdin.readline()
running = 0
else:
# handle all other sockets
data = s.recv(size)
if data:
s.send(data)
else:
s.close()
input.remove(s)
server.close()
答案 2 :(得分：11)
通常我会使用某种counting semaphore：
来执行此操作如果你不想那么复杂，你可以在你的while循环中添加一个sleep（）调用，并且睡眠时间很短。这将导致您的消息处理线程将其CPU时间转移到其他线程。 CPU不会再以100％挂钩，但它仍然非常浪费。
答案 3 :(得分：10)
我会使用一个名为ZeroMQ（http://www.zeromq.org/）的简单轻量级消息库。它是一个开源库（LGPL）。这是一个非常小的图书馆;在我的服务器上，整个项目在大约60秒内编译。
ZeroMQ将极大地简化您的事件驱动代码，并且它在性能方面也是最有效的解决方案。使用ZeroMQ在线程之间进行通信比使用信号量或本地UNIX套接字快得多（就速度而言）。 ZeroMQ也是100％可移植的解决方案，而所有其他解决方案将您的代码绑定到特定的操作系统。
答案 4 :(得分：0)
此答案适用于类似Unix的系统，例如Linux或Mac OSX。我不知道如何在Windows中完成此操作。
select（）或pselect（）。 Linux也有poll（）。
查看手册页以获取详细信息。 该系统调用需要文件描述符，超时和/或信号掩码的列表。该系统调用使程序等待事件发生。如果列表中的文件描述符之一准备好读取或写入（取决于设置，请参见联机帮助页），超时到期或到达信号，则此syscall将返回。然后，程序可以读取/写入文件描述符，处理信号或执行其他操作。之后，它将再次调用（p）select / poll，然后等到下一个事件。
应以非阻塞方式打开套接字，以便在没有数据/缓冲区已满时返回读/写功能。对于公共显示服务器X11，GUI是通过套接字处理的，并具有文件描述符。因此可以用相同的方式处理。
答案 5 :(得分：0)
这是一个 C++ 事件循环。在创建对象 EventLoop 时，它会创建一个线程，该线程不断运行赋予它的任何任务。如果没有可用任务，则主线程进入休眠状态，直到添加了某个任务。
首先我们需要一个线程安全的队列，它允许多个生产者和至少一个消费者（EventLoop 线程）。控制消费者和生产者的 EventLoop 对象。稍加改动，就可以添加多个消费者（runners 线程），而不是只有一个线程。
#include <stdio.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include <set>
#include <functional>
class EventLoopNoElements : public std::runtime_error
{
public:
EventLoopNoElements(const char* error)
: std::runtime_error(error)
{
}
};
template <typename Type>
struct EventLoopCompare {
typedef std::chrono::time_point<std::chrono::system_clock, std::chrono::duration<double, std::ratio<1, 1000000000> > > Milliseconds;
typedef std::tuple<typename EventLoopCompare<Type>::Milliseconds, Type> TimePoint;
bool operator()(const typename EventLoopCompare<Type>::TimePoint left, const typename EventLoopCompare<Type>::TimePoint right) {
return std::get<0>(left) < std::get<0>(right);
}
};
/**
* You can enqueue any thing with this event loop. Just use lambda functions, future and promises!
* With lambda `event.enqueue( 1000, [myvar, myfoo](){ myvar.something(myfoo); } )`
* With futures we can get values from the event loop:
* ```
* std::promise<int> accumulate_promise;
* event.enqueue( 2000, [&accumulate_promise](){ accumulate_promise.set_value(10); } );
* std::future<int> accumulate_future = accumulate_promise.get_future();
* accumulate_future.wait(); // It is not necessary to call wait, except for syncing the output.
* std::cout << "result=" << std::flush << accumulate_future.get() << std::endl;
* ```
* It is just not a nice ideia to add something which hang the whole event loop queue.
*/
template <class Type>
struct EventLoop {
typedef std::multiset<
typename EventLoopCompare<Type>::TimePoint,
EventLoopCompare<Type>
> EventLoopQueue;
bool _shutdown;
bool _free_shutdown;
std::mutex _mutex;
std::condition_variable _condition_variable;
EventLoopQueue _queue;
std::thread _runner;
// free_shutdown - if true, run all events on the queue before exiting
EventLoop(bool free_shutdown)
: _shutdown(false),
_free_shutdown(free_shutdown),
_runner( &EventLoop<Type>::_event_loop, this )
{
}
virtual ~EventLoop() {
std::unique_lock<std::mutex> dequeuelock(_mutex);
_shutdown = true;
_condition_variable.notify_all();
dequeuelock.unlock();
if (_runner.joinable()) {
_runner.join();
}
}
// Mutex and condition variables are not movable and there is no need for smart pointers yet
EventLoop(const EventLoop&) = delete;
EventLoop& operator =(const EventLoop&) = delete;
EventLoop(const EventLoop&&) = delete;
EventLoop& operator =(const EventLoop&&) = delete;
// To allow multiple threads to consume data, just add a mutex here and create multiple threads on the constructor
void _event_loop() {
while ( true ) {
try {
Type call = dequeue();
call();
}
catch (EventLoopNoElements&) {
return;
}
catch (std::exception& error) {
std::cerr << "Unexpected exception on EventLoop dequeue running: '" << error.what() << "'" << std::endl;
}
catch (...) {
std::cerr << "Unexpected exception on EventLoop dequeue running." << std::endl;
}
}
std::cerr << "The main EventLoop dequeue stopped running unexpectedly!" << std::endl;
}
// Add an element to the queue
void enqueue(int timeout, Type element) {
std::chrono::time_point<std::chrono::system_clock> timenow = std::chrono::system_clock::now();
typename EventLoopCompare<Type>::Milliseconds newtime = timenow + std::chrono::duration<double, std::ratio<1, 1000>>(timeout);
std::unique_lock<std::mutex> dequeuelock(_mutex);
_queue.insert(std::make_tuple(newtime, element));
_condition_variable.notify_one();
}
// Blocks until getting the first-element or throw EventLoopNoElements if it is shutting down
// Throws EventLoopNoElements when it is shutting down and there are not more elements
Type dequeue() {
typename EventLoopQueue::iterator queuebegin;
typename EventLoopQueue::iterator queueend;
typename EventLoopCompare<Type>::Milliseconds sleeptime;
// _mutex prevents multiple consumers from getting the same item or from missing the wake up
std::unique_lock<std::mutex> dequeuelock(_mutex);
do {
queuebegin = _queue.begin();
queueend = _queue.end();
if ( queuebegin == queueend ) {
if ( _shutdown ) {
throw EventLoopNoElements( "There are no more elements on the queue because it already shutdown." );
}
_condition_variable.wait( dequeuelock );
}
else {
if ( _shutdown ) {
if (_free_shutdown) {
break;
}
else {
throw EventLoopNoElements( "The queue is shutting down." );
}
}
std::chrono::time_point<std::chrono::system_clock> timenow = std::chrono::system_clock::now();
sleeptime = std::get<0>( *queuebegin );
if ( sleeptime <= timenow ) {
break;
}
_condition_variable.wait_until( dequeuelock, sleeptime );
}
} while ( true );
Type firstelement = std::get<1>( *queuebegin );
_queue.erase( queuebegin );
dequeuelock.unlock();
return firstelement;
}
};
打印当前时间戳的实用程序：
std::string getTime() {
char buffer[20];
#if defined( WIN32 )
SYSTEMTIME wlocaltime;
GetLocalTime(&wlocaltime);
::snprintf(buffer, sizeof buffer, "%02d:%02d:%02d.%03d ", wlocaltime.wHour, wlocaltime.wMinute, wlocaltime.wSecond, wlocaltime.wMilliseconds);
#else
std::chrono::time_point< std::chrono::system_clock > now = std::chrono::system_clock::now();
auto duration = now.time_since_epoch();
auto hours = std::chrono::duration_cast< std::chrono::hours >( duration );
duration -= hours;
auto minutes = std::chrono::duration_cast< std::chrono::minutes >( duration );
duration -= minutes;
auto seconds = std::chrono::duration_cast< std::chrono::seconds >( duration );
duration -= seconds;
auto milliseconds = std::chrono::duration_cast< std::chrono::milliseconds >( duration );
duration -= milliseconds;
time_t theTime = time( NULL );
struct tm* aTime = localtime( &theTime );
::snprintf(buffer, sizeof buffer, "%02d:%02d:%02d.%03ld ", aTime->tm_hour, aTime->tm_min, aTime->tm_sec, milliseconds.count());
#endif
return buffer;
}
使用这些的示例程序：
// g++ -o test -Wall -Wextra -ggdb -g3 -pthread test.cpp && gdb --args ./test
// valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --verbose ./test
// procdump -accepteula -ma -e -f "" -x c:\ myexe.exe
int main(int argc, char* argv[]) {
char buffer[20];
std::cerr << getTime() << "Creating EventLoop" << std::endl;
EventLoop<std::function<void()>>* eventloop = new EventLoop<std::function<void()>>(true);
std::cerr << getTime() << "Adding event element" << std::endl;
eventloop->enqueue( 3000, []{ char buffer[20]; std::cerr << getTime() << "Running task 3" << std::endl; } );
eventloop->enqueue( 1000, []{ char buffer[20]; std::cerr << getTime() << "Running task 1" << std::endl; } );
eventloop->enqueue( 2000, []{ char buffer[20]; std::cerr << getTime() << "Running task 2" << std::endl; } );
std::this_thread::sleep_for( std::chrono::duration<double, std::ratio<1, 1000>>(5000) );
delete eventloop;
std::cerr << getTime() << "Exiting after 10 seconds..." << std::endl;
return 0;
}
输出测试示例：
02:08:28.960 Creating EventLoop
02:08:28.960 Adding event element
02:08:29.960 Running task 1
02:08:30.961 Running task 2
02:08:31.961 Running task 3
02:08:33.961 Exiting after 10 seconds...