QCoreApplication QMetaCallEvent 压缩
每个排队的插槽调用最终都会将 a 发布QMetaCallEvent到目标对象。该事件包含发送者对象、信号 id、槽索引和打包的调用参数。在 Qt 5 上，信号 id 通常不等于返回的值QMetaObject::signalIndex()：它是一个计算的索引，就好像对象只有信号方法而没有其他方法一样。
目标是压缩此类调用，以便事件队列中对于给定的（发送者对象、发送者信号、接收者对象、接收者槽）元组仅存在一个唯一调用。
这是唯一明智的方法，无需更改源或目标对象，同时保持最小的开销。我的其他答案中的事件循环递归方法每个事件都有严重的堆栈开销，当 Qt 为 64 位指针架构构建时，大约为 1kbyte。
当新事件发布到一个已经发布了一个或多个事件的对象时，可以访问事件队列。在这种情况下，QCoreApplication::postEvent调用QCoreApplication::compressEvent. compressEvent当第一个事件发布到对象时不调用。在此方法的重新实现中，QMetaCallEvent可以检查发布到目标对象的内容以查找对您的插槽的调用，并且必须删除过时的副本。必须包含私有 Qt 头文件才能获得 和的QMetaCallEvent定义。QPostEventQPostEventList
优点：发送者和接收者对象都不必知道任何事情。信号和槽按原样工作，包括 Qt 5 中的方法指针调用。Qt 本身使用这种压缩事件的方式。
缺点：需要包含私有 Qt 标头和强制清除QEvent::posted标志。
当零持续时间计时器被触发时，QEvent::posted可以在单独的列表中排队并在调用之外删除要删除的事件，而不是破解标志。compressEvent这具有额外的事件列表的开销，并且每个事件删除都会遍历发布的事件列表。
其他方法
以其他方式执行此操作的目的是不使用 Qt 的内部结构。
L1第一个限制是不能访问私有定义的内容QMetaCallEvent。可按以下方式处理：
可以在源对象和目标对象之间连接具有与目标相同签名的信号和槽的代理对象。
在代理对象上运行QMetaCallEvent允许提取调用类型、被调用的槽 id 和参数。
代替信号槽连接，可以将事件显式发布到目标对象。目标对象或事件过滤器必须显式地从事件数据重新合成槽调用。
可以使用自定义compressedConnect实现来代替QObject::connect. 这充分暴露了信号和槽的细节。代理对象可用于queued_activate在发送者对象一侧执行压缩友好的等效操作。
L2第二个限制是不能完全重新实现QCoreApplication::compressEvent，因为事件列表是私有定义的。我们仍然可以访问被压缩的事件，我们仍然可以决定是否删除它，但是没有办法迭代事件列表。因此：
事件队列可以通过sendPostedEvents从内部递归调用来隐式访问notify（因此也可以从eventFilter()，event()或从插槽）。这不会导致死锁，因为QCoreApplication::sendPostedEvents当事件通过sendEvent. 可以按如下方式过滤事件：
- 在全球范围内重新实施
QCoreApplication::notify，
- 通过在全球范围内注册一个
QInternal::EventNotifyCallback,
- 在本地通过将事件过滤器附加到对象，
QObject::event()通过在目标类中重新实现显式本地化。
重复的事件仍会发布到事件队列中。notify从内部进行的递归调用会sendPostedEvents消耗相当多的堆栈空间（在 64 位指针架构上预算为 1kb）。
QCoreApplication::removePostedEvents在将新事件发布到对象之前，可以通过调用来删除已经存在的事件。不幸的是，这样做QCoreApplication::compressEvent会导致死锁，因为事件队列互斥体已经被持有。
包含指向接收器对象的指针的自定义事件类可以removePostedEvents在构造函数中自动调用。
QEvent::Exit可以重新占用现有的压缩事件，例如。
这些事件的集合是一个实现细节，可能会发生变化。QObject除了接收器指针之外，Qt 不会区分这些事件。实现需要每个（事件类型，接收器对象）元组的代理 QObject 开销。
执行
下面的代码适用于 Qt 4 和 Qt 5。在后者上，确保添加QT += core-private到您的 qmake 项目文件中，以便包含私有 Qt 标头。
其他答案中给出了不使用 Qt 内部标头的实现：
有两个事件删除代码路径，由 选择if (true)。启用的代码路径通常会保留最近的事件并且最有意义。或者，您可能希望保留最旧的事件 - 这就是禁用代码路径的作用。
#include <QApplication>
#include <QMap>
#include <QSet>
#include <QMetaMethod>
#include <QMetaObject>
#include <private/qcoreapplication_p.h>
#include <private/qthread_p.h>
#include <private/qobject_p.h>
#include <QWidget>
#include <QPushButton>
#include <QPlainTextEdit>
#include <QSpinBox>
#include <QFormLayout>
// Works on both Qt 4 and Qt 5.
//
// Common Code
/*! Keeps a list of singal indices for one or more meatobject classes.
* The indices are signal indices as given by QMetaCallEvent.signalId.
* On Qt 5, those do *not* match QMetaObject::methodIndex since they
* exclude non-signal methods. */
class SignalList {
Q_DISABLE_COPY(SignalList)
typedef QMap<const QMetaObject *, QSet<int> > T;
T m_data;
/*! Returns a signal index that is can be compared to QMetaCallEvent.signalId. */
static int signalIndex(const QMetaMethod & method) {
Q_ASSERT(method.methodType() == QMetaMethod::Signal);
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
int index = -1;
const QMetaObject * mobj = method.enclosingMetaObject();
for (int i = 0; i <= method.methodIndex(); ++i) {
if (mobj->method(i).methodType() != QMetaMethod::Signal) continue;
++ index;
}
return index;
#else
return method.methodIndex();
#endif
}
public:
SignalList() {}
void add(const QMetaMethod & method) {
m_data[method.enclosingMetaObject()].insert(signalIndex(method));
}
void remove(const QMetaMethod & method) {
T::iterator it = m_data.find(method.enclosingMetaObject());
if (it != m_data.end()) {
it->remove(signalIndex(method));
if (it->empty()) m_data.erase(it);
}
}
bool contains(const QMetaObject * metaObject, int signalId) {
T::const_iterator it = m_data.find(metaObject);
return it != m_data.end() && it.value().contains(signalId);
}
};
//
// Implementation Using Event Compression With Access to Private Qt Headers
struct EventHelper : private QEvent {
static void clearPostedFlag(QEvent * ev) {
(&static_cast<EventHelper*>(ev)->t)[1] &= ~0x8001; // Hack to clear QEvent::posted
}
};
template <class Base> class CompressorApplication : public Base {
SignalList m_compressedSignals;
public:
CompressorApplication(int & argc, char ** argv) : Base(argc, argv) {}
void addCompressedSignal(const QMetaMethod & method) { m_compressedSignals.add(method); }
void removeCompressedSignal(const QMetaMethod & method) { m_compressedSignals.remove(method); }
protected:
bool compressEvent(QEvent *event, QObject *receiver, QPostEventList *postedEvents) {
if (event->type() != QEvent::MetaCall)
return Base::compressEvent(event, receiver, postedEvents);
QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(event);
if (! m_compressedSignals.contains(mce->sender()->metaObject(), mce->signalId())) return false;
for (QPostEventList::iterator it = postedEvents->begin(); it != postedEvents->end(); ++it) {
QPostEvent &cur = *it;
if (cur.receiver != receiver || cur.event == 0 || cur.event->type() != event->type())
continue;
QMetaCallEvent *cur_mce = static_cast<QMetaCallEvent*>(cur.event);
if (cur_mce->sender() != mce->sender() || cur_mce->signalId() != mce->signalId() ||
cur_mce->id() != mce->id())
continue;
if (true) {
/* Keep The Newest Call */
// We can't merely qSwap the existing posted event with the new one, since QEvent
// keeps track of whether it has been posted. Deletion of a formerly posted event
// takes the posted event list mutex and does a useless search of the posted event
// list upon deletion. We thus clear the QEvent::posted flag before deletion.
EventHelper::clearPostedFlag(cur.event);
delete cur.event;
cur.event = event;
} else {
/* Keep the Oldest Call */
delete event;
}
return true;
}
return false;
}
};
//
// Demo GUI
class Signaller : public QObject {
Q_OBJECT
public:
Q_SIGNAL void emptySignal();
Q_SIGNAL void dataSignal(int);
};
class Widget : public QWidget {
Q_OBJECT
QPlainTextEdit * m_edit;
QSpinBox * m_count;
Signaller m_signaller;
Q_SLOT void emptySlot() {
m_edit->appendPlainText("emptySlot invoked");
}
Q_SLOT void dataSlot(int n) {
m_edit->appendPlainText(QString("dataSlot(%1) invoked").arg(n));
}
Q_SLOT void sendSignals() {
m_edit->appendPlainText(QString("\nEmitting %1 signals").arg(m_count->value()));
for (int i = 0; i < m_count->value(); ++ i) {
emit m_signaller.emptySignal();
emit m_signaller.dataSignal(i + 1);
}
}
public:
Widget(QWidget * parent = 0) : QWidget(parent),
m_edit(new QPlainTextEdit), m_count(new QSpinBox)
{
QFormLayout * l = new QFormLayout(this);
QPushButton * invoke = new QPushButton("Invoke");
m_edit->setReadOnly(true);
m_count->setRange(1, 1000);
l->addRow("Number of slot invocations", m_count);
l->addRow(invoke);
l->addRow(m_edit);
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
connect(invoke, &QPushButton::clicked, this, &Widget::sendSignals);
connect(&m_signaller, &Signaller::emptySignal, this, &Widget::emptySlot, Qt::QueuedConnection);
connect(&m_signaller, &Signaller::dataSignal, this, &Widget::dataSlot, Qt::QueuedConnection);
#else
connect(invoke, SIGNAL(clicked()), SLOT(sendSignals()));
connect(&m_signaller, SIGNAL(emptySignal()), SLOT(emptySlot()), Qt::QueuedConnection);
connect(&m_signaller, SIGNAL(dataSignal(int)), SLOT(dataSlot(int)), Qt::QueuedConnection);
#endif
}
};
int main(int argc, char *argv[])
{
CompressorApplication<QApplication> a(argc, argv);
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
a.addCompressedSignal(QMetaMethod::fromSignal(&Signaller::emptySignal));
a.addCompressedSignal(QMetaMethod::fromSignal(&Signaller::dataSignal));
#else
a.addCompressedSignal(Signaller::staticMetaObject.method(Signaller::staticMetaObject.indexOfSignal("emptySignal()")));
a.addCompressedSignal(Signaller::staticMetaObject.method(Signaller::staticMetaObject.indexOfSignal("dataSignal(int)")));
#endif
Widget w;
w.show();
return a.exec();
}
#include "main.moc"
