Python多任务——线程

偏执的太偏执、 2022-11-08 14:19 2阅读 0赞

# 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()`][start] 方法开始。这会在独立的控制线程调用 [`run()`][run] 方法。

*class* `threading.Thread`(*group=None*, *target=None*, *name=None*, *args=()*, *kwargs=\{\}*, \*, *daemon=None*)

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

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

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

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

##### threading.Thread类方法及属性 #####

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

[start]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.start
[run]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.run
[RuntimeError]: https://docs.python.org/zh-cn/3.7/library/exceptions.html#RuntimeError
[join]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.join
[is_alive]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.is_alive
[name]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.name
[get_ident]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.get_ident
[enumerate]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.enumerate
[daemon]: https://docs.python.org/zh-cn/3.7/library/threading.html#threading.Thread.daemon