python进程池线程异常抛出_python异常处理，多线程，多进程

什么是异常&＃xff1f;

异常即是一个事件&＃xff0c;该事件会在程序执行过程中发生&＃xff0c;影响了程序的正常执行。

一般情况下&＃xff0c;在Python无法正常处理程序时就会发生一个异常。

异常是Python对象&＃xff0c;表示一个错误。

当Python脚本发生异常时我们需要捕获处理它&＃xff0c;否则程序会终止执行。

异常处理

捕捉异常可以使用try / except语句。

try/except语句用来检测try语句块中的错误&＃xff0c;从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序&＃xff0c;只需在try里捕获它。

以下为简单的try....except...else的语法&＃xff1a;

try:

正常的操作

......................

except: #可以多次使用except捕捉多个错误

发生异常&＃xff0c;执行这块代码

......................

else:　　#可有可无

如果没有异常执行这块代码

例&＃xff1a;索引错误

l &＃61; [1, 2, 3, 4]try:

l[5]exceptIndexError:print(&＃39;索引错误&＃39;)else:print(&＃39;成功&＃39;)

运行结果&＃xff1a;

l &＃61; [1, 2, 3, 4]try:

l[5]except IndexError as i: #可以给错误个别名

print(i) #然后打印错误&＃xff0c;会出现原生错误

else:print(&＃39;成功&＃39;)

运行结果&＃xff1a;

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try:

finally:

#退出try时总会执行

raise

例&＃xff1a;

l &＃61; [1, 2, 3, 4]try:

l[5]exceptIndexError:print(&＃39;索引错误&＃39;)finally:print(&＃39;happy&＃39;)

运行结果&＃xff1a;

自定义异常

通过创建一个新的异常类&＃xff0c;程序可以命名它们自己的异常。异常应该是典型的继承自Exception类&＃xff0c;通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类&＃xff0c;基类为RuntimeError&＃xff0c;用于在异常触发时输出更多的信息。

在try语句块中&＃xff0c;用户自定义的异常后执行except块语句&＃xff0c;变量 e 是用于创建Networkerror类的实例。

例&＃xff1a;

class 异常错误名字(Exception): #自定义异常&＃xff0c;继承Exception类的形式

def __init__(self, msg): #初始化

self.message &＃61;msg#def __str__(self):

#return self.message

try:raise 异常错误名字(&＃39;我的异常&＃39;) #固定格式

except异常错误名字 as e:print(e)

多任务多线程

线程的并发是利用cpu的上下文的切换&＃xff0c;在python3里是假的多线程&＃xff0c;它不是真真正正的并行&＃xff0c;其实就是串行&＃xff0c;只不过利用了cpu上下文的切换而已

线程是程序最小的调度单位

例&＃xff1a;串行

deftest1():for i in range(3):print(&＃39;test1&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %i)deftest2():for i in range(3):print(&＃39;test2&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %i)

test1()

test2()

运行结果&＃xff1a;

例&＃xff1a;并发

import threading #导入线程模块

import time #导入time模块

deftest1():for i in range(3):

time.sleep(1) #为了看出效果&＃xff0c;延迟1秒

print(&＃39;test1&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %i)deftest2():for i in range(3):

time.sleep(1) #为了看出效果&＃xff0c;延迟1秒

print(&＃39;test2&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %i)

t1&＃61; threading.Thread(target&＃61;test1) #实例化一个线程&＃xff0c;用Thread方法 &＃xff0c;目标是test1(不加括号&＃xff0c;是内存地址)

t2 &＃61; threading.Thread(target&＃61;test2)

t1.start()#执行这个线程

t2.start() #执行这个线程

运行结果&＃xff1a;图一出现后1秒&＃xff0c;再次出现两行&＃xff0c;如图二&＃xff0c;再1秒后&＃xff0c;再次出现两行&＃xff0c;如图三

多线程执行的顺序是无序的

deftest1(n):

time.sleep(1)print(&＃39;task&＃39;, n)for i in range(10):

t&＃61; threading.Thread(target&＃61;test1, args&＃61;(&＃39;t-%s&＃39; % i,)) #传参args&＃xff0c;必须元组形式&＃xff0c;必须要加逗号

t.start()

运行结果&＃xff1a;

多线程共享全局变量

因为函数内得不到函数外的数据&＃xff0c;所以要global声明

g_num &＃61; 0 #全局变量

defupdate():global g_num #global声明全局变量(才可以修改)

for i in range(10):

g_num&＃43;&＃61; 1update()print(g_num)

运行结果&＃xff1a;

g_num &＃61; 0 #全局变量

defupdate():global g_num #global声明全局变量(才可以修改)

for i in range(10):

g_num&＃43;&＃61; 1

defreader():globalg_numprint(g_num)

t1&＃61; threading.Thread(target&＃61;update)

t2&＃61; threading.Thread(target&＃61;reader)

t1.start()

t2.start()

运行结果&＃xff1a;

线程是继承在进程里的&＃xff0c;没有进程就没有线程

GIL全局解释器锁

GIL的全称是&＃xff1a;Global Interpreter Lock,意思就是全局解释器锁&＃xff0c;这个GIL并不是python的特性&＃xff0c;他是只在Cpython解释器里引入的一个概念&＃xff0c;而在其他的语言编写的解释器里就没有这个GIL例如&＃xff1a;Jython&＃xff0c;Pypy

为什么会有GIL&＃xff1f;&＃xff1a;

随着电脑多核cpu的出现核cpu频率的提升&＃xff0c;为了充分利用多核处理器&＃xff0c;进行多线程的编程方式更为普及&＃xff0c;随之而来的困难是线程之间数据的一致性和状态同步&＃xff0c;而python也利用了多核&＃xff0c;所以也逃不开这个困难&＃xff0c;为了解决这个数据不能同步的问题&＃xff0c;设计了gil全局解释器锁。

例&＃xff1a;

deftest1():global global_num #声明全局变量

for i in range(1000000):

global_num&＃43;&＃61; 1 #加1

print("test1", global_num)deftest2():globalglobal_numfor i in range(1000000):

global_num&＃43;&＃61; 1

print("test2", global_num)

t1&＃61; threading.Thread(target&＃61;test1)

t2&＃61; threading.Thread(target&＃61;test2)

t1.start()

t2.start()## t1.join() #等t1线程执行完毕## t2.join()

print(global_num)

执行结果&＃xff1a;会发现每次都是不同的

那么问题来了&＃xff0c;为什么每次的执行结果都不一样呢&＃xff0c;让我们结合上面的大图&＃xff0c;分析一下&＃xff1a;

上图和实例解析&＃xff1a;

线程共享数据池&＃xff0c;就相当于声明的全局变量&＃xff0c;线程1拿到公共数据后&＃xff0c;首先会申请到gil锁&＃xff0c;就是在它进行操作时&＃xff0c;不允许其他线程的操作&＃xff0c;通过python解释器&＃xff0c;调用系统原生线程&＃xff0c;&＃xff0c;然后假设在cpu上执行&＃xff0c;若执行时间到了&＃xff0c;线程1 还没有执行结束&＃xff0c;那么将会被要求释放gil锁&＃xff0c;相当于暂停&＃xff0c;释放后线程2会拿到公共数据&＃xff0c;同样申请到gil锁&＃xff0c;通过python解释器调用原生线程&＃xff0c;假设在cpu3上执行&＃xff0c;并且完成&＃43;1的赋值&＃xff0c;全局变量将会从0变成1&＃xff0c;并且 &＃xff0c;线程2释放gil锁&＃xff0c;线程1再次开始执行&＃xff0c;将从暂停的位置开始&＃xff0c;当结束&＃43;1赋值时&＃xff0c;释放gil锁&＃xff0c;这里线程1的从0到1赋值的过程将会覆盖掉线程2的赋值&＃xff0c;所以&＃xff0c;全局变量还是1&＃xff0c;接下来还是同样的道理&＃xff0c;不管线程1还是线程2&＃xff0c;每一次赋值都是覆盖形式的&＃xff0c;所以当主线程结束的时候&＃xff0c;每次的结果就不一样了。

那么上面的结果并不是我们想要的&＃xff0c;针对上面的情况我们的解决的方案是再加一把锁

互斥锁&＃xff0c;要么不作&＃xff0c;要么做完

GIL全局解释器锁importthreading

global_num&＃61;0

lock&＃61; threading.Lock() #申请一把锁

deftest1():globalglobal_num

lock.acquire()#上锁

for i in range(1000000):

global_num&＃43;&＃61; 1lock.release()#释放锁

print("test1", global_num)deftest2():globalglobal_num

lock.acquire()#上锁

for i in range(1000000):

global_num&＃43;&＃61; 1lock.release()#释放锁

print("test2", global_num)

t1&＃61; threading.Thread(target&＃61;test1)

t2&＃61; threading.Thread(target&＃61;test2)

t1.start()

t2.start()

t1.join()#为了防止主线程结束的太快&＃xff0c;等t1线程执行完毕

t2.join() #为了防止主线程结束的太快&＃xff0c;等t2线程执行完毕

print(global_num)

运行结果&＃xff1a;

那么上过锁之后&＃xff0c;实际就变成了串行

例&＃xff1a;下面代码开了10个进程&＃xff0c;跑了多久的时间

importtimedefrun(n):

time.sleep(2)print(&＃39;this is running&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %n)for i in range(10):

t&＃61; threading.Thread(target&＃61;run, args&＃61;(i,))

t.start()

解决方案&＃xff1a;

importtimedefrun(n):

time.sleep(2)print(&＃39;this is running&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;>%s&＃39; %n)

l&＃61; [] #建立一个空列表

start &＃61; time.time() #记录开始的时间

for i in range(10):

t&＃61; threading.Thread(target&＃61;run, args&＃61;(i,))

t.start()

l.append(t)#把创建的实例加入列表

for j in l: #循环l列表

j.join() #等待循环进程结束

end &＃61; time.time() #记录结束的时间

print(&＃39;cost&＃39;, (end-start))

只要在进行耗时的IO操作的时候&＃xff0c;能释放GIL&＃xff0c;所以只要在IO密集型的代码里&＃xff0c;用多线程就很合适

进程

一个程序运行起来之后&＃xff0c;代码&＃43;用到的资源称之为进程&＃xff0c;它是操作系统分配资源的基本单位&＃xff0c;不仅可以通过线程完成多任务&＃xff0c;进程也是可以的&＃xff0c;cpu密集的时候适合用多进程

多进程的并发

importtime

import multiprocessing #导入多重处理模块

deftest1():

for i in range(10):

time.sleep(1)

print(&＃39;test1&＃61;&＃61;&＃61;&＃61;>&＃39;, i)

deftest2():

for i in range(10):

time.sleep(1)

print(&＃39;test2&＃61;&＃61;&＃61;&＃61;>&＃39;, i)

if __name__&＃61;&＃61;&＃39;__main__&＃39;: #main的固定格式&＃xff0c;如果没有将报错不支持

p1 &＃61; multiprocessing.Process(target&＃61;test1) #进程1的调用

p2 &＃61; multiprocessing.Process(target&＃61;test2) #进程2的调用

p1.start()

p2.start()

一这两个进程任务为例&＃xff0c;如果cpu核数>&＃61;2&＃xff0c;那么就是真真正正的 并行

运行结果&＃xff1a;

以此类推

进程之间是相互独立的

importmultiprocessing

importtime

g_num &＃61;0

def update(): #写函数

globalg_num

for i in range(100):

g_num &＃43;&＃61; 1

print(g_num)

def reader(): #读函数

print(g_num)

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

p1 &＃61; multiprocessing.Process(target&＃61;update)

p2 &＃61; multiprocessing.Process(target&＃61;reader)

p1.start()

p2.start()

运行结果&＃xff1a;

&＃xff0c;由此看出读函数没有读到写函数更改的内容&＃xff0c;所以得出&＃xff0c;进程之间互相独立&＃xff0c;互不影响

进程池

什么时候用进程池&＃xff1f;

当不知道有多少个进程池要跑的时候&＃xff0c;用进程池最合适。

importmultiprocessing

from multiprocessing import Pool #或者用 multiprocessing.Pool()&＃xff0c;再给他赋变量

importtime

importthreading

g_num &＃61;0

deftest1(n):

for i inrange(n):

time.sleep(1)

print(&＃39;test1&＃39;, i)

deftest2(n):

for i inrange(n):

time.sleep(1)

print(&＃39;test2&＃39;, i)

if __name__ &＃61;&＃61; &＃39;__main__&＃39;:

pool &＃61; Pool() #声明进程池 #括号内没有声明进程数&＃xff0c;默认无限(根据电脑配置情况)

pool.apply_async(test1, (10,)) #使用方法并且加参数

pool.apply_async(test2, (10,))

pool.close() #进程池关闭

pool.join() #进程池等待(注意的是&＃xff1a;join必须放在close后边)

这就是进程池的并发&＃xff0c;运行结果&＃xff1a;

等等

协程

进程是资源分配的单位&＃xff0c;切换需要的资源最大&＃xff0c;效率低

线程是操作系统调度的单位&＃xff0c;切换需要的资源一般&＃xff0c;效率一般

协程是寄生在线程里的&＃xff0c;所以协程切换任务资源很小&＃xff0c;效率高。IO操作密集的时候首选协程

多进程、多线程根据cpu核数不一样可能是并行的&＃xff0c;但是协成在一个线程中

协程&＃xff0c;其实就是串行

例&＃xff1a;

importgevent,time

deftest1():

for i in range(10):

time.sleep(1) #遇见延迟就切换

print(&＃39;test1&＃39;, i)

deftest2():

for i in range(10):

time.sleep(1) #遇见延迟就切换

print(&＃39;test2&＃39;, i)

g1 &＃61; gevent.spawn(test1) #声明实例&＃xff0c;调用函数的方法就是spawn

g2 &＃61;gevent.spawn(test2)

g1.join() #调用方式join&＃xff0c;不是start

g2.join()

运行结果&＃xff1a;依次出现

&＃xff0c;由此看出是串行

协程&＃xff0c;可以自动切换

由于协程工作时遇见延迟就会切换&＃xff0c;所以会在test1&＃xff0c;test2来回切换&＃xff0c;因为test1延迟1秒&＃xff0c;test2&＃xff0c;延迟2秒&＃xff0c;所以会按照2个test1&＃xff0c;一个test2 的规律打印

importgevent,time

#from gevent import monkey #打个补丁支持time.sleep()#monkey.patch_all() #让gevent支持time.sleep()

deftest1():

for i in range(10):

#time.sleep(1) #遇见延迟就切换

gevent.sleep(1) #延迟1秒

print(&＃39;test1&＃39;, i)

deftest2():

for i in range(10):

#time.sleep(2) #遇见延迟就切换

gevent.sleep(2) #延迟2秒

print(&＃39;test2&＃39;, i)

g1 &＃61; gevent.spawn(test1) #声明实例&＃xff0c;调用函数的方法就是spawn

g2 &＃61;gevent.spawn(test2)

g1.join() #调用方式join&＃xff0c;不是start

g2.join()

运行结果&＃xff1a;