python3多线程趣味详解

python3的多线程很多人无法理解是怎么运行的，因此本文从程序猿的日常生活出发，写了一个由浅入深的多线程教程，这样子大家就不会觉得陌生了，多线程真的很简单很简单！

 不要讲多线程局限于库或者框架，自己造轮子才是最大的快乐。

-----------------------------------------以下是正文--------------------------------------------

假设我是一个程序猿，我想听歌，但是我又要打码，所以有：

我听完歌就去打码：

#!/usr/bin/python3.4
# -*- coding: utf-8 -*-

import time

def matter1(music):
    print("我想听这些歌")

    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    print("我在打码")

    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")

if __name__ == '__main__':

    start = time.time()

    # 设定我要听的歌为
    music = ["music1","music2","music3"]
    # 开始听歌
    matter1(music)
    # 设定我要打码的行数
    number = 5
    # 开始打码
    matter2(number)

    end = time.time()
    print("完成的时间为：" + str(end - start))

记录来的完成时间为：

完成的时间为：12.007483959197998

时间上完全符合，但是身为一个程序猿，可以一边打码一边听歌，那么设计一个多线程，让他们同时进行：

#!/usr/bin/python3.4
# -*- coding: utf-8 -*-

import time
import threading

def matter1(music):
    print("我想听这些歌")

    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    print("我在打码")

    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")

if __name__ == '__main__':
    # 设定我要听的歌为
    music = ["music1","music2","music3"]

    # 设定我要打码的行数
    number = 5
    # 建立一个新数组
    threads = []
    # 将听歌放入数组里面
    thing1 = threading.Thread(target=matter1, args=(music,))
    threads.append(thing1)
    # 将打码放入数组里面
    thing2 = threading.Thread(target=matter2, args=(number,))
    threads.append(thing2)

    # 开始时间
    start = time.time()
    # 写个for让两件事情都进行
    for thing in threads:
        # setDaemon为主线程启动了线程matter1和matter2
        # 启动也就是相当于执行了这个for循环
        thing.setDaemon(True)
        thing.start()

    # 结束时间
    end = time.time()
    print("完成的时间为：" + str(end - start))

但是直接就结束了？

完成的时间为：0.0010008811950683594

原来是setDaemon，主线程启动两个子线程后做事后，主线程就不管子线程是否运行完毕，直接往下运行，直接运行到

print("完成的时间为：" + str(end - start))

然后程序就结束了，因此，为了防止子线程还没结束主线程就结束的意外情况，在程序里面加个join：

import time
import threading

def matter1(music):
    print("我想听这些歌")

    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    print("我在打码")

    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 当前时间为
        print(time.strftime('%Y%H%M%S', time.localtime()))
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")

if __name__ == '__main__':
    # 设定我要听的歌为
    music = ["music1","music2","music3"]

    # 设定我要打码的行数
    number = 5
    # 建立一个新数组
    threads = []
    # 将听歌放入数组里面
    thing1 = threading.Thread(target=matter1, args=(music,))
    threads.append(thing1)
    # 将打码放入数组里面
    thing2 = threading.Thread(target=matter2, args=(number,))
    threads.append(thing2)

    # 开始时间
    start = time.time()
    # 写个for让两件事情都进行
    for thing in threads:
        # setDaemon为主线程启动了线程matter1和matter2
        # 启动也就是相当于执行了这个for循环
        thing.setDaemon(True)
        thing.start()

    # 子线程没结束前主线程会被卡在这里
    thing1.join()
    thing2.join()
    # 结束时间
    end = time.time()
    print("完成的时间为：" + str(end - start))

最后运行的时间就是打码的时间：

完成的时间为：6.003339052200317

这就真正做到了一边听歌一边打码的双手互博的状态，本文后面的那0.003333秒就别纠结了，系统运行程序花个0.0033333秒不过分吧

偷懒打码打4行：

number = 4
完成的时间为：5.008083820343018

------------------------------我是快乐的分割线------------------------------

网上的多线程都是写成“类”的形式，这里写成函数不符合“大众”标准，那么就改成类的形式：

#!/usr/bin/python3.4
# -*- coding: utf-8 -*-

import time
import threading

class MyThread(threading.Thread):
    def __init__(self, func, args, name=''):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args
        #self.counter = counter

    def run(self):
        # 某某线程要开始了
        print(self.name + "开始了##################")

        if self.name == "听歌线程":
            matter1(music)
        elif self.name == "打码线程":
            matter2(number)
        print(self.name + "结束了##################")

def matter1(music):
    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")


if __name__ == '__main__':
    # 设定我要听的歌为
    music = ["music1","music2","music3"]

    # 设定我要打码的行数
    number = 4

    # 开始时间
    start = time.time()

    thing1 = MyThread(matter1, music,"听歌线程")
    thing2 = MyThread(matter2, number, "打码线程")
    thing1.start()
    thing2.start()
    thing1.join()
    thing2.join()

    # 结束时间
    end = time.time()
    print("完成的时间为：" + str(end - start))

运行结果也是6秒：

完成的时间为：6.001942157745361

----------------------我是快乐的分割线-------------------------

程序猿在跑代码的时候是很无聊的，无聊的时候就会想到去吃零食，那么我就加入一个函数：

#!/usr/bin/python3.4
# -*- coding: utf-8 -*-

import time
import threading

class MyThread(threading.Thread):
    def __init__(self, func, args, name=''):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args
        #self.counter = counter

    def run(self):
        # 某某线程要开始了
        print(self.name + "开始了##################")

        if self.name == "听歌线程":
            matter1(music)
        elif self.name == "打码线程":
            matter2(number)
        elif self.name == "零食线程":
            matter3(snacks)
        print(self.name + "结束了##################")

def matter1(music):
    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")

def matter3(snacks):
    for k in range(0,len(snacks)):
        print("我正在听着歌吃" + str(snacks[k]) + "零食")
        #每吃一袋零食间隔5秒
        time.sleep(5)
        print("吃完了一包零食")

if __name__ == '__main__':
    # 设定我要听的歌为
    music = ["music1","music2","music3"]

    # 设定我要打码的行数
    number = 4

    # 设定我想吃的零食
    snacks = ["咪咪","辣条"]

    # 开始时间
    start = time.time()

    thing1 = MyThread(matter1, music,"听歌线程")
    thing2 = MyThread(matter2, number, "打码线程")
    thing3 = MyThread(matter3, snacks, "零食线程")
    thing1.start()
    thing2.start()
    thing3.start()
    thing1.join()
    thing2.join()
    thing3.join()

    # 结束时间
    end = time.time()
    print("完成的时间为：" + str(end - start))

程序运行的时间是：

完成的时间为：10.000968933105469

感觉还是吃零食比较耗时间。但是但是，程序猿只有两个手，那么吃零食和打码是不能同时进行了，那么这里加个线程锁：

#!/usr/bin/python3.4
# -*- coding: utf-8 -*-

import time
import threading

# 打开线程锁
lock = threading.Lock()

class MyThread(threading.Thread):
    def __init__(self, func, args, name=''):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args
        #self.counter = counter

    def run(self):
        # 某某线程要开始了
        print(self.name + "开始了##################")

        if self.name == "听歌线程":
            matter1(music)
        elif self.name == "打码线程":
            matter2(number)
        elif self.name == "零食线程":
            matter3(snacks)
        print(self.name + "结束了##################")

def matter1(music):
    for i in range(0,len(music)):
        print("第" + str(i + 1) + "首歌是：" + str(music[i]))
        # 假设每一首歌曲的时间是2秒
        time.sleep(2)
        print("切换下一首歌...")

def matter2(number):
    lock.acquire()
    j = 0
    while j <= number:
        print("我准备写入第" + str(j + 1) +"行代码")
        j = j + 1
        # 假设每写一行代码的时间为1秒
        time.sleep(1)
        print("写下一行代码...")
    lock.release()

def matter3(snacks):
    lock.acquire()
    for k in range(0,len(snacks)):
        print("我正在听着歌吃" + str(snacks[k]) + "零食")
        #每吃一袋零食间隔5秒
        time.sleep(5)
        print("吃完了一包零食")
    lock.release()

if __name__ == '__main__':
    # 设定我要听的歌为
    music = ["music1","music2","music3"]

    # 设定我要打码的行数
    number = 4

    # 设定我想吃的零食
    snacks = ["咪咪","辣条"]

    # 开始时间
    start = time.time()

    thing1 = MyThread(matter1, music,"听歌线程")
    thing2 = MyThread(matter2, number, "打码线程")
    thing3 = MyThread(matter3, snacks, "零食线程")
    thing1.start()
    thing2.start()
    thing3.start()
    thing1.join()
    thing2.join()
    thing3.join()

    # 结束时间
    end = time.time()
    print("完成的时间为：" + str(end - start))

运行时间为：

完成的时间为：15.001857995986938

这里解释一下：

只是听歌和打码花的时间是5s多；

听歌、打码、吃零食同时进行是10s多；

加了线程锁后，打码和吃零食不能同时进行，那么就变成：

听歌和打码花的时间是5s多；

单独吃零食是10s多，加起来就是15秒；

为了验证吃零食的时候还是听着歌的，所以将听歌的时间间隔改成10s，得到的运行时间为：

完成的时间为：30.000711917877197

运行结果贴出来看一下：

听歌线程开始了##################
第1首歌是：music1
打码线程开始了##################
我准备写入第1行代码
零食线程开始了##################
写下一行代码...
我准备写入第2行代码
写下一行代码...
我准备写入第3行代码
写下一行代码...
我准备写入第4行代码
写下一行代码...
我准备写入第5行代码
写下一行代码...
打码线程结束了##################
我正在听着歌吃咪咪零食
切换下一首歌...
第2首歌是：music2
吃完了一包零食
我正在听着歌吃辣条零食
吃完了一包零食
零食线程结束了##################
切换下一首歌...
第3首歌是：music3
切换下一首歌...
听歌线程结束了##################

perfect！