>撩个概念 多任务
什么是多任务呢?
我现在听着音乐,同时浏览着网页,在文档中写着笔记.是的,这就是多任务;对于计算机来说,就是同时执行多段的代码;
如今计算机都是多核CPU了,单核CPU也可以执行多任务,我们都知道计算机的代码都是顺序执行的,那么,单核的CPU是如何实现多任务的呢?
答案就是 在极短的时间内轮流切换各个任务,CPU的运算太快了,给我们的感觉就是在同时进行一样;
So.这里引进两个概念:并行和并发
并发: 例如在单核CPU中执行多个任务,这个就是并发(执行的任务数量大于CPU核数)
并行: 两个任务在多核CPU机器中执行,两个任务分别在不同的CPU中执行,这个就是并行(任务数小于CPU核数)
>接下来 线程
在python3中,线程由threading模块提供,来一窥threading面貌
threading模块下常用的方法或者属性
| 方法 | 说明 |
|---|---|
| current_thread() | 返回当前线程 |
| active_count() | 返回当前活跃的线程数量,主线程+子线程 |
| get_ident() | 返回当前线程 |
| enumerate() | 返回当前活动的Thread列表 |
| main_thread() | 返回主Thread对象 |
| settrace(func) | 为所有线程设置一个 trace 函数 |
| setprofile(func) | 为所有线程设置一个 profile 函数 |
| stack_size([size]) | 返回新创建线程栈大小；或为后续创建的线程设定栈大小为 size |
| TIMEOUT_MAX | Lock.acquire(), RLock.acquire(), Condition.wait() 允许的最大超时时间 |
threading模块包含的类
| 类 | 说明 |
|---|---|
| Thread | 基本的线程类 |
| Lock | 互斥锁 |
| RLock | 可重入锁，使单一进程再次获得已持有的锁(递归锁) |
| Condition | 条件锁，使得一个线程等待另一个线程满足特定条件，比如改变状态或某个值 |
| Semaphore | 信号锁。为线程间共享的有限资源提供一个”计数器”，如果没有可用资源则会被阻塞 |
| Event | 事件锁，任意数量的线程等待某个事件的发生，在该事件发生后所有线程被激活 |
| Timer | 一种计时器 |
| Barrier | Python3.2新增的“阻碍”类，必须达到指定数量的线程后才可以继续执行 |
threading模块中Thread类的方法和属性
| 方法与属性 | 说明 |
|---|---|
| start() | 启动线程，等待CPU调度 |
| run() | 线程被cpu调度后自动执行的方法 |
| getName()、setName()和name | 用于获取和设置线程的名称 |
| setDaemon() | 设置为后台线程或前台线程（默认是False，前台线程）。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止。如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程执行完成后，程序才停止 |
| ident | 获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None |
| is_alive() | 判断线程是否是激活的（alive）。从调用start()方法启动线程，到run()方法执行完毕或遇到未处理异常而中断这段时间内，线程是激活的 |
| isDaemon()方法和daemon属性 | 是否为守护线程 |
| join([timeout]) | 调用该方法将会使主调线程堵塞，直到被调用线程运行结束或超时。参数timeout是一个数值类型，表示超时时间，如果未提供该参数，那么主调线程将一直堵塞到被调线程结束 |
- 单线程(001_single_thread.py)
import time
def single_thread():
print("这个单线程执行:%s"%time.time())
time.sleep(1)
def main():
for _ in range(5):
single_thread()
if __name__ == "__main__":
main()
- 多线程(002_multi_thread.py)
import time
import threading
def single_thread():
print("这个单线程执行:%s"%time.time())
time.sleep(1)
def main():
for _ in range(5):
t = threading.Thread(target= single_thread)
t.start()
if __name__ == "__main__":
main()
执行结果:
test_code$ python3 001_single_thread.py
这个单线程执行:1563089407.2469919
这个单线程执行:1563089408.248269
这个单线程执行:1563089409.2495542
这个单线程执行:1563089410.2508354
这个单线程执行:1563089411.2516193
test_code$ python3 002_mulit_thread.py
这个多线程执行:1563089416.1928792
这个多线程执行:1563089416.1931264
这个多线程执行:1563089416.1932962
这个多线程执行:1563089416.1934686
这个多线程执行:1563089416.1936424
我们刚看了单线程执行和两个线程的执行效果,让我回想起GIL里讲到的,在I/0密集操作程序中可以使用多线程,这里的耗时操作使用了time.sleep(1)来模仿了.接下来让我们学习更多的关于threading模块的知识...
使用多线程并发操作,花费时间要短很多
当调用start(),才会真正的创建线程,并且开始执行
>主线程会等待所有的子线程结束后才结束
#coding=utf-8
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d"%i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d"%i)
sleep(1)
if __name__ == '__main__':
print('---开始---:%s'%ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
#sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
print('---结束---:%s'%ctime())
>查看线程数量
import threading
from time import sleep,ctime
def sing():
for i in range(2):
sleep(1)
print("sing_ending...")
def dance():
for i in range(3):
sleep(1)
if __name__ == "__main__":
print("----开始----:%s"%ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
while True:
length = len(threading.enumerate())
print("当前运行的线程数量为:%d"%length)
if length <= 1:
break
sleep(1)
运行结果:
----开始----:Sun Jul 14 17:11:24 2019
当前运行的线程数量为:3
当前运行的线程数量为:3
当前运行的线程数量为:3
sing_ending...
当前运行的线程数量为:2
当前运行的线程数量为:1
test_code$
>创建线程的第二种方式
-
使用的都是在threading.Thread()实例化时,给里面传入对应的参数
threading.Thread(self, group=None, target=None, name=None, args=(),kwargs=None, *, daemon=None)- group: 预留参数
- target: 一个可调用对象,在线程执行后使用
- name: 线程的名字,默认为"Thread-N"
- args,kwargs: 传递的参数列表和关键字参数
还有一种创建线程的方式是继承threading.Thread类,重写run方法,我们来尝试第二种方式
import threading
import time
class MyThread(threading.Thread):
def run(self):
print("I`m thread %s" % self.name)
if __name__ == '__main__':
t = MyThread()
t.start()
执行结果:
I`m thread Thread-1
总结
- 创建自己的线程类时,需要重写run方法,创建自己的线程实例后,通过调用Thread类的start方法可以启动该线程,交给python虚拟机进行调度,当该线程获得执行机会时,就会调用run方法执行线程,run()方法执行完,线程结束.
>线程的执行顺序
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(2):
time.sleep(0.5)
print("I`m %s %s" % (self.name, i))
def main():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
main()
执行结果:
I`m Thread-2 0
I`m Thread-3 0
I`m Thread-1 0
I`m Thread-4 0
I`m Thread-5 0
I`m Thread-2 1
I`m Thread-3 1
I`m Thread-4 1
I`m Thread-1 1
I`m Thread-5 1
总结
- 多线程的执行结果是不确定的,当执行到sleep时,线程将会被阻塞(Blocked),等到sleep结束后,线程进入就绪状态(Runnable)状态,等待调度;而线程的调度是随机选择一个线程执行.
>多线程,共享全局变量
import threading
import time
num = 100
def count_test1():
global num
for i in range(10):
num += 1
print("count_test1-->num:%s"%num)
def count_test2():
global num
for i in range(5):
num += 1
print("count_test2-->num:%s"%num)
print("最原始的num:%s"%num)
t1 = threading.Thread(target=count_test1)
t1.start()
time.sleep(2) #让t1执行完成
t2 = threading.Thread(target=count_test2)
t2.start()
执行结果:
最原始的num:100
count_test1-->num:110
count_test2-->num:115
>使用列表来测试
import threading
import time
def count_test1(num_list):
num_list.append(10000)
print("count_test1-->num:%s"%num_list)
def count_test2(num_list):
print("count_test2-->num:%s"%num_list)
num_list = [11, 22, 33, 44]
t1 = threading.Thread(target=count_test1, args=(num_list,))
t1.start()
time.sleep(1) #让t1执行完成
t2 = threading.Thread(target=count_test2, args=(num_list,))
t2.start()
执行结果:
count_test1-->num:[11, 22, 33, 44, 10000]
count_test2-->num:[11, 22, 33, 44, 10000]
总结
- 在一个进程内线程共享全局变量,多线程方便共享数据
- 缺点就是,线程对全局变量的随意修改会造成线程之间对全局变量的混乱(即线程非安全)
>多线程的资源竞争问题
两个线程(t1,t2)对同一个全局变量(global_num)进行修改,正常情况下,t1对global_num加10,然后t2对global_num加10,最终global_num为20.
But,在多线程中,存在这种情况,t1获取到global_num,此时系统将t1设置为"sleep"状态,这时t2获取到global_num,对global_num进行加1,完成后,系统将t2设置为"sleep"状态,将t1设置为"running"状态,此时t1拿到的global_num是t2修改前的值,这时进行修改就会和t2修改重复.
测试1(循环数为100)
import threading
import time
num = 0
def count_test1():
global num
for i in range(100):
num += 1
print("count_test1-->num:%s"%num)
def count_test2():
global num
for i in range(100):
num += 1
print("count_test2-->num:%s"%num)
t1 = threading.Thread(target=count_test1)
t2 = threading.Thread(target=count_test2)
t1.start()
t2.start()
t1.join()
t2.join()
print("最终的num:%s"%num)
测试结果:
count_test1-->num:100
count_test2-->num:200
最终的num:200
测试2(循环数为100000)
import threading
import time
num = 0
def count_test1():
global num
for i in range(100000):
num += 1
print("count_test1-->num:%s"%num)
def count_test2():
global num
for i in range(100000):
num += 1
print("count_test2-->num:%s"%num)
t1 = threading.Thread(target=count_test1)
t2 = threading.Thread(target=count_test2)
t1.start()
t2.start()
t1.join()
t2.join()
print("最终的num:%s"%num)
测试结果:
count_test1-->num:100000
count_test2-->num:153462
最终的num:153462
总结
- 如果多个线程对同一个全局变量操作,会出现资源问题,从而导致数据不准确
>解决资源竞争问题使用互斥锁
- threading模块中定义了Lock类,可以实现锁
- 创建锁对象: mutex = threading.Lock()
- 上锁: mutex.acquire()
- 释放锁: mutex.release()
- 注意:
- 如果这个锁之前是没有上锁的,那么acquire就不会阻塞
- 如果调用acquire之前这个锁是被其它线程上了锁的,那么acquire就会阻塞,知道这个锁被释放
使用互斥锁(循环数为100000)
import threading
import time
num = 0
def count_test1():
global num
for i in range(100000):
mutex.acquire()
num += 1
mutex.release()
print("count_test1-->num:%s"%num)
def count_test2():
global num
for i in range(100000):
mutex.acquire()
num += 1
mutex.release()
print("count_test2-->num:%s"%num)
mutex = threading.Lock()
t1 = threading.Thread(target=count_test1)
t2 = threading.Thread(target=count_test2)
t1.start()
t2.start()
t1.join()
t2.join()
print("最终的num:%s"%num)
执行结果:
count_test1-->num:188038
count_test2-->num:200000
最终的num:200000
上锁释放锁的过程
当一个线程调用锁的acquire()方法获得锁时,锁就进入“locked”状态
每次只有一个线程可以获得锁,如果此时另一个线程试图获得这个锁,该线程就会变为"blocked"状态,称为"阻塞",直到拥有锁的线程调用锁的release()方法释放锁之后,锁进入"unlocked"状态。
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁,并使得该线程进入运行(running)状态
总结
- 锁的好处
- 确保了一段代码只能由一个线程从前到尾完整执行
- 锁的坏处
- 阻止了多线程的并发执行,包含锁的代码段只能是单线程执行,大大降低了效率
- 可能会存在多个锁,在获取锁和释放锁时容易造成死锁
>死锁问题
情侣吵架后,都在等待对方道歉,如果双方一直等待对方先开口,那么结果就悲剧了...
情侣吵架和死锁有什么联系呢?如果两个线程共享全局变量,两个线程分别占有一定的资源并且咋等待对方的资源,就会造成死锁问题
#coding=utf-8
import threading
import time
class MyThread1(threading.Thread):
def run(self):
# 对mutexA上锁
mutexA.acquire()
# mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
print(self.name+'----do1---up----')
time.sleep(1)
# 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
mutexB.acquire()
print(self.name+'----do1---down----')
mutexB.release()
# 对mutexA解锁
mutexA.release()
class MyThread2(threading.Thread):
def run(self):
# 对mutexB上锁
mutexB.acquire()
# mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
print(self.name+'----do2---up----')
time.sleep(1)
# 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
mutexA.acquire()
print(self.name+'----do2---down----')
mutexA.release()
# 对mutexB解锁
mutexB.release()
mutexA = threading.Lock()
mutexB = threading.Lock()
if __name__ == '__main__':
t1 = MyThread1()
t2 = MyThread2()
t1.start()
t2.start()
执行结果
程序会卡住: 按唱、跳、Rap键+c退出
总结
- 如何避免死锁
- 程序设计上尽量避免
- 添加超时时间等
