Python中QThread、Thread、Processing的比较总结

最近在学习PyQt相关知识，碰到了其中的QThread类。于是查找学习了Python中Thread类与Processing类的基础知识。而QThread类则是Thread类的一个封装，两者功能相似

由于GIL(全局解释锁)的存在，Thread类和QThread类并不能利用多核优势。所以，如果你的多线程进程是CPU密集型的，那多线程并不能带来效率上的提升，相反还可能会因为线程的频繁切换，导致效率下降；如果是IO密集型，多线程进程可以利用IO阻塞等待时的空闲时间执行其他线程，提升效率。

如果目的是加强程序执行的效率，那么在python中应该使用多进程(multiprocess)而不是多线程(thread)

1. QThread类

在程序设计中，有时候有一些模块需要较长时间执行，例如文件传输等。在一个GUI程序中，如果直接使用简单的信号-槽(即简单事件响应机制)机制完成这类模块，那么在执行该模块时整个程序会陷入无响应，直到执行完成后才会恢复正常。
解决这种问题的好办法是引入多线程机制

基本用法

QThread是Qt的线程类中最核心的底层类。由于PyQt的的跨平台特性，QThread要隐藏所有与平台相关的代码 要使用的QThread开始一个线程，可以创建它的一个子类，然后覆盖其它QThread.run()函数。

class Thread(QThread):
    def __init__(self):
        super(Thread,self).__init__()
    def run(self):
        #

需要重写的是run()，而实际启动线程使用线程的start()
thread = Thread()
thread.start()

线程类中，常用的信号对象是在线程类内实例化一个pyqtSignal对象，然后使用时与槽函数连接，即signalName.connect(slotName)

trigger = pyqtSignal()

---

有了以上知识后，可以看下面的程序

import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *


class MainWidget(QWidget):
    def __init__(self, parent=None):
        super(MainWidget, self).__init__(parent)
        # 设置标题
        self.setWindowTitle('QThread多线程例子')

        # 实例化多线程对象
        self.thread = Worker()

        # 实例化列表控件与按钮控件
        self.listFile = QListWidget()
        self.btnStart = QPushButton('开始')

        # 把控件放置在栅格布局中
        layout = QGridLayout(self)
        layout.addWidget(self.listFile, 0, 0, 1, 2)
        layout.addWidget(self.btnStart, 1, 1)

        # 信号与槽函数的连接
        self.btnStart.clicked.connect(self.slotStart)
        self.thread.sinOut.connect(self.slotAdd)

    def slotAdd(self, file_inf):
        # 向列表控件中添加条目
        self.listFile.addItem(file_inf)

    def slotStart(self):
        # 开始按钮不可点击，线程开始
        self.btnStart.setEnabled(False)
        self.thread.start()


class Worker(QThread):
    sinOut = pyqtSignal(str)

    def __init__(self, parent=None):
        super(Worker, self).__init__(parent)
        # 设置工作状态与初始num数值
        self.working = True
        self.num = 0

    def __del__(self):
        # 线程状态改变与线程终止
        self.working = False
        self.wait()

    def run(self):
        while self.working:
            # 获取文本
            file_str = 'File index{0}'.format(self.num)
            self.num += 1
            # 发射信号
            self.sinOut.emit(file_str)
            # 线程休眠2秒
            self.sleep(2)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    demo = MainWidget()
    demo.show()
    sys.exit(app.exec_())

注意点: 注意run函数中的emit()方法，给emit的传参也即发出信号，会作为入参传入到指定的槽函数中。这可以看作一个隐的参数传递，区别于参数列表的参数传递

2. Thread类

import threading
import time

def read():
    for x in range(5):
        print('在%s,正在听音乐' % time.ctime())
        time.sleep(1.5)

def write():
    for x in range(5):
        print('在%s,正在看电视' % time.ctime())
        time.sleep(1.5)

def main():

    music_threads = []  # 用来存放执行read函数线程的列表
    TV_threads = []  # 用来存放执行write函数线程的列表

    for i in range(1,2):  # 创建1个线程用于read()，并添加到read_threads列表
        t = threading.Thread(target=read) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
        music_threads.append(t)

    for i in range(1,2): # 创建1个线程执行write()，并添加到write_threads列表
        t = threading.Thread(target=write) # 执行的函数如果需要传递参数，threading.Thread(target=函数名,args=(参数，逗号隔开))
        TV_threads.append(t)

    for i in range(0,1):  # 启动存放在read_threads和write_threads列表中的线程
        music_threads[i].start()
        TV_threads[i].start()

if __name__ == '__main__':
    main()

用法与QThread类基本一致

3. Process类

from multiprocessing import Process
import os


def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())


def f(name):
    info('function f')
    print('hello', name)


if __name__ == '__main__':
    info('main line')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

注意p = Process(target=f, args=('bob',)),参数args作为参数列表传给函数f

参考

• multiprocessing类详解
• multiprocessing类文档
• Thread类的用法
• QThread类的用法
• Qt高级控件之QThread