Python多任务——线程

多任务概念

什么叫 多任务 呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听音乐，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？

答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。

真正的并行执行多任务只能在 多核CPU 上实现，但是，由于任务数量远远多于 CPU 的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。

线程 thread ：是 操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

• 并发性：是指两个或多个事件在同一时间间隔内发生，。
• 并行性：是指两个或多个事件在同一时刻发生。

单线程执行任务

程序模拟 边唱歌，边玩游戏

"""
Python多线程的使用
"""
import time
def sing(name):
    for i in range(3):
        print("%s正在唱歌...%d" % (name, i))
        time.sleep(1)
def play(name):
    for i in range(3):
        print("%s正在玩游戏...%d" % (name, i))
        time.sleep(1)
def single_thread_demo():
    """
    单线程案例
    """
    name = 'hui'
    sing(name)
    play(name)
def main():
    single_thread_demo()
if __name__ == '__main__':
    main()

运行结果如下：

hui正在唱歌...0
hui正在唱歌...1
hui正在唱歌...2
hui正在玩游戏...0
hui正在玩游戏...1
hui正在玩游戏...2
[Finished in 6.2s]

很显然程序并没有完成唱歌和玩游戏同时进行的要求，但生活中却很多这样的场景，例如边唱歌、边跳舞，唱跳一起进行。在Python中想实现多任务同时进行，可以使用 多线程、多进程、协程 等技术

Python多线程的实现

常用模块

Python 线程中常用的两个模块为：

• _thread
• threading(推荐使用)

Python的 _thread 模块是比较底层的模块，Python的 threading 模块是对 _thread 做了一些封装的，可以更加方便的被使用。

使用方式

Python中使用线程有以下方式：

• 函数式 _thread.start_new_thread()
• 线程对象 threading.Thread()
• 自定义类继承 threading.Thread

_thread模块（函数式）

_thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function 线程函数。
• args 传递给线程函数的参数，他必须是个tuple类型。
• kwargs 可选参数。

"""
Python多线程的使用
"""
import time
import _thread
def sing(name):
    for i in range(3):
        print("%s正在唱歌...%d" % (name, i))
        time.sleep(1)
def play(name):
    for i in range(3):
        print("%s正在玩游戏...%d" % (name, i))
        time.sleep(1)
def single_thread_demo():
    """
    单线程案例
    """
    name = 'hui'
    sing(name)
    play(name)
def fun_multithread():
    """函数式使用多线程"""
    name = 'hui'
    # 启动唱歌、玩游戏线程
    sing_thread = _thread.start_new_thread(sing, (name, ))
    play_thread = _thread.start_new_thread(play, (name, ))
def main():
    # single_thread_demo()
    fun_multithread()
    # 防止主线程先执行完，导致子线程没有执行
    time.sleep(3)
if __name__ == '__main__':
    main()

运行结果如下

第一种运行结果
hui正在唱歌...0hui正在玩游戏...0
hui正在唱歌...1hui正在玩游戏...1
hui正在玩游戏...2hui正在唱歌...2
[Finished in 3.1s]
第二种运行结果
hui正在唱歌...0
hui正在玩游戏...0
hui正在唱歌...1
hui正在玩游戏...1
hui正在唱歌...2
hui正在玩游戏...2
[Finished in 3.1s]
第......

与单线程对比

hui正在唱歌...0
hui正在唱歌...1
hui正在唱歌...2
hui正在玩游戏...0
hui正在玩游戏...1
hui正在玩游戏...2
[Finished in 6.2s]

很明显使用多线程并发的操作，耗时更短，也完成了 边唱歌边玩游戏 的模拟。

注意： 由于操作系统分给每个线程的时间片不一样，调度的先后顺序也不同，所以会有很多不一样的运行结果。

threading模块 （线程对象）

"""
Python多线程的使用
"""
import time
import _thread
import threading
def sing(name):
    for i in range(3):
        print("%s正在唱歌...%d" % (name, i))
        time.sleep(1)
def play(name):
    for i in range(3):
        print("%s正在玩游戏...%d" % (name, i))
        time.sleep(1)
def thread_obj_demo():
    """
    使用线程对象创建多线程
    """
    name = 'hui'
    # 创建线程
    sing_thread = threading.Thread(target=sing, args=(name,))
    play_thread = threading.Thread(target=play, args=(name,))
    # 启动线程
    sing_thread.start()
    play_thread.start()
def main():
    thread_obj_demo()
    # 防止主线程先执行完，导致子线程没有执行
    time.sleep(3)
if __name__ == '__main__':
    main()

运行结果如下

hui正在唱歌...0
hui正在玩游戏...0
hui正在玩游戏...1
hui正在唱歌...1
hui正在唱歌...2hui正在玩游戏...2
[Finished in 3.1s]

threading模块常用方法

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的 list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果。

"""
python threading模块的常用方法
"""
import time
import threading
def test1():
    print('------test1-------')
    time.sleep(3)
def test2():
    print('------test2-------')
    time.sleep(3)
def main():
    t1 = threading.Thread(target=test1)
    t2 = threading.Thread(target=test2)
    t1.start()
    t2.start()
    print('activeCount: %d' % threading.activeCount())
    print(threading.enumerate())
    while threading.activeCount() != 1:
        time.sleep(1)
        print(threading.enumerate())
    print(threading.enumerate())
if __name__ == '__main__':
    main()

运行结果

------test1-------
------test2-------
activeCount: 3
[<_MainThread(MainThread, started 8680)>, <Thread(Thread-1, started 4256)>, <Thread(Thread-2, started 7932)>]
[<_MainThread(MainThread, started 8680)>, <Thread(Thread-1, started 4256)>, <Thread(Thread-2, started 7932)>]
[<_MainThread(MainThread, started 8680)>, <Thread(Thread-1, started 4256)>, <Thread(Thread-2, started 7932)>]
[<_MainThread(MainThread, started 8680)>]
[<_MainThread(MainThread, started 8680)>]

threading.Thread类构造

当线程对象一但被创建，其活动一定会因调用线程的 start() 方法开始。这会在独立的控制线程调用 run() 方法。

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, _, _daemon=None*)

调用这个构造函数时，必需带有关键字参数。参数如下：

• group 应该为 None；为了日后扩展 ThreadGroup 类实现而保留。
• target 是用于 run() 方法调用的可调用对象。默认是 None，表示不需要调用任何方法。
• name 是线程名称。默认情况下，由 “Thread-N“ 格式构成一个唯一的名称，其中 N 是小的十进制数。
• args 是用于调用目标函数的参数元组。默认是 ()。
• kwargs 是用于调用目标函数的关键字参数字典。默认是 {}。

如果不是 None，daemon 参数将显式地设置该线程是否为守护模式。 如果是 None (默认值)，线程将继承当前线程的守护模式属性。

如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(Thread.__init__())。

threading.Thread类方法及属性

• start()
  开始线程活动。它在一个线程里最多只能被调用一次。它安排对象的 run() 方法在一个独立的控制进程中调用。如果同一个线程对象中调用这个方法的次数大于一次，会抛出 RuntimeError 。
• run()
  代表线程活动的方法。你可以在子类型里重载这个方法。 标准的 run() 方法会对作为 target 参数传递给该对象构造器的可调用对象（如果存在）发起调用，并附带从 args 和 kwargs 参数分别获取的位置和关键字参数。
• join(timeout=None)
  等待，直到线程终结。这会阻塞调用这个方法的线程，直到被调用 join() 的线程终结 — 不管是正常终结还是抛出未处理异常 — 或者直到发生超时，超时选项是可选的。当 timeout 参数存在而且不是 None 时，它应该是一个用于指定操作超时的以秒为单位的浮点数（或者分数）。因为 join() 总是返回 None ，所以你一定要在 join() 后调用 is_alive() 才能判断是否发生超时 — 如果线程仍然存活，则 join() 超时。当 timeout 参数不存在或者是 None ，这个操作会阻塞直到线程终结。一个线程可以被 join() 很多次。如果尝试加入当前线程会导致死锁， join() 会引起 RuntimeError 异常。如果尝试 join() 一个尚未开始的线程，也会抛出相同的异常。
• name
  只用于识别的字符串。它没有语义。多个线程可以赋予相同的名称。 初始名称由构造函数设置。
• getName()
• setName()
  旧的 name 取值/设值 API；直接当做特征属性使用它。
• ident
  这个线程的 ‘线程标识符’，如果线程尚未开始则为 None 。这是个非零整数。参见 get_ident() 函数。当一个线程退出而另外一个线程被创建，线程标识符会被复用。即使线程退出后，仍可得到标识符。
• is_alive()
  返回线程是否存活。当 run() 方法刚开始直到 run() 方法刚结束，这个方法返回 True 。模块函数 enumerate() 返回包含所有存活线程的列表。
• daemon
  一个表示这个线程是（True）否（False）守护线程的布尔值。一定要在调用 start() 前设置好，不然会抛出 RuntimeError 。初始值继承于创建线程；主线程不是守护线程，因此主线程创建的所有线程默认都是 daemon = False。当没有存活的非守护线程时，整个Python程序才会退出。
• isDaemon()
• setDaemon()
  旧的 name 取值/设值 API；建议直接当做特征属性使用它。

自定义类继承 threading.Thread

通过使用 threading 模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使用 threading 模块时，往往会定义一个新的子类 class，只要继承 threading.Thread 就可以了，然后重写 run 方法

"""
Python多线程的使用
"""
import time
import threading
class MyThread(threading.Thread):
    # def __init__(self):
    #    super().__init__()
    def run(self):
        for i in range(3):
            time.sleep(1)
            msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
            print(msg)
def main():
    t = MyThread()
    t.start()
if __name__ == '__main__':
    main()

如果子类型重载了构造函数，它一定要确保在做任何事前，先发起调用基类构造器(Thread.__init__())。

super().__init__()    # 需先调用父类构造

运行结果如下：

I'm Thread-1 @ 0
I'm Thread-1 @ 1
I'm Thread-1 @ 2

结论：

python 的 threading.Thread 类有一个 run() 方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。而创建自己的线程实例后，通过 Thread 类的 start()方法，可以启动该线程，交给 python 虚拟机进行调度，当该线程获得执行的机会时，就会调用 run()方法执行线程

总结

• 每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的 name，但是 python 会自动为线程指定一个名字。
• 当线程的 run() 方法结束时该线程完成。
• 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

公众号

新建文件夹X

大自然用数百亿年创造出我们现实世界，而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦，用大脑构建一切。人们把1000视为权威，我们反其道行之，捍卫1024的地位。我们不是键盘侠，我们只是平凡世界中不凡的缔造者 。