主线程可以一直存在的原因

最新推荐文章于 2024-09-22 20:21:37 发布
原创 最新推荐文章于 2024-09-22 20:21:37 发布 · 281 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

线程是一个动态执行的过程，从产生到死亡包括五个状态：新建、就绪、运行、死亡和堵塞。只要线程没有执行完毕或者没有被其它线程杀死，线程就不会进入死亡状态。Android中的主线程一直存在是因为主线程中一直在监听消息（通过死循环looper.loop一直获取消息），从而使线程无法被执行完毕。

问：这个死循环为什么不会导致,主线程阻塞或者几秒无响应发生ANR？
这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

简单一句说epoll机制：相比于select和poll每次线性扫描所有的socket，epoll只会对“活跃”的socket操作。

获取双异步返回值时，如何保证主线程不阻塞？
学Java，找哪吒
01-25 1624
CompletableFuture的异步执行通过ForkJoinPool实现，ForkJoinPool在于可以充分利用多核CPU的优势，把一个任务拆分成多个小任务，把多个小任务放到多个CPU上并行执行，当多个小任务执行完毕后，再将其执行结果合并起来。
【Android面试八股文】 Looper 为什么要使用死循环？Looper.loop会不会阻塞主线程?Looper无限循环的阻塞会不会导致主线程ANR？
字节卷动
06-27 997
一、 Looper 为什么要使用死循环？ 1.1 进程 1.2 线程 1.3 ActivityThread 1.4 总结 二、 Looper.loop会不会阻塞主线程？ 2.1 概述 2.2 nativePollOnce 2.3 `nativePollOnce` 的底层逻辑 2.4 Android中为什么主线程不会因为Looper.loop()里的死循环卡死？ 2.5 总结 三、Looper无限循环的阻塞会不会导致主线程ANR？ 3.1 ANR 3.1.1 什么是ANR 3.1.1 发生ANR的主要四种情况
【原创】一个线程oom，进程里其他线程还能运行吗？
weixin_30338461的博客
09-21 360
引言 这题是一个网友@大脸猫爱吃鱼给我的提问，出自今年校招美团三面的一个真题。大致如下 一个进程有3个线程，如果一个线程抛出oom，其他两个线程还能运行么? 先说一下答案，答案是还能运行 不瞒大家说，真在面试中，我遇到这一题，我估计也是答错。因为我初看到这一题，内心嘿嘿一笑，觉得这题是在考察JVM的内存结构。我第一反应是OOM的常见情况堆溢出，也就是下面的这种异常 java.lang.OutO...
运行最快的 PHP框架,Doophp 用过的最快的php框架
weixin_35910783的博客
04-08 393
前几天在http://www.lamppr.com上看到Doophp的介绍，传说是速度最快的php框架，于是google了一把，看了一下很多评论，貌似不错，来到Doophp的官网，稍微看了一下就把Framework给下载下来了，但是不知什么原因，API的包下载下来解压缩有问题，也许是操作系统原因吧。不过不碍事，马上动手搭建起来。先介绍一下文件夹结构，解压出来3个文件夹和4个TXT文件，TXT文件中...
Pandas DataFrame 使用技巧
DooDoo~的博客
04-13 721
Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。Pandas是Python的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。Pandas的目标是成为 Python数据分析实践与实战的必备高级工具，其长远目标是成为最强大、最灵活、可以支持任何语言的开源数据分析工具。经过多年不懈的努力，Pandas离这个目标已经越来越近了。
macOS 上好用的任务管理工具「Doo」
Cheers2020的博客
08-23 1415
无论是学习、工作还是生活，我们经常会在忙碌中不小心疏忽遗漏掉一些重要的事情。 这种情况下不得不借助一些工具的帮助，Mac 的原生备忘录、提醒事项应用都挺方便好用。 还有一些第三方软件的功能也更加多样强大，常见的如「滴答清单」「OmniFocus」「Things」等等。 本期Mac毒为大家推荐分享的是一款简约的任务管理工具「Doo」。 （ 颜狗表示 pick 它的原因之一是图标很好看） 应用介绍 为什么选择 Doo？ 盯着待办事项列表总是会感到焦虑。 迈出第一步往往是最难的事情...
3种谷歌多语言翻译接口的调用方法（Python）
DooDoo~的博客
08-11 4812
在日常的生活和工作中，我们经常会需要使用到翻译工具。在诸多翻译工具中，我个人更青睐谷歌翻译，因此在这里整理通过Python调用谷歌翻译接口的3种方式。
QT 子线程存在死循环时，主线程不能修改退出标志位
asdasfdgdhh的博客
03-29 2246
子线程： void close() //槽函数 { end = 1; } while(0 == end) { // do something } 主线程中发送信号触发close()，目的是为了改变end值，从而使while循环退出。 在实际操作中发现，主线程的信号发送了，但是槽函数不能触发，子线程一直阻塞在while中。 根本原因是：没有去接收信号 解决办法： #include <QApplication> void close() //槽函数 { end = 1; } while(0 =
c++主线程和子线程
热门推荐
魏圣颖的博客
01-29 1万+
c++主线程和子线程 最近在学习c++多线程，写一篇博客记录下自己的收获。 一.main()函数是主线程函数，在main()函数中创建的线程属于子线程，那主线程和子线程的优先级谁更高呢？ 可以看下另外一篇文档：link 在一个线程中开启另外一个新线程，则新开线程称为该线程的子线程，子线程初始优先级与父线程相同。不过主线程先启动占用了cpu资源，如果存在主线程和子线程争抢cpu执行权的话，看运气，谁...
鸿蒙NEXT开发【主线程耗时操作优化】性能分析
ADgai1987的博客
09-22 1021
在应用开发实践中，有效避免主线程执行冗余与易耗时操作是至关重要的策略。此举能有效降低主线程负载，提升UI的响应速度。面对高频回调接口在短时间内密集触发的场景，需要避免接口内的耗时操作，尽量保证主线程不被长时间占用，从而防止阻塞UI渲染，引发界面卡顿或掉帧现象。本文介绍开发过程中常见的冗余操作，常见的高频回调场景以及其他主线程优化思路。
从双曲几何到Gauss-Bonnet-Chern定理
Xmlbird的博客
05-11 4519
早在Gauss十五岁时，他就构想了一种几何，这种几何中Euclid几何中的第五公设不再成立，他把这个几何成为“星空几何”，或许他预计到这种几何在浩瀚星空中可能实现。   但是我们都知道，真正公开地、系统地提出这个几何的是Lobachevskii（有些英文文献是Lobachevsky，俄国人的名字再翻译成英文时可以有些小差别。）所以这种几何被称作“Lobachevskii几何（Lobache
线程运行状态
写写代码
02-19 799
线程是不太可能一直运行的，系统资源有限，多线程或多进程都必须在执行一段事件之后让出资源，交由其他线程继续执行。这是并发编程的本质。 这里有五种运行状态： 1、创建：定义好线程类对象，Thread实例 2、就绪：调用start()方法的时候线程不是立即执行，而是进入到一个等待状态，等待CPU进行调度。 3、执行：CPU执行调度到某个线程对象后，该线程对象开始执行run方法或call方法，但是...
debug时报anr错：Reason: Input dispatching timed out 解决办法
Azadoo的博客
12-02 5680
在排查问题对点击事件的监听debug时，突然遇到这种anr报错 大体意思是点击事件超过5s没有回应 系统报出anr错误并闪退，导致我无法debug查看问题。android Studio 输入下方命令行即可不闪退 正常debug操作。
为什么不能在子线程中直接更新ui
Azadoo的博客
04-03 4107
首先在子线程中是可以直接更新ui的 @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); init(); new Thread(new Runnable() { @Override public void run() {
Activity、view、window之间的关系
Azadoo的博客
04-17 3754
Activity是ui的框架 View是展示出来的视图 而view有多个 window主要是管理 View 的创建与删除，以及与 ViewRootImpl 的交互，将 Activity 与 View 解耦。 1,如何理解Activity，View，Window三者之间的关系？ 先来个算是比较恰当的比喻来形容下它们的关系吧。Activity像一个工匠（控制单元），Window像窗户（承载模型），View像窗花（显示视图）LayoutInflater像剪刀，Xml配置像窗花图纸。 1：Activity构造的时.
安卓四大组件之一——内容提供器ContentProvider
Azadoo的博客
11-12 2776
ContentProvider主要用于在不同的应用程序之间实现数据共享的功能 他提供了一套完整的机制 允许一个程序访问另一个程序中的数据 同时还能保证被访数据的安全性 目前 使用ContentProvider是安卓实现跨程序共享数据的标准方式 不同于前面说的文件存储这种全局可读写操作模式 ContentProvider可以选择只对哪一部分数据进行共享 从而保证我们程序中的隐藏数据不会有泄漏风险 运行时权限 ContentProvider会使用到运行时权限的功能 运行时权限是安卓6.0添加的功能 用于避免ap
android常用的锁 AtomicInteger lock
Azadoo的博客
04-17 2743
AtomicInteger是一种乐观锁——非阻塞同步 /** * Atomically increments by one the current value. * * @return the updated value */ public final int incrementAndGet() { for (;;) { int current = get(); int next = curren
Calling startActivity() from outside of an Activity context requires the FLAG_ACTIVITY_NEW_TASK
Azadoo的博客
01-12 2646
安卓跳转失败 查日志SchemeU 显示Calling startActivity() from outside of an Activity context requires the FLAG_ACTIVITY_NEW_TASK flag. 解决方法 1. 如果使用intent跳转 Context中有一个startActivity方法，Activity继承自Context，重载了startActivity方法。如果使用Activity的startActivity方法，不会有任何限制，而如果使用Conte
Glide使用 为布局（relativelayout）设置背景图的最新方法！
Azadoo的博客
04-13 2571
官方文档 配置 在AndroidManifest。xml中配置如下 <!--访问网络连接，可能产生GPRS流量 --> <uses-permission android:name="android.permission.INTERNET"/> <!--获取网络信息状态，如当前的网络连接是否有效 --> <uses-permission android:name="android.permission.ACCESS_NETWORK_S
子线程内部函数一直循环发送信号，怎么委托给主线程
最新发布
08-08
<think>我们面临的核心问题：在NX二次开发的DLL中，Qt子线程持续发送信号，需要确保这些信号的处理被委托给主线程（NX主线程）执行。 关键点： 1. 子线程发送的信号需要被主线程接收并处理。 2. 由于NX主线程可能没有运行Qt事件循环，我们需要确保事件循环存在。 3. 跨线程信号槽连接必须使用`Qt::QueuedConnection`（自动或显式指定），这样信号才会被放入主线程的事件队列中，由主线程的事件循环处理。 根据引用[1]和[3]中的示例，我们可以采用以下步骤： 步骤1：确保主线程有Qt事件循环 - 在DLL初始化时，检查是否有`QCoreApplication`实例，如果没有则创建一个（注意：不能在DllMain中创建，因为DllMain中不能进行复杂操作，建议在NX调用的入口函数中创建）。 - 如果主线程没有事件循环，我们可以创建一个`QEventLoop`来临时处理事件，但更好的做法是启动一个持续的事件循环（需考虑NX主线程的特性，避免阻塞NX操作）。 步骤2：使用正确的连接方式 - 在连接信号槽时，显式指定连接类型为`Qt::QueuedConnection`，这样即使子线程发送信号，槽函数会在信号接收者所在的线程（主线程）中执行。 步骤3：将接收者对象放置在主线程 - 接收信号的对象（例如包含槽函数的对象）必须在主线程中创建，这样它的槽函数才会在主线程中执行。 步骤4：在子线程中安全地发送信号 - 子线程中通过发射信号来通知主线程，不要直接调用主线程的对象方法。 具体实现方案： 1. 初始化Qt应用环境（在NX入口函数中）： ```cpp extern "C" DllExport void ufusr(char *param, int *retCode, int paramLen) { // 确保有QCoreApplication实例 if (!QCoreApplication::instance()) { static int argc = 1; static char *argv[] = {(char*)"NX_Qt_App"}; static QCoreApplication app(argc, argv); } // 其他初始化... } ``` 2. 创建接收者类（在主线程中创建）： ```cpp class SignalReceiver : public QObject { Q_OBJECT public slots: void handleSignal(int value) { // 这里处理信号，此函数将在主线程执行 // 注意：可以安全地更新UI（如果是在NX的UI线程中，但NX的UI不是Qt，所以不能直接操作，这里只是示例） qDebug() << "Received signal in main thread:" << value; } }; ``` 3. 在子线程中发送信号： ```cpp class WorkerThread : public QThread { Q_OBJECT public: void run() override { for (int i = 0; i < 100; i++) { emit progress(i); // 发送信号 msleep(100); } } signals: void progress(int value); }; ``` 4. 连接信号槽（使用`Qt::QueuedConnection`）： ```cpp // 在入口函数中 SignalReceiver receiver; // 在主线程中创建的对象 WorkerThread workerThread; // 连接信号和槽，显式指定连接方式 QObject::connect(&workerThread, &WorkerThread::progress, &receiver, &SignalReceiver::handleSignal, Qt::QueuedConnection); workerThread.start(); ``` 5. 事件循环处理： 由于NX的主线程不是Qt应用程序，我们创建了`QCoreApplication`实例，但需要确保事件循环运行。我们可以在入口函数中启动一个局部事件循环，等待子线程完成（或者根据需求调整）： ```cpp QEventLoop loop; // 当子线程结束时退出事件循环 QObject::connect(&workerThread, &WorkerThread::finished, &loop, &QEventLoop::quit); loop.exec(); // 进入事件循环，直到子线程结束 ``` 注意：如果子线程是持续运行的（比如循环发送信号而不结束），则不能使用上面的`loop.exec()`等待线程结束，因为这样会一直阻塞。在这种情况下，我们可以不等待，而是让事件循环在后台处理信号。但是，NX的入口函数不能长时间阻塞，否则会卡住NX。因此，我们需要考虑将事件循环放在单独的线程中运行，或者使用其他机制（如定时器）来定期处理事件。 替代方案：使用QTimer定期处理事件 如果NX主线程不允许长时间阻塞，我们可以在初始化后启动一个定时器，定期处理事件： ```cpp QTimer *timer = new QTimer; timer->start(100); // 每100毫秒处理一次事件 // 注意：这个定时器会定期唤醒事件循环，处理信号 ``` 但是，更常见的做法是在NX的回调中主动处理事件，例如在NX空闲时处理。然而，NX没有提供这样的机制。因此，我们可能需要创建一个单独的线程来运行Qt事件循环，但这会增加复杂性。 根据引用[4]中关于事件循环的说明，事件循环是处理事件分发的核心。因此，我们必须确保主线程有事件循环在运行。 考虑到NX二次开发的特殊性，建议如下： - 如果子线程是短时任务，使用`QEventLoop`临时事件循环等待完成。 - 如果是长时间运行的任务，且需要持续接收信号，则需要在NX的入口函数中启动一个定时器来定期处理事件（但要注意，定时器需要在主线程中启动，并且需要保持主线程不退出，而NX的入口函数会退出，所以不可行）。 因此，我们需要在DLL中创建一个全局的`QCoreApplication`（或`QApplication`）实例，并启动一个单独的线程来运行事件循环？这并不常见。 实际上，更好的做法是：在初始化时创建`QCoreApplication`，然后不阻塞入口函数，而是让事件循环在后台运行。但是，由于NX主线程不会运行Qt事件循环，我们需要在另一个线程中运行事件循环？这会导致接收者对象不能属于主线程（因为主线程没有事件循环），所以我们需要将接收者对象移动到事件循环线程。 但这样又回到了跨线程通信的问题。因此，我们重新考虑：将事件循环运行在主线程（NX线程）中，但使用非阻塞的方式。然而，NX主线程不能阻塞，所以我们不能调用`exec()`。 解决方案：使用`QEventLoop::processEvents()`定期处理事件。 在NX的某些回调中（例如菜单回调、按钮回调）中，我们可以定期调用`QCoreApplication::processEvents()`来处理积压的事件。 例如，在子线程运行期间，我们在主线程中定期处理事件： ```cpp workerThread.start(); while (workerThread.isRunning()) { QCoreApplication::processEvents(); // 处理事件 workerThread.msleep(100); // 避免忙等待 } ``` 但是，这种方法会阻塞入口函数，直到子线程完成。如果子线程是持续运行的（比如后台服务），则不适合。 因此，对于持续运行的子线程，我们只能： 1. 将接收者对象移动到子线程？不行，这样槽函数就在子线程执行了。 2. 使用`Qt::BlockingQueuedConnection`？这会阻塞子线程直到主线程处理完毕，但主线程如果没有及时处理事件，子线程就会阻塞，影响性能。 综合权衡，建议在NX二次开发中，子线程执行短时任务，然后使用临时事件循环等待。如果必须长时间运行，则考虑在子线程中执行计算，但将需要主线程处理的操作通过信号槽（使用`Qt::QueuedConnection`）发送，然后由主线程在空闲时处理（通过定期调用`QCoreApplication::processEvents()`）。但是，NX并没有提供一个空闲回调机制。 因此，我们可能需要一个折中方案：在NX的UI线程中，通过定时器回调（如果NX允许）来定期处理事件。但NX二次开发中，我们可以注册一个UF_UI_update_listener，在NX更新时调用，但这不是标准做法。 另一种思路：在DLL中创建一个隐藏的Qt窗口，然后进入事件循环，但这样会创建一个新的线程（窗口线程）。但这样又脱离了NX主线程。 鉴于上述复杂性，在NX二次开发中，如果必须长时间运行子线程并持续更新，建议采用以下方法： 1. 在DLL入口函数中创建`QCoreApplication`（如果还没有）。 2. 创建一个工作线程（WorkerThread）执行后台任务。 3. 创建一个接收者对象（在主线程中创建）。 4. 连接工作线程的信号到接收者对象的槽，使用`Qt::QueuedConnection`。 5. 启动工作线程。 6. 在入口函数返回前，启动一个定时器（单次定时器），定时器超时时调用`QCoreApplication::processEvents()`，然后再次启动定时器。这样，定时器会定期在主线程中处理事件。 定时器示例： ```cpp QTimer *timer = new QTimer; // 设置定时器每100毫秒触发一次 timer->setInterval(100); // 连接定时器的timeout信号，调用processEvents QObject::connect(timer, &QTimer::timeout, [](){ QCoreApplication::processEvents(); }); timer->start(); ``` 注意：这个定时器对象需要长期存在，所以可以设为静态对象或全局对象。 但是，这种方法会在NX主线程中定期处理事件，不会阻塞NX，但会增加CPU负担。需要根据实际需求调整定时器间隔。 完整代码示例（简略）： ```cpp #include <QCoreApplication> #include <QThread> #include <QTimer> #include <QDebug> // 接收者，在主线程中 class SignalReceiver : public QObject { Q_OBJECT public slots: void handleSignal(int value) { qDebug() << "Handle in main thread:" << value; // 注意：这里可以调用NX Open API，但必须确保在NX主线程中调用（因为NX API不是线程安全的） } }; // 工作线程 class WorkerThread : public QThread { Q_OBJECT void run() override { int i = 0; while (!isInterruptionRequested()) { emit progress(i++); msleep(100); } } signals: void progress(int value); }; static QTimer *s_timer = nullptr; extern "C" DllExport void ufusr(char *param, int *retCode, int paramLen) { // 初始化Qt if (!QCoreApplication::instance()) { static int argc = 1; static char *argv[] = {(char*)"NX_App"}; static QCoreApplication app(argc, argv); } // 创建定时器（仅一次） if (!s_timer) { s_timer = new QTimer; s_timer->setInterval(100); // 100毫秒 QObject::connect(s_timer, &QTimer::timeout, [](){ QCoreApplication::processEvents(); }); s_timer->start(); } // 创建接收者（主线程） static SignalReceiver receiver; // 静态确保长期存在 // 创建并启动工作线程 static WorkerThread workerThread; // 静态，避免在栈上被销毁 QObject::connect(&workerThread, &WorkerThread::progress, &receiver, &SignalReceiver::handleSignal, Qt::QueuedConnection); workerThread.start(); // 注意：这里不能阻塞，所以直接返回，工作线程在后台运行 } ``` 注意事项： - 定时器对象和接收者对象需要长期存在，所以使用静态对象。 - 工作线程也设为静态，避免在函数返回时被销毁（但要注意，下一次调用ufusr时，工作线程可能还在运行）。因此，需要设计停止线程的机制（例如在DLL卸载时停止线程）。 - 在DLL卸载时（DllMain的DLL_PROCESS_DETACH）停止线程和定时器。 停止线程： ```cpp // 在DllMain中 BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID reserved) { if (reason == DLL_PROCESS_DETACH) { if (workerThread.isRunning()) { workerThread.requestInterruption(); // 请求中断 workerThread.quit(); workerThread.wait(1000); // 等待1秒 } if (s_timer) { s_timer->stop(); delete s_timer; s_timer = nullptr; } } return TRUE; } ``` 但是，DllMain中不能做太多操作，特别是不能等待线程退出（可能导致死锁）。因此，建议在NX提供的退出回调中停止线程。 总结：在NX二次开发中，使用Qt多线程并跨线程传递信号需要谨慎处理事件循环。通过创建全局的Qt应用实例，使用定时器定期处理事件，并确保信号槽连接使用`Qt::QueuedConnection`，可以实现子线程信号委托给主线程处理。 相关问题： 1. 如何在NX二次开发中安全地停止后台线程？ 2. 使用定时器处理事件循环对性能有何影响？ 3. 在DLL中使用静态对象有哪些注意事项？ 4. 如何确保NX Open API在主线程中被调用？</think>### 在NX二次开发DLL中实现Qt子线程信号委托主线程处理的完整方案 在NX二次开发DLL中，子线程持续发送信号需要委托主线程处理的核心问题在于**跨线程通信**和**事件循环管理**。以下是详细解决方案： --- #### 核心原理 1. **信号槽机制**：Qt使用信号槽实现对象间通信，跨线程时需使用`Qt::QueuedConnection`确保线程安全[^1] 2. **事件循环**：主线程必须运行事件循环（`QEventLoop`）才能处理队列中的信号[^4] 3. **线程归属**：接收信号的对象必须属于主线程（通过`moveToThread()`实现） --- #### 解决方案步骤 ##### 1. 初始化Qt应用环境（关键） ```cpp extern "C" DllExport void ufusr(char *param, int *retCode, int paramLen) { // 确保Qt应用实例存在 if (!QCoreApplication::instance()) { static int argc = 1; static char *argv[] = {(char*)"NX_Qt_App"}; static QCoreApplication app(argc, argv); // 静态对象保证长期存在 } // 创建全局事件处理器（主线程） static EventProcessor processor; // 需继承QObject // 创建并启动子线程 static WorkerThread worker; worker.start(); } ``` ##### 2. 实现事件处理器（主线程对象） ```cpp class EventProcessor : public QObject { Q_OBJECT public slots: void handleSignal(int progress) { // 此槽函数在主线程执行 UF_UI_set_status("处理进度: " + QString::number(progress)); } }; ``` ##### 3. 实现工作线程（子线程） ```cpp class WorkerThread : public QThread { Q_OBJECT protected: void run() override { while (!isInterruptionRequested()) { // 持续发送信号 emit progressUpdate(calculateProgress()); msleep(100); // 控制发送频率 } } signals: void progressUpdate(int value); private: int calculateProgress() { /* 业务逻辑 */ } }; ``` ##### 4. 跨线程连接（关键配置） ```cpp // 在ufusr函数内添加连接 QObject::connect( &worker, &WorkerThread::progressUpdate, &processor, &EventProcessor::handleSignal, Qt::QueuedConnection // 确保信号进入主线程队列 ); ``` ##### 5. 事件循环管理（三种模式） ```cpp // 模式1：临时事件循环（适合短任务） QEventLoop loop; QObject::connect(&worker, &WorkerThread::finished, &loop, &QEventLoop::quit); loop.exec(); // 模式2：定时处理（适合长任务） QTimer* timer = new QTimer; timer->start(100); // 每100ms处理一次事件 QObject::connect(timer, &QTimer::timeout, []{ QCoreApplication::processEvents(); // 处理积压事件 }); // 模式3：NX空闲回调（推荐） UF_UI_add_update_listener(updateCallback); static int updateCallback(UF_UI_update_type_t type) { if (type == UF_UI_UPDATE_FREE) { QCoreApplication::processEvents(); } return UF_UI_CONTINUE_DIALOG; } ``` --- #### 关键注意事项 1. **对象生命周期**：使用`static`对象或智能指针避免DLL卸载时资源泄露 ```cpp static QSharedPointer<EventProcessor> processor(new EventProcessor); ``` 2. **线程安全**： - 禁止子线程直接操作NX API（通过信号委托主线程执行） - 使用`QMutex`保护共享数据 ```cpp // 子线程中访问共享数据 mutex.lock(); int value = sharedData; mutex.unlock(); ``` 3. **信号频率控制**： - 添加信号阈值过滤，避免事件队列溢出 ```cpp // 在WorkerThread中 if(abs(lastValue - newValue) > 5) { // 变化超过5%才发送 emit progressUpdate(newValue); lastValue = newValue; } ``` 4. **DLL卸载处理**： ```cpp BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID reserved) { if (reason == DLL_PROCESS_DETACH) { worker.requestInterruption(); worker.wait(1000); // 等待线程退出 } return TRUE; } ``` --- #### 完整架构示意图 ```mermaid graph TD A[子线程 WorkerThread] -->|Qt::QueuedConnection| B[信号队列] B --> C[主线程事件循环] C --> D[EventProcessor槽函数] D --> E[调用NX API] F[NX空闲回调] --> C ``` --- #### 性能优化建议 1. **信号批量处理**：累积多个进度值后发送数组信号 2. **内存管理**：使用`QSharedMemory`共享大数据 3. **线程池**：对密集型计算使用`QThreadPool` ```cpp QThreadPool::globalInstance()->start([]{ // 计算任务 }); ``` 4. **信号压缩**：使用`QSignalBlocker`或单次定时器合并信号 [^1]: 在Qt当中使用多线程基于类QThread，每一个QThread对象对应一个子线程[^1] [^2]: 主线程和子线程之间进行数据传递需要使用Qt中的信号槽机制[^2] [^3]: 跨线程连接必须使用`Qt::QueuedConnection`确保主线程执行槽函数[^3] [^4]: 事件循环用于从操作系统接收事件并将其分发给合适的对象进行处理[^4] --- ### 相关问题 1. 如何在NX二次开发中安全停止长时间运行的Qt子线程？ 2. 使用`Qt::BlockingQueuedConnection`与`Qt::QueuedConnection`有何性能差异？ 3. 当NX主线程阻塞时如何处理Qt事件队列积压？ 4. 在多DLL环境中如何避免Qt资源冲突？
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值