Qt源码阅读(一) 信号槽的连接与调用

信号槽连接


目录

• 信号槽连接
  
  
  
  • 1. 信号的连接
    
  • 2 槽的调用
    
  
  

信号槽的连接，其实内部本质还是一个回调函数，主要是维护了信号发送Object的元对象里一个连接的列表。调用connect函数时，将槽的一系列信息，封装成一个Connection，在发送信号时，通过这个列表，去回调槽函数。
1. 信号的连接

下面列举一种信号的连接方式，来大致讲解一下信号的连接过程。

1. //Connect a signal to a pointer to qobject member function
2.     // QtPrivate::FunctionPointer<Func1>::Object返回发送信号的对象类型
3.     template <typename Func1, typename Func2>
4.     static inline QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
5.                                      const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot,
6.                                      Qt::ConnectionType type = Qt::AutoConnection)
7.     {
8.         typedef QtPrivate::FunctionPointer<Func1> SignalType;
9.         typedef QtPrivate::FunctionPointer<Func2> SlotType;
11.         Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value,
12.                           "No Q_OBJECT in the class with the signal");
14.         //compilation error if the arguments does not match.
15.         // 检查信号和槽参数是否一致
16.         Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount),
17.                           "The slot requires more arguments than the signal provides.");
18.                 // 检查信号和槽参数是否兼容
19.         Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value),
20.                           "Signal and slot arguments are not compatible.");
21.                 // 检查信号和槽的返回值是否兼容
22.                 Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value),
23.                           "Return type of the slot is not compatible with the return type of the signal.");
25.         const int *types = nullptr;
26.                 // SignalType -> QtPrivate::FunctionPointer<Func1>
27.                 // QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types() 返回信号参数的值对应的元类型id列表
28.         if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
29.             types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
31.         return connectImpl(sender, reinterpret_cast<void **>(&signal),
32.                            receiver, reinterpret_cast<void **>(&slot),
33.                            new QtPrivate::QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
34.                                            typename SignalType::ReturnType>(slot),
35.                             type, types, &SignalType::Object::staticMetaObject);
36.     }

复制代码

上面主要都是一些基本的信号连接的判断，主要是：

• 信号和槽的参数数量
  
• 信号和槽的参数是否兼容
  
• 信号和槽的返回值是否兼容
  

然后获取信号参数所对应的元类型Id，再就到了一个信号连接的具体内部实现中

1. QMetaObject::Connection QObject::connectImpl(const QObject *sender, void **signal,
2.                                              const QObject *receiver, void **slot,
3.                                              QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type,
4.                                              const int *types, const QMetaObject *senderMetaObject)
5. {
6.     if (!signal) {
7.         qWarning("QObject::connect: invalid nullptr parameter");
8.         if (slotObj)
9.             slotObj->destroyIfLastRef();
10.         return QMetaObject::Connection();
11.     }
13.     int signal_index = -1;
14.     void *args[] = { &signal_index, signal };
15.         // 根据调用来判断是否存在信号，如果当前类没有就去父类中寻找
16.         // 直到找到信号或者是最基层的类
17.         // 找到信号的index和信号的对象
18.     for (; senderMetaObject && signal_index < 0; senderMetaObject = senderMetaObject->superClass()) {
19.         senderMetaObject->static_metacall(QMetaObject::IndexOfMethod, 0, args);
20.         if (signal_index >= 0 && signal_index < QMetaObjectPrivate::get(senderMetaObject)->signalCount)
21.             break;
22.     }
23.     if (!senderMetaObject) {
24.         qWarning("QObject::connect: signal not found in %s", sender->metaObject()->className());
25.         slotObj->destroyIfLastRef();
26.         return QMetaObject::Connection(nullptr);
27.     }
28.         // 信号下标
29.     signal_index += QMetaObjectPrivate::signalOffset(senderMetaObject);
30.     return QObjectPrivate::connectImpl(sender, signal_index, receiver, slot, slotObj, type, types, senderMetaObject);
31. }

复制代码

同样，我们对这个函数进行分析，第一个片段是对信号发送者是否为空指针的一个判断

1. if (!signal) {
2.     qWarning("QObject::connect: invalid nullptr parameter");
3.     if (slotObj)
4.         slotObj->destroyIfLastRef();
5.     return QMetaObject::Connection();
6. }

复制代码

第二个片段是去找到信号发送者(sender)的元对象类型(Meta Object)以及信号在对象信号中的位置。如果当前对象没有该信号，就去其父类对象去找。直到找到为止。

1. for (; senderMetaObject && signal_index < 0; senderMetaObject = senderMetaObject->superClass()) {
2.     senderMetaObject->static_metacall(QMetaObject::IndexOfMethod, 0, args);
3.     if (signal_index >= 0 && signal_index < QMetaObjectPrivate::get(senderMetaObject)->signalCount)
4.         break;
5. }

复制代码

然后就是进一步调用其内部实现：

1. QMetaObject::Connection QObjectPrivate::connectImpl(const QObject *sender, int signal_index,
2.                                              const QObject *receiver, void **slot,
3.                                              QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type,
4.                                              const int *types, const QMetaObject *senderMetaObject)
5. {
6.         // 发送对象、接收对象、槽函数对象、信号发送的元对象都不为空 2023-3-11
7.     if (!sender || !receiver || !slotObj || !senderMetaObject) {
8.                 // 任意一个为空，报错且清理空间，并返回
9.         const char *senderString = sender ? sender->metaObject()->className()
10.                                           : senderMetaObject ? senderMetaObject->className()
11.                                           : "Unknown";
12.         const char *receiverString = receiver ? receiver->metaObject()->className()
13.                                               : "Unknown";
14.         qWarning("QObject::connect(%s, %s): invalid nullptr parameter", senderString, receiverString);
15.         if (slotObj)
16.             slotObj->destroyIfLastRef();
17.         return QMetaObject::Connection();
18.     }
20.         // 去掉const的发送和接受对象
21.     QObject *s = const_cast<QObject *>(sender);
22.     QObject *r = const_cast<QObject *>(receiver);
24.         // 顺序锁，按照顺序依次去对mutex去上锁
25.         // 这里依次对发送和接收者的信号去上锁
26.     QOrderedMutexLocker locker(signalSlotLock(sender),
27.                                signalSlotLock(receiver));
29.     if (type & Qt::UniqueConnection && slot && QObjectPrivate::get(s)->connections.loadRelaxed()) {
30.                 // ObjectPrivate::get(s) 获取s对应的d指针
31.                 // connections 维护了所有的信号槽连接
32.         QObjectPrivate::ConnectionData *connections = QObjectPrivate::get(s)->connections.loadRelaxed();
33.         if (connections->signalVectorCount() > signal_index) {
34.                         // 获取信号的连接
35.             const QObjectPrivate::Connection *c2 = connections->signalVector.loadRelaxed()->at(signal_index).first.loadRelaxed();
37.                         // 循环遍历
38.             while (c2) {
39.                                 // 如果已经存在信号和槽的连接，且为uniqueConnection，则返回
40.                 if (c2->receiver.loadRelaxed() == receiver && c2->isSlotObject && c2->slotObj->compare(slot)) {
41.                     slotObj->destroyIfLastRef();
42.                     return QMetaObject::Connection();
43.                 }
44.                 c2 = c2->nextConnectionList.loadRelaxed();
45.             }
46.         }
47.                 // 将type与UniqueConnection进行异或，去掉UniqueConnection
48.         type = static_cast<Qt::ConnectionType>(type ^ Qt::UniqueConnection);
49.     }
51.         // 创建一个新的连接
52.     std::unique_ptr<QObjectPrivate::Connection> c{new QObjectPrivate::Connection};
53.     c->sender = s;
54.     c->signal_index = signal_index;
55.     QThreadData *td = r->d_func()->threadData;
56.     td->ref();
57.     c->receiverThreadData.storeRelaxed(td);
58.     c->receiver.storeRelaxed(r);
59.     c->slotObj = slotObj;
60.     c->connectionType = type;
61.     c->isSlotObject = true;
62.     if (types) {
63.         c->argumentTypes.storeRelaxed(types);
64.         c->ownArgumentTypes = false;
65.     }
67.         // 将新创建的连接加到连接列表中
68.     QObjectPrivate::get(s)->addConnection(signal_index, c.get());
69.     QMetaObject::Connection ret(c.release());
70.     locker.unlock();
72.     QMetaMethod method = QMetaObjectPrivate::signal(senderMetaObject, signal_index);
73.     Q_ASSERT(method.isValid());
74.     s->connectNotify(method);
76.     return ret;
77. }

复制代码

同样第一个部分也是对一些个空值的判断

1.         // 发送对象、接收对象、槽函数对象、信号发送的元对象都不为空 2023-3-11
2.     if (!sender || !receiver || !slotObj || !senderMetaObject) {
3.                 // 任意一个为空，报错且清理空间，并返回
4.         const char *senderString = sender ? sender->metaObject()->className()
5.                                           : senderMetaObject ? senderMetaObject->className()
6.                                           : "Unknown";
7.         const char *receiverString = receiver ? receiver->metaObject()->className()
8.                                               : "Unknown";
9.         qWarning("QObject::connect(%s, %s): invalid nullptr parameter", senderString, receiverString);
10.         if (slotObj)
11.             slotObj->destroyIfLastRef();
12.         return QMetaObject::Connection();
13.     }

复制代码

然后就是一个if判断，主要是对Qt::UniqueConnection连接的一些处理，获取当前对象的信号连接列表，并判断当前要连接的信号和槽，之前有没有被连接过，如果有过连接，就直接返回。

1. if (type & Qt::UniqueConnection && slot && QObjectPrivate::get(s)->connections.loadRelaxed()) {
2.                 // ObjectPrivate::get(s) 获取s对应的d指针
3.                 // connections 维护了所有的信号槽连接
4.         QObjectPrivate::ConnectionData *connections = QObjectPrivate::get(s)->connections.loadRelaxed();
5.         if (connections->signalVectorCount() > signal_index) {
6.                         // 获取信号的连接
7.             const QObjectPrivate::Connection *c2 = connections->signalVector.loadRelaxed()->at(signal_index).first.loadRelaxed();
9.                         // 循环遍历
10.             while (c2) {
11.                                 // 如果已经存在信号和槽的连接，且为uniqueConnection，则返回
12.                 if (c2->receiver.loadRelaxed() == receiver && c2->isSlotObject && c2->slotObj->compare(slot)) {
13.                     slotObj->destroyIfLastRef();
14.                     return QMetaObject::Connection();
15.                 }
16.                 c2 = c2->nextConnectionList.loadRelaxed();
17.             }
18.         }
19.                 // 将type与UniqueConnection进行异或，去掉UniqueConnection
20.         type = static_cast<Qt::ConnectionType>(type ^ Qt::UniqueConnection);
21.     }

复制代码

最后才是创建一个Connection并将连接的信息以及信号的参数设置进去，然后保存到对象的信号连接容器里。

1. // 创建一个新的连接
2.     std::unique_ptr<QObjectPrivate::Connection> c{new QObjectPrivate::Connection};
3.     c->sender = s;
4.     c->signal_index = signal_index;
5.     QThreadData *td = r->d_func()->threadData;
6.     td->ref();
7.     c->receiverThreadData.storeRelaxed(td);
8.     c->receiver.storeRelaxed(r);
9.     c->slotObj = slotObj;
10.     c->connectionType = type;
11.     c->isSlotObject = true;
12.     if (types) {
13.         c->argumentTypes.storeRelaxed(types);
14.         c->ownArgumentTypes = false;
15.     }
17.         // 将新创建的连接加到连接列表中
18.     QObjectPrivate::get(s)->addConnection(signal_index, c.get());
19.     QMetaObject::Connection ret(c.release());
20.     locker.unlock();
22.     QMetaMethod method = QMetaObjectPrivate::signal(senderMetaObject, signal_index);
23.     Q_ASSERT(method.isValid());
24.     s->connectNotify(method);
26.     return ret;

复制代码

2 槽的调用

定义一个信号，使用moc生成moc文件之后，我们可以看到信号函数的定义如下:

1. // SIGNAL 0
2. void MainWindow::sgnTestFor()
3. {
4.     QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
5. }

复制代码

我们发射一个信号的时候，我们会这样写：

1. emit sgnTestFor();

复制代码

我们可以看关于emit的定义：

其实emit关键字什么都没有做，只是标识了一下当前发射了信号。所以本质上，发射一个信号实际上就是直接调用了这个信号的函数，也就是调用了QMetaObject中的activate函数。
函数如下：

1. void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index,
2.                            void **argv)
3. {
4.     int signal_index = local_signal_index + QMetaObjectPrivate::signalOffset(m);
6.     if (Q_UNLIKELY(qt_signal_spy_callback_set.loadRelaxed()))
7.         doActivate<true>(sender, signal_index, argv);
8.     else
9.         doActivate<false>(sender, signal_index, argv);
10. }

复制代码

上面的qt_signal_spy_callback_set暂时不清楚是什么玩意，所以我们不管，直接看具体的doActive函数

1. template <bool callbacks_enabled>
2. void doActivate(QObject *sender, int signal_index, void **argv)
3. {
4.         // 首先获取QObject的private对象
5.     QObjectPrivate *sp = QObjectPrivate::get(sender);
7.         // 判断信号是否阻塞
8.     if (sp->blockSig)
9.         return;
11.     Q_TRACE_SCOPE(QMetaObject_activate, sender, signal_index);
13.     if (sp->isDeclarativeSignalConnected(signal_index)
14.             && QAbstractDeclarativeData::signalEmitted) {
15.         Q_TRACE_SCOPE(QMetaObject_activate_declarative_signal, sender, signal_index);
16.         QAbstractDeclarativeData::signalEmitted(sp->declarativeData, sender,
17.                                                 signal_index, argv);
18.     }
20.     const QSignalSpyCallbackSet *signal_spy_set = callbacks_enabled ? qt_signal_spy_callback_set.loadAcquire() : nullptr;
22.     void *empty_argv[] = { nullptr };
23.     if (!argv)
24.         argv = empty_argv;
26.     if (!sp->maybeSignalConnected(signal_index)) {
27.         // The possible declarative connection is done, and nothing else is connected
28.         if (callbacks_enabled && signal_spy_set->signal_begin_callback != nullptr)
29.             signal_spy_set->signal_begin_callback(sender, signal_index, argv);
30.         if (callbacks_enabled && signal_spy_set->signal_end_callback != nullptr)
31.             signal_spy_set->signal_end_callback(sender, signal_index);
32.         return;
33.     }
35.     if (callbacks_enabled && signal_spy_set->signal_begin_callback != nullptr)
36.         signal_spy_set->signal_begin_callback(sender, signal_index, argv);
38.     bool senderDeleted = false;
39.     {
40.     Q_ASSERT(sp->connections.loadAcquire());
41.     QObjectPrivate::ConnectionDataPointer connections(sp->connections.loadRelaxed());
42.     QObjectPrivate::SignalVector *signalVector = connections->signalVector.loadRelaxed();
44.         // 信号连接列表，因为一个信号可能连接了多个槽       
45.     const QObjectPrivate::ConnectionList *list;
46.     if (signal_index < signalVector->count())
47.         list = &signalVector->at(signal_index);
48.     else
49.         list = &signalVector->at(-1);
51.         // 判断当前线程是不是信号发送者的线程
52.     Qt::HANDLE currentThreadId = QThread::currentThreadId();
53.     bool inSenderThread = currentThreadId == QObjectPrivate::get(sender)->threadData.loadRelaxed()->threadId.loadRelaxed();
55.         //
56.     // We need to check against the highest connection id to ensure that signals added
57.     // during the signal emission are not emitted in this emission.
58.     uint highestConnectionId = connections->currentConnectionId.loadRelaxed();
59.         // 此处也就代表着，一个信号连接的多个槽函数，或者多个连接，会以连接的顺序被触发
60.     do {
61.         QObjectPrivate::Connection *c = list->first.loadRelaxed();
62.         if (!c)
63.             continue;
65.         do {
66.             QObject * const receiver = c->receiver.loadRelaxed();
67.             if (!receiver)
68.                 continue;
70.             QThreadData *td = c->receiverThreadData.loadRelaxed();
71.             if (!td)
72.                 continue;
74.             bool receiverInSameThread;
75.                         // 判断发送和接受是不是同一个线程
76.             if (inSenderThread) {
77.                 receiverInSameThread = currentThreadId == td->threadId.loadRelaxed();
78.             } else {
79.                 // need to lock before reading the threadId, because moveToThread() could interfere
80.                 QMutexLocker lock(signalSlotLock(receiver));
81.                 receiverInSameThread = currentThreadId == td->threadId.loadRelaxed();
82.             }
84.                         // 判断连接方式是否是队列连接，是队列连接就要丢入事件循环队列中处理
85.             // determine if this connection should be sent immediately or
86.             // put into the event queue
87.             if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
88.                 || (c->connectionType == Qt::QueuedConnection)) {
89.                 queued_activate(sender, signal_index, c, argv);
90.                 continue;
91. #if QT_CONFIG(thread)
92.             } else if (c->connectionType == Qt::BlockingQueuedConnection) {
93.                     // 如果发送对象和接受对象在一个线程，使用BlockingQueuedConnection会导致死锁
94.                 if (receiverInSameThread) {
95.                     qWarning("Qt: Dead lock detected while activating a BlockingQueuedConnection: "
96.                     "Sender is %s(%p), receiver is %s(%p)",
97.                     sender->metaObject()->className(), sender,
98.                     receiver->metaObject()->className(), receiver);
99.                 }
100.                 QSemaphore semaphore;
101.                 {
102.                     QBasicMutexLocker locker(signalSlotLock(sender));
103.                     if (!c->receiver.loadAcquire())
104.                         continue;
105.                     QMetaCallEvent *ev = c->isSlotObject ?
106.                         new QMetaCallEvent(c->slotObj, sender, signal_index, argv, &semaphore) :
107.                         new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction,
108.                                            sender, signal_index, argv, &semaphore);
109.                     QCoreApplication::postEvent(receiver, ev);
110.                 }
111.                                 // 阻塞直至函数执行完成
112.                 semaphore.acquire();
113.                 continue;
114. #endif
115.             }
116.                         // 下面是普通连接，
117.                         // 如果不在一个线程，并且使用直连，那么接收者就为空
118.             QObjectPrivate::Sender senderData(receiverInSameThread ? receiver : nullptr, sender, signal_index);
120.                         // 如果是槽函数对象
121.             if (c->isSlotObject) {
122.                 c->slotObj->ref();
124.                 struct Deleter {
125.                     void operator()(QtPrivate::QSlotObjectBase *slot) const {
126.                         if (slot) slot->destroyIfLastRef();
127.                     }
128.                 };
129.                 const std::unique_ptr<QtPrivate::QSlotObjectBase, Deleter> obj{c->slotObj};
131.                 {
132.                     Q_TRACE_SCOPE(QMetaObject_activate_slot_functor, obj.get());
133.                     obj->call(receiver, argv);
134.                 }
135.             } else if (c->callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) {
136.                 //we compare the vtable to make sure we are not in the destructor of the object.
137.                 const int method_relative = c->method_relative;
138.                 const auto callFunction = c->callFunction;
139.                 const int methodIndex = (Q_HAS_TRACEPOINTS || callbacks_enabled) ? c->method() : 0;
140.                 if (callbacks_enabled && signal_spy_set->slot_begin_callback != nullptr)
141.                     signal_spy_set->slot_begin_callback(receiver, methodIndex, argv);
143.                 {
144.                     Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, methodIndex);
145.                     callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv);
146.                 }
148.                 if (callbacks_enabled && signal_spy_set->slot_end_callback != nullptr)
149.                     signal_spy_set->slot_end_callback(receiver, methodIndex);
150.             } else {
151.                 const int method = c->method_relative + c->method_offset;
153.                 if (callbacks_enabled && signal_spy_set->slot_begin_callback != nullptr) {
154.                     signal_spy_set->slot_begin_callback(receiver, method, argv);
155.                 }
157.                 {
158.                     Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, method);
159.                     QMetaObject::metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
160.                 }
162.                 if (callbacks_enabled && signal_spy_set->slot_end_callback != nullptr)
163.                     signal_spy_set->slot_end_callback(receiver, method);
164.             }
165.                 // 此处while是循环遍历信号所连接的槽/信号
166.         } while ((c = c->nextConnectionList.loadRelaxed()) != nullptr && c->id <= highestConnectionId);
168.         // 循环两次
169.     } while (list != &signalVector->at(-1) &&
170.         //start over for all signals;
171.         ((list = &signalVector->at(-1)), true));
173.         if (connections->currentConnectionId.loadRelaxed() == 0)
174.             senderDeleted = true;
175.     }
176.     if (!senderDeleted) {
177.         sp->connections.loadRelaxed()->cleanOrphanedConnections(sender);
179.         if (callbacks_enabled && signal_spy_set->signal_end_callback != nullptr)
180.             signal_spy_set->signal_end_callback(sender, signal_index);
181.     }
182. }

复制代码

前面的一些基本的判断，我们就忽略，直接找到重要的地方，循环遍历信号所连接的部分。

• 当信号槽为队列连接，我们需要将信号丢到事件循环里，待事件循环将该信号发送出去。
  1. if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
  2.                 || (c->connectionType == Qt::QueuedConnection)) {
  3.                 queued_activate(sender, signal_index, c, argv);
  4.                 continue;
  5. #if QT_CONFIG(thread)
  6. }

  复制代码
• 当信号槽为阻塞队列连接(BlockingQueuedConnection)时，首先，我们需要判断发送和接收者是不是在一个线程，因为如果连接类型为BlockingQueuedConnection，发送者和接收者在一个线程，会导致死锁。
  1. else if (c->connectionType == Qt::BlockingQueuedConnection) {
  2.                     // 如果发送对象和接受对象在一个线程，使用BlockingQueuedConnection会导致死锁
  3.                 if (receiverInSameThread) {
  4.                     qWarning("Qt: Dead lock detected while activating a BlockingQueuedConnection: "
  5.                     "Sender is %s(%p), receiver is %s(%p)",
  6.                     sender->metaObject()->className(), sender,
  7.                     receiver->metaObject()->className(), receiver);
  8.                 }
  9.                 QSemaphore semaphore;
  10.                 {
  11.                     QBasicMutexLocker locker(signalSlotLock(sender));
  12.                     if (!c->receiver.loadAcquire())
  13.                         continue;
  14.                     QMetaCallEvent *ev = c->isSlotObject ?
  15.                         new QMetaCallEvent(c->slotObj, sender, signal_index, argv, &semaphore) :
  16.                         new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction,
  17.                                            sender, signal_index, argv, &semaphore);
  18.                     QCoreApplication::postEvent(receiver, ev);
  19.                 }
  20.                                 // 阻塞直至函数执行完成
  21.                 semaphore.acquire();
  22.                 continue;
  23. #endif
  24. }

  复制代码

其他类型的连接如下：

• 信号的连接是一个槽函数对象QSlotObject，就直接调用call函数
  1. if (c->isSlotObject) {
  2.                 c->slotObj->ref();
  4.                 struct Deleter {
  5.                     void operator()(QtPrivate::QSlotObjectBase *slot) const {
  6.                         if (slot) slot->destroyIfLastRef();
  7.                     }
  8.                 };
  9.                 const std::unique_ptr<QtPrivate::QSlotObjectBase, Deleter> obj{c->slotObj};
  11.                 {
  12.                     Q_TRACE_SCOPE(QMetaObject_activate_slot_functor, obj.get());
  13.                     obj->call(receiver, argv);
  14.                 }
  15.             }

  复制代码
• 如果是其他类型，就通过QMetaObject::InvokeMetaMethod来调用
  1. else if (c->callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) {
  2.                 //we compare the vtable to make sure we are not in the destructor of the object.
  3.                 const int method_relative = c->method_relative;
  4.                 const auto callFunction = c->callFunction;
  5.                 const int methodIndex = (Q_HAS_TRACEPOINTS || callbacks_enabled) ? c->method() : 0;
  6.                 if (callbacks_enabled && signal_spy_set->slot_begin_callback != nullptr)
  7.                     signal_spy_set->slot_begin_callback(receiver, methodIndex, argv);
  9.                 {
  10.                     Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, methodIndex);
  11.                     callFunction(receiver, QMetaObject::InvokeMetaMethod, method_relative, argv);
  12.                 }
  14.                 if (callbacks_enabled && signal_spy_set->slot_end_callback != nullptr)
  15.                     signal_spy_set->slot_end_callback(receiver, methodIndex);
  16.             } else {
  17.                 const int method = c->method_relative + c->method_offset;
  19.                 if (callbacks_enabled && signal_spy_set->slot_begin_callback != nullptr) {
  20.                     signal_spy_set->slot_begin_callback(receiver, method, argv);
  21.                 }
  23.                 {
  24.                     Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, method);
  25.                     QMetaObject::metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv);
  26.                 }
  28.                 if (callbacks_enabled && signal_spy_set->slot_end_callback != nullptr)
  29.                     signal_spy_set->slot_end_callback(receiver, method);
  30. }

  复制代码

并且遍历整个列表，将所有相关的连接都调用一遍。
然后我们看QueuedConnection的连接函数：
代码里，揭示了一点，就是如果我们使用信号槽连接的方式，而信号的参数不是一个元类型或者没用qRegisterMetaType来注册类型，那么队列连接是不行的，槽函数是不会触发的。

1. static void queued_activate(QObject *sender, int signal, QObjectPrivate::Connection *c, void **argv)
2. {
3.         // 存储元类型参数(meta-type argument)
4.     const int *argumentTypes = c->argumentTypes.loadRelaxed();
5.     if (!argumentTypes) {
6.                 // 获取对应的信号
7.         QMetaMethod m = QMetaObjectPrivate::signal(sender->metaObject(), signal);
8.                 // 获取信号的参数，并检查是否所有参数均为元类型(meta-type)
9.         argumentTypes = queuedConnectionTypes(m.parameterTypes());
10.         if (!argumentTypes) // cannot queue arguments
11.             argumentTypes = &DIRECT_CONNECTION_ONLY;
12.         if (!c->argumentTypes.testAndSetOrdered(nullptr, argumentTypes)) {
13.             if (argumentTypes != &DIRECT_CONNECTION_ONLY)
14.                 delete [] argumentTypes;
15.             argumentTypes = c->argumentTypes.loadRelaxed();
16.         }
17.     }
18.         // 参数不符合要求，返回
19.     if (argumentTypes == &DIRECT_CONNECTION_ONLY) // cannot activate
20.         return;
21.     int nargs = 1; // include return type
22.     while (argumentTypes[nargs-1])
23.         ++nargs;
25.     QBasicMutexLocker locker(signalSlotLock(c->receiver.loadRelaxed()));
26.     if (!c->receiver.loadRelaxed()) {
27.         // the connection has been disconnected before we got the lock
28.         return;
29.     }
30.     if (c->isSlotObject)
31.         c->slotObj->ref();
32.     locker.unlock();
34.         // 然后通过post一个QMetaCallEvent事件到事件循环队列中去
35.     QMetaCallEvent *ev = c->isSlotObject ?
36.         new QMetaCallEvent(c->slotObj, sender, signal, nargs) :
37.         new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, sender, signal, nargs);
39.     void **args = ev->args();
40.     int *types = ev->types();
42.     types[0] = 0; // return type
43.     args[0] = nullptr; // return value
45.     if (nargs > 1) {
46.         for (int n = 1; n < nargs; ++n)
47.             types[n] = argumentTypes[n-1];
49.         for (int n = 1; n < nargs; ++n)
50.             args[n] = QMetaType::create(types[n], argv[n]);
51.     }
53.     locker.relock();
54.     if (c->isSlotObject)
55.         c->slotObj->destroyIfLastRef();
56.     if (!c->receiver.loadRelaxed()) {
57.         // the connection has been disconnected while we were unlocked
58.         locker.unlock();
59.         delete ev;
60.         return;
61.     }
63.     QCoreApplication::postEvent(c->receiver.loadRelaxed(), ev);
64. }

复制代码

代码中我们可以看到，这里是通过post一个QMetaCallEvent的事件到事件循环中，然后由事件循环去触发槽函数的调用。
好了，对于信号和槽的分析，我们暂时就先分析到这，如果有问题是我上面没有说明的，可以在评论区给我评论，我看到了，看懂了，我就会更新这篇博客的。

谢谢观看
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！