qt 子窗口写到线程就卡死_python高级：6.多线程part1

0.前言

如果可以的话，请先关注（专栏和账号），然后点赞和收藏，最后学习和进步。你的支持是我继续写下去的最大动力，个人定当倾囊而送，不负众望。谢谢！！！

1.前提

基于win10专业版64位系统+64位jdk1.8+64位python3.6.5+社区版pycharm2018.1.3+unittest+selenium3.141.0。

要学好自动化测试，我们先从python语言基础开始学习，一步一个脚印，欲速则不达哦！

2.线程和进程

1）简介

线程：有时被称为轻量级进程(Lightweight Process，LWP），是操作系统调度（CPU调度）执行的最小单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

多线程类似于同时执行多个不同程序，多线程运行有如下优点：

a.使用线程可以把占据长时间的程序中的任务放到后台去处理;

b.用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度;

c.程序的运行速度可能加快。

进程：运行起来的程序。进程需要占用系统资源（内存，CPU）。进程是最小的系统资源分配单位，只是给线程提供执行环境。

注：一个进程可以包含一到多个线程，进程独享资源，进程包含的线程间共享该进程资源。比如启动一个QQ对应一个进程，你打开多个聊天窗口与不同人聊天用的就是线程，不同聊天窗口线程之间互不影响，同时共享QQ进程的资源。

这些游戏相信很多人都玩过，里面都是真实的玩家，在你的客户端电脑上启动游戏对应游戏里面的一个玩家角色，对于客户端电脑来说你是一个进程，但对于服务器来说你是一个线程，每个玩家都是线程，所以玩家之间才不会相互影响。

2）基础语法

仅以线程为例：进程语法类似。

from threading import Thread#线程模块导包
from multiprocessing import Process#进程模块导包

t1 = Thread(target=method)#创建线程
t1.setDaemon(True)#守护线程：与jion()相反，不等子线程完成继续执行后面的任务，与主线程一起结束
t1.start()#启动线程
t1.join()#等待线程：主线程必须等待对应子线程结束才能继续往下执行

注：程序运行的时候，代码从上到下从左到右这种运行逻辑就对应进程的主线程（一个进程至少得有一个主线程程），在这个过程中如果遇到定义的其它线程，这些其它线程就叫做子线程。

3）实例

等待线程：

from time import sleep
from threading import  Thread
def method(n):
    for i in range(1,n+1):
        print(i)
        sleep(1)  # 为了使后面线程并发时交叉效果更明显，故添加个等待
if __name__ == '__main__':
    t1 = Thread(target=method,args=(5,))
    t1.start()
    t1.join()#等待线程，主线程到达这里必须等待子线程t1完成才会继续往下执行
    print("game over!")
# 运行结果：
1
2
3
4
5
game over!

说明：game voer!的打印必须前面的t1线程运行完了才能执行，结果可见上方。

守护线程：

from time import sleep
from threading import  Thread
def method(n):
    for i in range(1,n+1):
        print(i)
        sleep(1)  # 为了使后面线程并发时交叉效果更明显，故添加个等待
if __name__ == '__main__':
    t1 = Thread(target=method,args=(5,))
    t1.setDaemon(True)#守护线程，主线程到达这里无需等待子线程t1完成，直接继续往下执行，主线程结束，对应的守护子线程跟着一起结束
    t1.start()
    print("game over!")

说明：game voer!的打印无需等待前面的t1线程运行完成，直接继续往下，主线程完了，对应的守护子线程跟着一起结束，结果可见上方。

不使用线程打印两遍1~5：

from time import sleep
def method(n):
    for i in range(1,n+1):
        print(i)
        sleep(1)#为了使后面线程并发时交叉效果更明显，故添加个等待
if __name__ == '__main__':
    method(5)
    method(5)
#运行结果：
1
2
3
4
5
1
2
3
4
5

使用两个线程分别打印一遍1~5：

from time import sleep
from threading import  Thread
def method(n):
    for i in range(1,n+1):
        print(i)
        sleep(1)#为了使后面线程并发时交叉效果更明显，故添加个等待
if __name__ == '__main__':
    t1 = Thread(target=method,args=(5,))
    t1.start()
    t2 = Thread(target=method,args=(5,))
    t2.start()
#运行结果：
1
1
2
2
3
3
4
4
5
5

总结：从以上两端代码得出结论，线程可以并发执行。

分别用进程和线程来操作同一个变量，看下结果：

from 

from multiprocessing import Process
a = 1
def method():
    global a
    a += 1
    print('函数内部',a)
if __name__ == '__main__':
    p1 = Process(target=method)#创建一个调用method方法的进程p1
    p1.start()#启动p1进程，实质是给全局变量a加了1，变为2
    print('函数外部',a)
    p2 = Process(target=method)#创建一个调用method方法的进程p2
    p2.start()#启动p2进程，实质是又给全局变量a加了1，变为3
    print('函数外部',a)
# 运行结果：
函数外部 1
函数外部 1
函数内部 2
函数内部 2

总结：以上结果能能说明什么呢？说明进程间独享资源（包括变量对象），线程间共享资源（包括变量对象的计算结果）。