2011-12-01 11:02:14 qimo601 阅读数 243
  • Qt Quick 4小时入门

    Qt Quick(QML)是Qt 5里推荐的UI开发框架,能够为各种设备搭建流畅且绚丽的用户界面。本课程删繁就简,精心选择主题,通过短短的几节课,即可让大家跨越Qt Quick的入门门槛,为进一步学习奠定坚实基础。

    48271 人正在学习 去看看 安晓辉

 

 

今天来看看Qt如何启动一个线程吧,代码就以精通Qt4编程的为例

先来给出每个文件的相关代码然后再加以分析

 

 

//*************dialog.h**************//

 
#ifndef DIALOG_H
#define DIALOG_H
#include <QDialog>
#define MAXSIZE 5  //最大的线程数
class QDialogButtonBox;
class QProgressBar;
class QPushButton;
class WorkThread;
class ThreadDlg : public QDialog
{
    Q_OBJECT
public:
    ThreadDlg(QWidget *parent = 0);
public slots:
		void start();   
		void stop();
private:
    QPushButton *startButton;
    QPushButton *quitButton;
    QPushButton *stopButton;
    QDialogButtonBox *buttonBox;
		WorkThread* threadVector[MAXSIZE];
};
#endif
//***********end end end************//

 

 

//***********mainwindow.h************//

 
#ifndef WORKTHREAD_H
#define WORKTHREAD_H
#include <QThread>
class WorkThread : public QThread
{
 protected:
     void run();   //重新实现run()函数
};
 
#endif
//***********end end end************//
 

 

 

//***********dialog.cpp************//

 
#include <QtGui>
#include "workThread.h"
#include "dialog.h"
	
ThreadDlg::ThreadDlg(QWidget *parent)     
    : QDialog(parent)
{
    startButton = new QPushButton(tr("开始"));
    quitButton = new QPushButton(tr("退出"));
		stopButton = new QPushButton(tr("停止"));
		stopButton->setEnabled(false);
    buttonBox = new QDialogButtonBox;
    buttonBox->addButton(startButton, QDialogButtonBox::ActionRole);
		buttonBox->addButton(stopButton, QDialogButtonBox::ActionRole);
    buttonBox->addButton(quitButton, QDialogButtonBox::RejectRole);
    connect(startButton, SIGNAL(clicked()), this, SLOT(start()));
    connect(quitButton, SIGNAL(clicked()), this, SLOT(close()));
    connect(stopButton, SIGNAL(clicked()), this, SLOT(stop()));
    QVBoxLayout *mainLayout = new QVBoxLayout;
    mainLayout->addWidget(buttonBox);
    setLayout(mainLayout);
    setWindowTitle(tr("启动线程"));
}
void ThreadDlg::start()
{
	for(int i=0;i<MAXSIZE;i++)
	{
		threadVector[i] = new WorkThread();   //创建线程
	}
	
		for(int i=0;i<MAXSIZE;i++)
	{
		threadVector[i]->start(QThread::LowestPriority);   //启动线程同时设置它的优先级,当然也可以不带,使用默认的优先级
	}
	stopButton->setEnabled(true);
	startButton->setEnabled(false);
}
void ThreadDlg::stop()
{
	for(int i=0;i<MAXSIZE;i++)
	{
		threadVector[i]->terminate();    //终止线程
		threadVector[i]->wait();    //阻塞等待
	}
	startButton->setEnabled(true);
	stopButton->setEnabled(false);
}
//***********end end end************//

 

 

//***********mainwindow.cpp************//

 
 
#include "workThread.h"
#include "dialog.h"
#include <QTextEdit>
#include <QDebug>
#include <stdio.h>
 void WorkThread::run()
 {
     while(true)
		 for (int n = 0; n < 10;++n) {
					printf("%d\n",n);  //打印输出
     }
 }
 
//***********end end end************//

//***********main.cpp************//

 
#include <QApplication>
#include <QtCore>
#include "dialog.h"
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
	QTextCodec::setCodecForTr( QTextCodec::codecForName("gb2312"));	
    ThreadDlg dialog;
    dialog.show();
    return dialog.exec();
}
//***********end end end************//

 

 

以上代码简单,没有必要做过多的讲解,但是其中的“threadVector[i]->terminate(); ”有必要讲解下,terminate()函数的调用便不会立刻终止线程,因为线程的何时终止取决于系统的调度策略,所在在之后又调用了wait()函数是线程阻塞等待直到退出或者超时。

最后加以一点就是在.pro文件中加入一行代码才能成功运行:

CONFIG+=thread

 

 

2019-06-05 17:46:42 zhanglong_4444 阅读数 506
  • Qt Quick 4小时入门

    Qt Quick(QML)是Qt 5里推荐的UI开发框架,能够为各种设备搭建流畅且绚丽的用户界面。本课程删繁就简,精心选择主题,通过短短的几节课,即可让大家跨越Qt Quick的入门门槛,为进一步学习奠定坚实基础。

    48271 人正在学习 去看看 安晓辉

确定优化目标

跟 CPU 和 I/O 方面的性能优化一样,优化前,我会先问问自己,网络性能优化的目标是什么?换句话说,我们观察到的网络性能指标,要达到多少才合适呢?

实际上,虽然网络性能优化的整体目标,是降低网络延迟(如 RTT)和提高吞吐量(如 BPS 和 PPS),但具体到不同应用中,每个指标的优化标准可能会不同,优先级顺序也大相径庭。

就拿上一节提到的 NAT 网关来说,由于其直接影响整个数据中心的网络出入性能,所以 NAT 网关通常需要达到或接近线性转发,也就是说, PPS 是最主要的性能目标。

再如,对于数据库、缓存等系统,快速完成网络收发,即低延迟,是主要的性能目标。

而对于我们经常访问的 Web 服务来说,则需要同时兼顾吞吐量和延迟。

所以,为了更客观合理地评估优化效果,我们首先应该明确优化的标准,即要对系统和应用程序进行基准测试,得到网络协议栈各层的基准性能。

在 怎么评估系统的网络性能 中,我已经介绍过,网络性能测试的方法。简单回顾一下,Linux 网络协议栈,是我们需要掌握的核心原理。它是基于 TCP/IP 协议族的分层结构,我用一张图来表示这个结构。

 

 

明白了这一点,在进行基准测试时,我们就可以按照协议栈的每一层来测试。由于底层是其上方各层的基础,底层性能也就决定了高层性能。所以我们要清楚,底层性能指标,其实就是对应高层的极限性能。我们从下到上来理解这一点。

首先是网络接口层和网络层,它们主要负责网络包的封装、寻址、路由,以及发送和接收。每秒可处理的网络包数 PPS,就是它们最重要的性能指标(特别是在小包的情况下)。你可以用内核自带的发包工具 pktgen ,来测试 PPS 的性能。

再向上到传输层的 TCP 和 UDP,它们主要负责网络传输。对它们而言,吞吐量(BPS)、连接数以及延迟,就是最重要的性能指标。你可以用 iperf 或 netperf ,来测试传输层的性能。

不过要注意,网络包的大小,会直接影响这些指标的值。所以,通常,你需要测试一系列不同大小网络包的性能。

最后,再往上到了应用层,最需要关注的是吞吐量(BPS)、每秒请求数以及延迟等指标。你可以用 wrk、ab 等工具,来测试应用程序的性能。

不过,这里要注意的是,测试场景要尽量模拟生产环境,这样的测试才更有价值。比如,你可以到生产环境中,录制实际的请求情况,再到测试中回放。

总之,根据这些基准指标,再结合已经观察到的性能瓶颈,我们就可以明确性能优化的目标。

 

网络性能工具

同前面学习一样,我建议从指标和工具两个不同维度出发,整理记忆网络相关的性能工具。

第一个维度,从网络性能指标出发,你更容易把性能工具同系统工作原理关联起来,对性能问题有宏观的认识和把握。这样,当你想查看某个性能指标时,就能清楚知道,可以用哪些工具。

这里,我把提供网络性能指标的工具,做成了一个表格,方便你梳理关系和理解记忆。你可以把它保存并打印出来,随时查看。当然,你也可以把它当成一个“指标工具”指南来使用。

再来看第二个维度,从性能工具出发。这可以让你更快上手使用工具,迅速找出想要观察的性能指标。特别是在工具有限的情况下,我们更要充分利用好手头的每一个工具,用少量工具也要尽力挖掘出大量信息。

同样的,我也将这些常用工具,汇总成了一个表格,方便你区分和理解。自然,你也可以当成一个“工具指标”指南使用,需要时查表即可。

网络性能优化

总的来说,先要获得网络基准测试报告,然后通过相关性能工具,定位出网络性能瓶颈。再接下来的优化工作,就是水到渠成的事情了。

当然,还是那句话,要优化网络性能,肯定离不开 Linux 系统的网络协议栈和网络收发流程的辅助。你可以结合下面这张图再回忆一下这部分的知识。

接下来,我们就可以从应用程序、套接字、传输层、网络层以及链路层等几个角度,分别来看网络性能优化的基本思路。

应用程序

应用程序,通常通过套接字接口进行网络操作。由于网络收发通常比较耗时,所以应用程序的优化,主要就是对网络 I/O 和进程自身的工作模型的优化。

相关内容,其实我们在 C10K 和 C1000K 回顾 的文章中已经学过了。这里我们简单回顾一下。

从网络 I/O 的角度来说,主要有下面两种优化思路。

第一种是最常用的 I/O 多路复用技术 epoll,主要用来取代 select 和 poll。这其实是解决 C10K 问题的关键,也是目前很多网络应用默认使用的机制。

第二种是使用异步 I/O(Asynchronous I/O,AIO)。AIO 允许应用程序同时发起很多 I/O 操作,而不用等待这些操作完成。等到 I/O 完成后,系统会用事件通知的方式,告诉应用程序结果。不过,AIO 的使用比较复杂,你需要小心处理很多边缘情况。

而从进程的工作模型来说,也有两种不同的模型用来优化。

第一种,主进程 + 多个 worker 子进程。其中,主进程负责管理网络连接,而子进程负责实际的业务处理。这也是最常用的一种模型。

第二种,监听到相同端口的多进程模型。在这种模型下,所有进程都会监听相同接口,并且开启 SO_REUSEPORT 选项,由内核负责,把请求负载均衡到这些监听进程中去。

除了网络 I/O 和进程的工作模型外,应用层的网络协议优化,也是至关重要的一点。我总结了常见的几种优化方法。

  • 使用长连接取代短连接,可以显著降低 TCP 建立连接的成本。在每秒请求次数较多时,这样做的效果非常明显。

  • 使用内存等方式,来缓存不常变化的数据,可以降低网络 I/O 次数,同时加快应用程序的响应速度。

  • 使用 Protocol Buffer 等序列化的方式,压缩网络 I/O 的数据量,可以提高应用程序的吞吐。

  • 使用 DNS 缓存、预取、HTTPDNS 等方式,减少 DNS 解析的延迟,也可以提升网络 I/O 的整体速度。

套接字

套接字可以屏蔽掉 Linux 内核中不同协议的差异,为应用程序提供统一的访问接口。每个套接字,都有一个读写缓冲区。

  • 读缓冲区,缓存了远端发过来的数据。如果读缓冲区已满,就不能再接收新的数据。

  • 写缓冲区,缓存了要发出去的数据。如果写缓冲区已满,应用程序的写操作就会被阻塞。

所以,为了提高网络的吞吐量,你通常需要调整这些缓冲区的大小。比如:

  • 增大每个套接字的缓冲区大小 net.core.optmem_max;

  • 增大套接字接收缓冲区大小 net.core.rmem_max 和发送缓冲区大小 net.core.wmem_max;

  • 增大 TCP 接收缓冲区大小 net.ipv4.tcp_rmem 和发送缓冲区大小 net.ipv4.tcp_wmem。

至于套接字的内核选项,我把它们整理成了一个表格,方便你在需要时参考:

不过有几点需要你注意。

  • tcp_rmem 和 tcp_wmem 的三个数值分别是 min,default,max,系统会根据这些设置,自动调整 TCP 接收 / 发送缓冲区的大小。

  • udp_mem 的三个数值分别是 min,pressure,max,系统会根据这些设置,自动调整 UDP 发送缓冲区的大小。

当然,表格中的数值只提供参考价值,具体应该设置多少,还需要你根据实际的网络状况来确定。比如,发送缓冲区大小,理想数值是吞吐量 * 延迟,这样才可以达到最大网络利用率。

除此之外,套接字接口还提供了一些配置选项,用来修改网络连接的行为:

  • 为 TCP 连接设置 TCP_NODELAY 后,就可以禁用 Nagle 算法;

  • 为 TCP 连接开启 TCP_CORK 后,可以让小包聚合成大包后再发送(注意会阻塞小包的发送);

  • 使用 SO_SNDBUF 和 SO_RCVBUF ,可以分别调整套接字发送缓冲区和接收缓冲区的大小。

网络性能优化

传输层

传输层最重要的是 TCP 和 UDP 协议,所以这儿的优化,其实主要就是对这两种协议的优化。

我们首先来看 TCP 协议的优化。

TCP 提供了面向连接的可靠传输服务。要优化 TCP,我们首先要掌握 TCP 协议的基本原理,比如流量控制、慢启动、拥塞避免、延迟确认以及状态流图(如下图所示)等。

 

关于这些原理的细节,我就不再展开讲解了。如果你还没有完全掌握,建议你先学完这些基本原理后再来优化,而不是囫囵吞枣地乱抄乱试。

掌握这些原理后,你就可以在不破坏 TCP 正常工作的基础上,对它进行优化。下面,我分几类情况详细说明。

第一类,在请求数比较大的场景下,你可能会看到大量处于 TIME_WAIT 状态的连接,它们会占用大量内存和端口资源。这时,我们可以优化与 TIME_WAIT 状态相关的内核选项,比如采取下面几种措施。

 

  • 增大处于 TIME_WAIT 状态的连接数量 net.ipv4.tcp_max_tw_buckets ,并增大连接跟踪表的大小 net.netfilter.nf_conntrack_max。

  • 减小 net.ipv4.tcp_fin_timeout 和 net.netfilter.nf_conntrack_tcp_timeout_time_wait ,让系统尽快释放它们所占用的资源。

  • 开启端口复用 net.ipv4.tcp_tw_reuse。这样,被 TIME_WAIT 状态占用的端口,还能用到新建的连接中。

  • 增大本地端口的范围 net.ipv4.ip_local_port_range 。这样就可以支持更多连接,提高整体的并发能力。

  • 增加最大文件描述符的数量。你可以使用 fs.nr_open 和 fs.file-max ,分别增大进程和系统的最大文件描述符数;或在应用程序的 systemd 配置文件中,配置 LimitNOFILE ,设置应用程序的最大文件描述符数。

 

第二类,为了缓解 SYN FLOOD 等,利用 TCP 协议特点进行攻击而引发的性能问题,你可以考虑优化与 SYN 状态相关的内核选项,比如采取下面几种措施。

  • 增大 TCP 半连接的最大数量 net.ipv4.tcp_max_syn_backlog ,或者开启 TCP SYN Cookies net.ipv4.tcp_syncookies ,来绕开半连接数量限制的问题(注意,这两个选项不可同时使用)。

  • 减少 SYN_RECV 状态的连接重传 SYN+ACK 包的次数 net.ipv4.tcp_synack_retries。

第三类,在长连接的场景中,通常使用 Keepalive 来检测 TCP 连接的状态,以便对端连接断开后,可以自动回收。但是,系统默认的 Keepalive 探测间隔和重试次数,一般都无法满足应用程序的性能要求。所以,这时候你需要优化与 Keepalive 相关的内核选项,比如:

  • 缩短最后一次数据包到 Keepalive 探测包的间隔时间 net.ipv4.tcp_keepalive_time;

  • 缩短发送 Keepalive 探测包的间隔时间 net.ipv4.tcp_keepalive_intvl;

  • 减少 Keepalive 探测失败后,一直到通知应用程序前的重试次数 net.ipv4.tcp_keepalive_probes。

讲了这么多 TCP 优化方法,我也把它们整理成了一个表格,方便你在需要时参考(数值仅供参考,具体配置还要结合你的实际场景来调整):

 

优化 TCP 性能时,你还要注意,如果同时使用不同优化方法,可能会产生冲突。

比如,就像网络请求延迟的案例中我们曾经分析过的,服务器端开启 Nagle 算法,而客户端开启延迟确认机制,就很容易导致网络延迟增大。

另外,在使用 NAT 的服务器上,如果开启 net.ipv4.tcp_tw_recycle ,就很容易导致各种连接失败。实际上,由于坑太多,这个选项在内核的 4.1 版本中已经删除了。

说完 TCP,我们再来看 UDP 的优化。

UDP 提供了面向数据报的网络协议,它不需要网络连接,也不提供可靠性保障。所以,UDP 优化,相对于 TCP 来说,要简单得多。这里我也总结了常见的几种优化方案。

  • 跟上篇套接字部分提到的一样,增大套接字缓冲区大小以及 UDP 缓冲区范围;

  • 跟前面 TCP 部分提到的一样,增大本地端口号的范围;

  • 根据 MTU 大小,调整 UDP 数据包的大小,减少或者避免分片的发生。

网络层

接下来,我们再来看网络层的优化。

网络层,负责网络包的封装、寻址和路由,包括 IP、ICMP 等常见协议。在网络层,最主要的优化,其实就是对路由、 IP 分片以及 ICMP 等进行调优。

第一种,从路由和转发的角度出发,你可以调整下面的内核选项。

  • 在需要转发的服务器中,比如用作 NAT 网关的服务器或者使用 Docker 容器时,开启 IP 转发,即设置 net.ipv4.ip_forward = 1。

  • 调整数据包的生存周期 TTL,比如设置 net.ipv4.ip_default_ttl = 64。注意,增大该值会降低系统性能。

  • 开启数据包的反向地址校验,比如设置 net.ipv4.conf.eth0.rp_filter = 1。这样可以防止 IP 欺骗,并减少伪造 IP 带来的 DDoS 问题。

第二种,从分片的角度出发,最主要的是调整 MTU(Maximum Transmission Unit)的大小。

通常,MTU 的大小应该根据以太网的标准来设置。以太网标准规定,一个网络帧最大为 1518B,那么去掉以太网头部的 18B 后,剩余的 1500 就是以太网 MTU 的大小。

在使用 VXLAN、GRE 等叠加网络技术时,要注意,网络叠加会使原来的网络包变大,导致 MTU 也需要调整。

比如,就以 VXLAN 为例,它在原来报文的基础上,增加了 14B 的以太网头部、 8B 的 VXLAN 头部、8B 的 UDP 头部以及 20B 的 IP 头部。换句话说,每个包比原来增大了 50B。

所以,我们就需要把交换机、路由器等的 MTU,增大到 1550, 或者把 VXLAN 封包前(比如虚拟化环境中的虚拟网卡)的 MTU 减小为 1450。

另外,现在很多网络设备都支持巨帧,如果是这种环境,你还可以把 MTU 调大为 9000,以提高网络吞吐量。

第三种,从 ICMP 的角度出发,为了避免 ICMP 主机探测、ICMP Flood 等各种网络问题,你可以通过内核选项,来限制 ICMP 的行为。

  • 比如,你可以禁止 ICMP 协议,即设置 net.ipv4.icmp_echo_ignore_all = 1。这样,外部主机就无法通过 ICMP 来探测主机。

  • 或者,你还可以禁止广播 ICMP,即设置 net.ipv4.icmp_echo_ignore_broadcasts = 1。

链路层

网络层的下面是链路层,所以最后,我们再来看链路层的优化方法。

链路层负责网络包在物理网络中的传输,比如 MAC 寻址、错误侦测以及通过网卡传输网络帧等。自然,链路层的优化,也是围绕这些基本功能进行的。接下来,我们从不同的几个方面分别来看。

由于网卡收包后调用的中断处理程序(特别是软中断),需要消耗大量的 CPU。所以,将这些中断处理程序调度到不同的 CPU 上执行,就可以显著提高网络吞吐量。这通常可以采用下面两种方法。

  • 比如,你可以为网卡硬中断配置 CPU 亲和性(smp_affinity),或者开启 irqbalance 服务。

  • 再如,你可以开启 RPS(Receive Packet Steering)和 RFS(Receive Flow Steering),将应用程序和软中断的处理,调度到相同 CPU 上,这样就可以增加 CPU 缓存命中率,减少网络延迟。

另外,现在的网卡都有很丰富的功能,原来在内核中通过软件处理的功能,可以卸载到网卡中,通过硬件来执行。

  • TSO(TCP Segmentation Offload)和 UFO(UDP Fragmentation Offload):在 TCP/UDP 协议中直接发送大包;而 TCP 包的分段(按照 MSS 分段)和 UDP 的分片(按照 MTU 分片)功能,由网卡来完成 。

  • GSO(Generic Segmentation Offload):在网卡不支持 TSO/UFO 时,将 TCP/UDP 包的分段,延迟到进入网卡前再执行。这样,不仅可以减少 CPU 的消耗,还可以在发生丢包时只重传分段后的包。

  • LRO(Large Receive Offload):在接收 TCP 分段包时,由网卡将其组装合并后,再交给上层网络处理。不过要注意,在需要 IP 转发的情况下,不能开启 LRO,因为如果多个包的头部信息不一致,LRO 合并会导致网络包的校验错误。

  • GRO(Generic Receive Offload):GRO 修复了 LRO 的缺陷,并且更为通用,同时支持 TCP 和 UDP。

  • RSS(Receive Side Scaling):也称为多队列接收,它基于硬件的多个接收队列,来分配网络接收进程,这样可以让多个 CPU 来处理接收到的网络包。

  • VXLAN 卸载:也就是让网卡来完成 VXLAN 的组包功能。

最后,对于网络接口本身,也有很多方法,可以优化网络的吞吐量。

  • 比如,你可以开启网络接口的多队列功能。这样,每个队列就可以用不同的中断号,调度到不同 CPU 上执行,从而提升网络的吞吐量。

  • 再如,你可以增大网络接口的缓冲区大小,以及队列长度等,提升网络传输的吞吐量(注意,这可能导致延迟增大)。

  • 你还可以使用 Traffic Control 工具,为不同网络流量配置 QoS。

  • 到这里,我就从应用程序、套接字、传输层、网络层,再到链路层,分别介绍了相应的网络性能优化方法。通过这些方法的优化后,网络性能就可以满足绝大部分场景了。

    最后,别忘了一种极限场景。还记得我们学过的的 C10M 问题吗?

    在单机并发 1000 万的场景中,对 Linux 网络协议栈进行的各种优化策略,基本都没有太大效果。因为这种情况下,网络协议栈的冗长流程,其实才是最主要的性能负担。

    这时,我们可以用两种方式来优化。

    第一种,使用 DPDK 技术,跳过内核协议栈,直接由用户态进程用轮询的方式,来处理网络请求。同时,再结合大页、CPU 绑定、内存对齐、流水线并发等多种机制,优化网络包的处理效率。

      第二种,使用内核自带的 XDP 技术,在网络包进入内核协议栈前,就对其进行处理,这样也可以实现很好的性能。

 

小结

这两节课,我们一起梳理了常见的 Linux 网络性能优化方法。

在优化网络的性能时,我们可以结合 Linux 系统的网络协议栈和网络收发流程,从应用程序、套接字、传输层、网络层再到链路层等,对每个层次进行逐层优化。

实际上,我们分析和定位网络瓶颈,也是基于这些网络层进行的。而定位出网络性能瓶颈后,我们就可以根据瓶颈所在的协议层,进行优化。具体而言:

  • 在应用程序中,主要是优化 I/O 模型、工作模型以及应用层的网络协议;

  • 在套接字层中,主要是优化套接字的缓冲区大小;

  • 在传输层中,主要是优化 TCP 和 UDP 协议;

  • 在网络层中,主要是优化路由、转发、分片以及 ICMP 协议;

  • 最后,在链路层中,主要是优化网络包的收发、网络功能卸载以及网卡选项。

如果这些方法依然不能满足你的要求,那就可以考虑,使用 DPDK 等用户态方式,绕过内核协议栈;或者,使用 XDP,在网络包进入内核协议栈前进行处理。

 

小结

今天,我们一起梳理了常见的 Linux 网络性能优化方法。

在优化网络性能时,你可以结合 Linux 系统的网络协议栈和网络收发流程,然后从应用程序、套接字、传输层、网络层再到链路层等,进行逐层优化。

当然,其实我们分析、定位网络瓶颈,也是基于这些进行的。定位出性能瓶颈后,就可以根据瓶颈所在的协议层进行优化。比如,今天我们学了应用程序和套接字的优化思路:

  • 在应用程序中,主要优化 I/O 模型、工作模型以及应用层的网络协议;

  • 在套接字层中,主要优化套接字的缓冲区大小。

 

 


 

来源: Linux性能优化实战   倪朋飞

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2011-10-30 21:14:01 moyumoyu 阅读数 690
  • Qt Quick 4小时入门

    Qt Quick(QML)是Qt 5里推荐的UI开发框架,能够为各种设备搭建流畅且绚丽的用户界面。本课程删繁就简,精心选择主题,通过短短的几节课,即可让大家跨越Qt Quick的入门门槛,为进一步学习奠定坚实基础。

    48271 人正在学习 去看看 安晓辉
 

同css 相似,qss的主要功能与最终目的都是能使界面的表现与界面的元素分离,即质与形的分离,就如同一个人可以在不同的时候穿上不同的衣服一样。

AD:


三、级联效应

子类可以继承父类的StyleSheet,但是如果子类里面设置了StyleSheet与父类里在设置的有冲突,那么当然会优先考虑子类自己的,

同样,如果在qApp时面设置了,但是在某一个特定控件里面也设置,如果有冲突,也是优先控件自己的,例如,我在程序时面设置了:btnOneEn->setStyleSheet("QPushButton { color: red }");

而,当我再设置qApp时,如果,将QPushButton的color设置成grey的,那么结果是对于btnOneEn这个QPushButton来说他的颜色还是red。

这就是为什么这里设置为grey了btnOneEn却还是red的。

如果我们对一个控件设置StyleSheet为:

  1. QPushButton* myPushButton;  
  2. myPushButton->setStyleSheet("*{ color: blue }"); 

其实他和设置为:myPushButton->setStyleSheet("color: blue");

效果相同,只是后一种设置不会对QPushButton的子类产生作用,但第一种却会。

四、继承性

与CSS不同的一点,在CSS box模型中,如果一个元素在别一元素的里面,那么里面的元素会自动继承外面元素的属性,但QSS里面不会,如:

一个QPushButton如果放在一个QGroupBox里面,如果:qApp->setStyleSheet("QGroupBox{ color: red; }");

并不代表在QGroupBox里面的QPushButton也会有color:red的属性,如果要想有的话要显示写明,如:qApp->setStyleSheet("QGroupBox, QGroupBox*{ color: red; }");

或者在应用程序里面也可以用QWidget::setFont等来设置到子控件的属性。

五、Namespace冲突

类型选择器能够使用到一个特定的类型,如:

  1. class MyPushButton : public QPushButton {  
  2.       //...  
  3. }  
  4. qApp->setStyleSheet("MyPushButton { background: yellow; }"); 

因为QSS使用QObject::className来判断要赋与style sheet的控件类型,如果一个用户定义控件类型在一个namespace里面的话,QObject::className会返回<namespace>::<classname> 的名字,这和子控件选择器的语法相冲突,为了解决此问题,使用“--”来代替“::”,比如:

  1. namespace ns {  
  2.       class MyPushButton : public QPushButton {  
  3.           //...  
  4.       }  
  5. }  
  6. qApp->setSytleSheet("ns--MyPushButton { background: yellow; }"); 

六、设置对像属性

如果在程序里面使用Q_PROPERTY设置的属性,可以在qss里面使用:qproperty-<property name>的形式来访问并设置值。如:

  1. MyLabel { qproperty-pixmap: url(pixmap.png); }  
  2. MyGroupBox{ qproperty-titleColor: rgb(100, 200, 100); }  
  3. QPushButton { qproperty-iconSize: 20px 20px; } 

如果属性引用到的是一个由Q_ENUMS申明的enum 时,要引用其属性名字要用定义的名称而不是数字。

小结:详解 QT 皮肤QSS编程的内容介绍完了,希望本篇文章对你有所帮助。

【编辑推荐】

Qt 线程
2018-03-02 17:18:22 xuxunjie147 阅读数 256
  • Qt Quick 4小时入门

    Qt Quick(QML)是Qt 5里推荐的UI开发框架,能够为各种设备搭建流畅且绚丽的用户界面。本课程删繁就简,精心选择主题,通过短短的几节课,即可让大家跨越Qt Quick的入门门槛,为进一步学习奠定坚实基础。

    48271 人正在学习 去看看 安晓辉

一、线程管理
1、线程启动

void start(Priority priority = InheritPriority)

调用后会执行run()函数,但在run()函数执行前会发射信号started(),操作系统将根据优先级参数调度线程。如果线程已经在运行,那么这个函数什么也不做。优先级参数的效果取决于操作系统的调度策略。特别是那些不支持线程优先级的系统优先级将会被忽略(例如在Linux中,更多细节请参考http://linux.die.net/man/2/sched_setscheduler)。

2、线程执行

int exec()

进入事件循环并等待直到调用exit(),返回值是通过调用exit()来获得,如果调用成功则范围0。

virtual void run();

线程的起点,在调用start()之后,新创建的线程就会调用这个函数,默认实现调用exec(),大多数需要重新实现这个功能,便于管理自己的线程。该方法返回时,该线程的执行将结束。

3、线程退出

void quit()

告诉线程事件循环退出,返回0表示成功,相当于调用了QThread::exit(0)。

void exit(int returnCode = 0)

告诉线程事件循环退出。

调用这个函数后,线程离开事件循环后返回,QEventLoop::exec()返回returnCode,

按照惯例0表示成功,任何非0值表示失败。

void terminate()

终止线程,线程可能会立即被终止也可能不会,这取决于操作系统的调度策略,使用terminate()之后再使用QThread::wait()确保万无一失。

当线程被终止后,所有等待中的线程将会被唤醒。

警告:此功能比较危险,不鼓励使用。线程可以在代码执行的任何点被终止。线程可能在更新数据时被终止,从而没有机会来清理自己,解锁等等。。。总之,只有在绝对必要时使用此功能。

建议:一般情况下,都在run函数里面设置一个标识符,可以控制循环停止。然后才调用quit函数,退出线程。

4、线程等待

void msleep(unsigned long msecs)

强制当前线程睡眠msecs毫秒

void sleep(unsigned long secs)

强制当前线程睡眠secs秒

void usleep(unsigned long usecs)

强制当前线程睡眠usecs微秒

bool wait(unsigned long time = ULONG_MAX);

线程将会被阻塞,等待time毫秒。和sleep不同的是,如果线程退出,wait会返回。

5、线程状态

bool isFinished() const    

线程是否结束

bool isRunning() const    
线程是否正在运行

6、线程优先级

void setPriority(Priority priority)
这个函数设置正在运行线程的优先级。如果线程没有运行,此功能不执行任何操作并立即返回。使用的start()来启动一个线程具有特定的优先级。
优先级参数可以是QThread::Priority枚举除InheritPriortyd的任何值。
Priority priority() const
下面来看下优先级中的各个枚举值:

Constant

Value

Description

QThread::IdlePriority

0

没有其它线程运行时才调度.

QThread::LowestPriority

1

比LowPriority调度频率低.

QThread::LowPriority

2

比NormalPriority调度频率低.

QThread::NormalPriority

3

操作系统默认的默认优先级.

QThread::HighPriority

4

比NormalPriority调度频繁.

QThread::HighestPriority

5

比HighPriority调度频繁.

QThread::TimeCriticalPriority

6

尽可能频繁的调度.

QThread::InheritPriority

7

使用和创建线程同样的优先级. 这是默认值.

二、主线程、次线程
在Qt之线程(QThread)一节中我介绍了QThread 的两种使用方法:

1、子类化 QThread(不使用事件循环)。

这是官方手册、例子以及相关书籍中都介绍的一种常用的方法。

a. 子类化 QThread

b. 重载 run 函数,run函数内有一个while或for的死循环(模拟耗时操作)

c. 设置一个标记为来控制死循环的退出。

2、子类化 QObject

a. 子类化 QObject

b. 定义槽函数

c. 将该子类的对象moveToThread到新线程中

run 对于线程的作用相当于main函数对于应用程序。它是线程的入口,run的开始和结束意味着线程的开始和结束。

采用这两种做法,毫无疑问都会在次线程中运行(这里说的是,run中的逻辑以及子类化QObject后连接通过moveToThread然后连接到QThread的started()信号的槽函数,这个下面会详细讲解)。

那么,线程中的槽函数是怎么运行的呢?

说到信号与槽,大家应该再熟悉不过了,包括我,特别喜欢使用自定义信号与槽,感觉用起来特方便、特棒。。。

经常使用,你能否100%的使用正确?你了解它的高级用法吗?

1、你是否在多次connect,还发现不了为什么槽函数会执行那N多次。

2、你是否了解disconnect

3、你是否了解connect中的第五个参数 Qt::ConnectionType

关于connect、disconnect信号、槽的使用可参考:Qt之信号与槽。既然谈到线程这里需要重点说下Qt::ConnectionType(信号与槽的传递方式)

Constant

Value

Description

Qt::AutoConnection

0

自动连接:(默认值)如果信号在接收者所依附的线程内发射,则等同于直接连接。如果发射信号的线程和接受者所依附的线程不同,则等同于队列连接。

Qt::DirectConnection

1

直接连接:当信号发射时,槽函数将直接被调用。无论槽函数所属对象在哪个线程,槽函数都在发射信号的线程内执行。

Qt::QueuedConnection

2

队列连接:当控制权回到接受者所依附线程的事件循环时,槽函数被调用。槽函数在接收者所依附线程执行。也就是说:这种方式既可以在线程内传递消息,也可以跨线程传递消息

Qt::BlockingQueuedConnection

3

与Qt::QueuedConnection类似,但是会阻塞等到关联的slot都被执行。这里出现了阻塞这个词,说明它是专门用来多线程间传递消息的。

举例:

MyObject.h

ifndef MYOBJECT_H

define MYOBJECT_H

include

class MyObject : public QObject
{
Q_OBJECT

public:
explicit MyObject(QObject *parent = 0);

public slots:
void start();
};

endif // MYOBJECT_H

MyObject.cpp

include “MyObject.h”

include

include

MyObject::MyObject(QObject *parent)
: QObject(parent)
{

}

void MyObject::start()
{
qDebug() << QString(“my object thread id:”) << QThread::currentThreadId();
}
main.cpp

include “MyObject.h”

include

include

include

int main(int argc, char *argv[])
{
QApplication a(argc, argv);

qDebug() << QString("main thread id:") << QThread::currentThreadId();

MyObject object;
QThread thread;
object.moveToThread(&thread);
QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()));
thread.start();

return a.exec();

}
查看运行结果:
“main thread id:” 0xf08

“my object thread id:” 0x216c

显然主线程与槽函数的线程是不同的(你可以多次尝试,屡试不爽。。。),因为moveToThread后MyObject所在的线程为QThread,继上面介绍的thread.start()执行后首先会发射started()信号,也就是说started()信号发射是在次线程中进行的,所以无论采取Qt::AutoConnection、Qt::DirectConnection、Qt::QueuedConnection哪种连接方式,主线程与槽函数的线程都是不同的。

1、修改代码如下:

MyObject object;
QThread thread;
//object.moveToThread(&thread);
QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::DirectConnection);
thread.start();

查看运行结果:
“main thread id:” 0x2688

“my object thread id:” 0x2110

显然主线程与槽函数的线程是不同的,MyObject所依附的线程为主线程(因为注释掉了moveToThread),继上面介绍的Qt::DirectConnection(无论槽函数所属对象在哪个线程,槽函数都在发射信号的线程内执行)。也就是说started()信号发射是在次线程中进行的,槽函数也是在次线程中进行的,所以主线程与槽函数的线程是不同的。

2、修改代码如下:

MyObject object;
QThread thread;
//object.moveToThread(&thread);
QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::QueuedConnection);
thread.start();

查看运行结果:

“main thread id:” 0x24ec

“my object thread id:” 0x24ec

显然主线程与槽函数的线程是相同的,继上面介绍的Qt::QueuedConnection(槽函数在接收者所依附线程执行)。也就是说started()信号发射是在次线程中进行的,但MyObject所依附的线程为主线程(因为注释掉了moveToThread),所以主线程与槽函数的线程必然是相同的。

3、修改代码如下:

MyObject object;
QThread thread;
//object.moveToThread(&thread);
QObject::connect(&thread, SIGNAL(started()), &object, SLOT(start()), Qt::AutoConnection);
thread.start();

查看运行结果:
“main thread id:” 0x2700

“my object thread id:” 0x2700

显然主线程与槽函数的线程是相同的,MyObject所依附的线程为主线程(因为注释掉了moveToThread),继上面介绍的Qt::AutoConnection(如果信号在接收者所依附的线程内发射,则等同于直接连接。如果发射信号的线程和接受者所依附的线程不同,则等同于队列连接。)。因为started()信号和MyObject依附的线程不同,所以结果和Qt::QueuedConnection对应的相同,所以主线程与槽函数的线程是相同的。



基本就介绍到这里,QThread使用和上面的大同小异,run里面执行的代码都是在次线程中,如果是QThead的槽函数,那么结论同上!

注:
技术在于交流、沟通,转载请注明出处并保持作品的完整性。
作者:一去丶二三里 原文:http://blog.sina.com.cn/s/blog_a6fb6cc90102vs8z.html

2010-04-06 10:57:46 iteye_394 阅读数 47
  • Qt Quick 4小时入门

    Qt Quick(QML)是Qt 5里推荐的UI开发框架,能够为各种设备搭建流畅且绚丽的用户界面。本课程删繁就简,精心选择主题,通过短短的几节课,即可让大家跨越Qt Quick的入门门槛,为进一步学习奠定坚实基础。

    48271 人正在学习 去看看 安晓辉
Wooce Yang收集整理
POCO的优点:
1) 比boost更好的线程库,特别是一个活动的方法的实现,并且还可设置线程的优先级。
2) 比 boost:asio更全面的网络库。但是boost:asio也是一个非常好的网络库。
3) 包含了一些Boost所不包含的功能,像XML,数据库接口等。
4) 跟Boost相比,集成度更高,是更加统一的一个库。
5) Poco的c++代码更清洁,现代和易理解。对不是模板编程专家的人来说,POCO的代码比大多数Boost库容易理解得多
6) 可以在许多平台上使用
POCO的缺点:
1) 文档有限。但这一定程度上是因为代码的容易理解。
2) 跟Boost相比用户社群小得多。
3) 有多少能集成进C++标准是个问题。而Boost在这方面不是个问题。

许多POCO的用户把POCO和Boost一起并用。
Boost是高质量的库,但它不是个框架。
Boost:asio处理高并发的效率还可以。 单连接吞吐稍微弱点。 如果选用, 最好封装好, 别让boost代码吞噬你的代码, 那样最后不可收拾。 呵呵。
asio在windows下效率是最好的。 基本接近自己在iocp上开发的效率。 在linux下, 他默认选用epoll, 但中间为了做了层stream cache, 效率稍有损失。 而且他的epoll规则用的不太合理, 可以自己修改他的代码, 达到自己的需求。
在freebsd下, 他默认是select的, 要自己修改他的代码条件编译, 才可以支持kqueue
没有更多推荐了,返回首页