python并发编程调优_python并发编程

并发编程是我们编程中常用的优化程序性能的手段，能提高CPU的使用率。一般使用是多线程，多进程，协程

一、python的全局解释锁GIL

我们目前跑的python程序大多数都是在cpython上运行的。cpython是有一个全局解释锁，具体什么意思，可以两个方面理解

在同一时刻，只能运行一个线程

无法将多个线程映射到多个cpu上运行

也就是说python多线程是有一定局限性的，对于io密集型的任务，我们可以很好的利用多线程，对于计算密集型的任务，多线程就没有意义了，只能利用多进程提高性能

二、简单多线程编程

第一种形式：使用threading库，直接使用Thread类

fromthreading import Thread

import time

def fun(n):

#dosomething

time.sleep(n)

print(n)

t1= Thread(target=fun, args=(1,))

t2= Thread(target=fun, args=(2,))

# 启动线程

t1.start()

t2.start()

# 等待线程结束

t1.join()

t2.join()

第二种形式：使用threading库，继承Thread类

fromthreading import Thread

import timeclassMyThread(Thread):

def __init__(self, n):

self.n=n

super().__init__()

def run(self):

time.sleep(self.n)

print(self.n)

t1= MyThread(1)

t2= MyThread(2)

t1.start()

t2.start()

t1.join()

t2.join()

三、线程安全

多个线程在同一个进程中运行时，是共享内存空间的，这就有可能引起一个线程在修改一个变量到一半的时候去休息了，回来的时候发现这个变量变了，这就会产生问题

如何保证线程安全，一般有下面几个方法

使用私有变量，每个线程都只知道自己的变量，其他线程无法修改，一般通过局部变量实现

通过拷贝数据到自己的空间，自己修改自己拷贝的数据，这样不会影响其他线程，一般通过thread.local实现

控制共享变量的访问方式，同一时刻只能有一个线程修改，一般通过加锁实现

还有一些其他方法保证线程安全，不同的场景，保证线程安全的方法也不同，需要合理采用。下面用代码说明一下

首先，我们不加锁，有两个线程共同操作一个共享变量

# 没有使用锁的情况fromthreading import Thread

n= 0def add():globalnfor i in range(1000000):

n+= 1def sub():globalnfor i in range(1000000):

n-= 1t1= Thread(target=add)

t2= Thread(target=sub)

t1.start()

t2.start()

t1.join()

t2.join()

print(n)

输出的结果，发现不是我们想象中的0，这就是因为两个线程运行期间，一个线程把 对n的操作执行到一半时候，去休息了，回来继续执行剩下一半的过程中，另一个线程修改了n，这样就造成了线程不安全的问题，最后的结果不一致。

加锁后的代码

fromthreading import Thread, Lock

n= 0

lock =Lock()

def add(lock):globalnfor i in range(1000000):lock.acquire()

n+= 1

lock.release()

def sub(lock):globalnfor i in range(1000000):lock.acquire()

n-= 1

lock.release()

t1= Thread(target=add, args=(lock,))

t2= Thread(target=sub, args=(lock,))

t1.start()

t2.start()

t1.join()

t2.join()

print(n)

这次输出的结果都是0了，我们在整个修改共享变量的过程中，加了锁，在锁未释放的时候，其他线程是运行不了的

四、线程间通信

上面我们知道存在线程安全的问题，所以通信的过程中，我们要考虑线程安全的问题

线程间通信最常用的是队列，python提供了一个线程安全的队列，from queue import Queue，在多个线程之间操作队列里的元素都是安全的

还有更加复杂的线程通信机制，比如条件变量，信号量等，python也提供了相应的模块

五、线程池

有时候，我们有很多条数据，我们希望同一时刻总共有5个线程来处理这一批数据，一个线程结束后，再启动另一个线程，总数不能超过5个，这时候线程池就可以很好的解决我们的问题了

fromconcurrent.futures.thread import ThreadPoolExecutorfromconcurrent.futures import wait

import time

pools= ThreadPoolExecutor(5)

data= list(range(20))

res=[]

def fun(n):

time.sleep(2)

print(n)returnnfor n indata:

res.append(pools.submit(fun, n))

# 等待所有线程执行完毕

wait(res)

线程池还给我们提供了更多的功能，我们可以获取线程返回的结果

fromconcurrent.futures.thread import ThreadPoolExecutorfromconcurrent.futures import as_completed

import time

pools= ThreadPoolExecutor(5)

data= list(range(20))

res=[]

def fun(n):

time.sleep(2)returnnfor n indata:

res.append(pools.submit(fun, n))

# 获取线程结束后的结果for r inas_completed(res):

print(r.result())

六、多进程编程

关于python多进程，在大多数业务开发中，用的比较少，我只给出一个简单的例子(实际上进程在运行的时候比这个负责，是会拷贝一份父进程的信息的)

frommultiprocessing import Process

import time

def fun(n):

#dosomething

time.sleep(n)

print(n)if __name__ == "__main__":

p1= Process(target=fun, args=(1,))

p2= Process(target=fun, args=(2,))

p1.start()

p2.start()

p1.join()

p2.join()

七、总结

并发编程是我们提高程序性能的常用手段，一般来说就是多线程，多进程，协程，并发编程的时候，我们还有许多问题需要考虑，线程安全，通信等等。