一、单线程和多线程比较

单线程代码如下：

import threading
from datetime import *


def test():
    print (datetime.now())


def thd():
    Threads = []
    # 创建线程
    for i in range(500):
        t = threading.Thread(target=test)
        Threads.append(t)

    # 启动线程
    for t in Threads:
        t.start()
    # 阻塞线程
    for t in Threads:
        t.join()



if __name__ == "__main__":
    start_time = datetime.now()
    thd()
    end_time = datetime.now()
    print("执行总共耗时：", end_time - start_time, "秒")

注意，这里还用了一个t.join()，这个方法的作用是阻塞线程，这是为了保证所有的子线程都执行完毕后，再执行主线程的代码。

多线程代码如下：

import threading
from datetime import *


def test():
    print (datetime.now())


def looptest():
    for i in range(20):
        test()


def thd():
    Threads = []

    # 创建线程
    for i in range(25):
        t = threading.Thread(target=looptest)
        Threads.append(t)
    for t in Threads:
        t.start()
    # 阻塞线程
    for t in Threads:
        t.join()


if __name__ == "__main__":
    start_time = datetime.now()
    thd()
    end_time = datetime.now()
    print("执行总共耗时：", end_time - start_time, "秒")

原来的代码，需要并发执行500次test()函数，启动了500个线程，速度比较慢，非常消耗资源；新的代码，把500的并发拆成25个线程，每个线程并发执行20次test()函数，速度明显提升。

结果如下：

# 单线程
执行总共耗时： 0:00:00.078003 秒
# 多线程执行
执行总共耗时： 0:00:00.013262 秒

二、守护线程

在理解守护线程之前先要知道主线程和子线程的区别，第一节创建的线程只是main()线程的子线程，即先启动主线程main()，然后执行thd()启动 子线程。

守护线程是指在主线程结束后，不管守护线程（子线程）是否执行完毕，都会强制结束守护线程。

我们用一个死循环来测试一下，添加t.setDaemon(True)就是守护线程。

如果不添加这一行代码，当主线程执行完毕打印了主线程结束，然后程序继续等待子线程执行完毕，但是子线程是一个死循环，所以程序会一直等待下去，无法终止程序了。

import threading
from datetime import *
from time import sleep

def test():

    sleep(1)

    x = 0
    while(x == 0):
        print (datetime.now())

def thd():
    Threads = []
    # 创建线程
    for i in range(500):
        t = threading.Thread(target=test)
        Threads.append(t)
        # 守护线程
        t.setDaemon(True)

    # 启动线程
    for t in Threads:
        t.start()


if __name__ == "__main__":
    thd()
    print("主线程结束")