10、数据共享

除了上面的通过Queue队列文件进行数据共享外

还可以使用Manager（list列表，dict字典）进行进程之间的共享数据

from multiprocessing import Process,Manager,Lock
def work(data,lock):# 1.正常写法"""lock.acquire()# data["count"] -= 1data[0] += 1lock.release()"""# 2.使用with 语法简化上锁解锁操作with lock:data[0] += 1if __name__ == "__main__":m = Manager()# 创建一个共享的字典data = m.dict( {"count":20000} )# 创建一个共享的列表data = m.list([1,2,3])# print(data)lst = []lock = Lock()for i in range(100):p = Process(target=work,args=(data,lock))p.start()lst.append(p)# 确保所有的进程执行完毕,然后在向下运行,打印数据,否则报错;for i in lst:i.join()print(data) # [101, 2, 3]

廿三、线程

线程是计算机中调度的最小单位

线程的特点：线程比较轻量级，能干更多的活，一个进程中的所有线程资源是共享的

注：一个进程至少有一个线程在工作

目前配置最高的主机，5万个并发已经是上线

1、线程的基本使用

（1）一份进程资源中可以包含多个线程

（2）多线程的速度远远快于多进程

（3）多线程：共享同一份进程资源

（4）用类定义线程：继承线程父类Thread

from threading import Thread
from multiprocessing import Process
import os# (1)
def func(num):print('当前线程{},所归属的进程id号{}'.format(os.getpid(),num))for i in range(10):# 异步创建10个子线程t = Thread(target=func,args=(i,))t.start()# 主线程执行任务
print(os.getpid())# (2)
import time
def func(num):print('当前线程{}，所归属的进程id号{}'.format(num, os.getpid()))if __name__ == "__main__":starttime = time.time()lst = []for i in range(100):t = Thread(target=func, args=(i,))t.start()lst.append(t)for i in range(100):p = Process(target=func, args=(i,))p.start()lst.append(p)for i in lst:i.join()endtime=time.time()print("多线程执行时间：", endtime-starttime)# (3)
num =1000
def func():global numnum -=1for i in range(1000):t=Thread(target=func)t.start()print(num)# (4)
class MyThread(Thread):def __init__(self,name):# 手动调用父类的构造方法super().__init__()self.name = namedef run(self):time.sleep(1)print("当前进程正在执行runing ... " , self.name)if __name__ == "__main__":t = MyThread("机器今天会再次爆炸么?")t.start()print("主线程执行结束 ... ")

2、线程的缺陷

python中的线程可以并发但不能并行；同一个进程下的多个线程不能分开被多个cpu同时执行

原因：

​ 全局解释器锁(Cpython解释器特有)GIL锁：同一时间一个进程下的多个线程只能被一个cpu执行

​ python是解释型语言，不能一次性全部编译成功，不能提前规划，都是临时调度，容易造成cpu执行调度异常，所以加了一把锁叫GIL

实现并行的方法：

​ （1）用多进程间接实现线程的并行

​ （2）换一个Pypy，Jpython解释器

线程分为计算密集型和IO密集型：

​ 计算密集型会大量占用cpu资源，对于python来说负担大

​ IO密集型像网页，爬虫，OA办公，python处理起来就很方便

3、线程的相关函数

（1）is_alive()：检测线程是否仍然存在

（2）setName()：设置线程名

（3）getName()：获取线程名

（4）currentThread().ident：查看线程id号

（5）enumerate()：返回目前正在运行的线程列表

（6）activeCount()：返回目前正在运行的线程数量

# 
def func():time.sleep(1)
if __name__ == "__main__":t = Thread(target=func)t.start()print(t.is_alive()) # Falseprint(t.getName())t.setName("1234")print(t.getName())# currentThread().ident
def func():print("子线程id",currentThread().ident  , os.getpid())if __name__ == "__main__":Thread(target=func).start()print("主线程id",currentThread().ident , os.getpid())# enumerate(),activeCount()
from threading import enumerate
from threading import activeCount # (了解)
def func():print("子线程id",currentThread().ident  , os.getpid())time.sleep(0.5)if __name__ == "__main__":for i in range(10):Thread(target=func).start()lst = enumerate()print( activeCount() )

4、守护线程

注：等待所有线程全部执行完，才终止程序，守护的是所有线程

from threading import Thread
import time
def func1():while True:time.sleep(0.5)print("我是func1")def func2():	print("我是func2 start ... ")time.sleep(3)print("我是func2 end ... ")t1 = Thread(target=func1)
t2 = Thread(target=func2)# 在start调用之前,设置守护线程
t1.setDaemon(True)t1.start()
t2.start()print("主线程执行结束 ... ")

5、线程锁

Lock和信号量Semaphore

保证线程数据安全

注：在创建线程的时候是异步创建，在执行的时候因为Semaphore加了锁，所以线程之间变成同步

# Lock
from threading import Lock,Thread
import time
n = 0def func1(lock):global nlock.acquire()for i in range(1000000):# 方法一		n -= 1lock.release()def func2(lock):global n# with 自动完成上锁+解锁with lock:for i in range(1000000):# 方法二				n += 1if __name__ == "__main__":lst = []lock = Lock()time1 = time.time()for i in range(10):t1 = Thread(target=func1,args=(lock,))t2 = Thread(target=func2,args=(lock,))t1.start()t2.start()lst.append(t1)lst.append(t2)# 等待所有的子线程执行结束之后, 在打印数据for i in lst:i.join()time2 = time.time()print("主线程执行结束..." , n ,time2 - time1)# semaphore
from threading import Semaphore,Thread
import timedef func(i,sm):with sm:	print(i)time.sleep(3)if __name__ == "__main__":sm = Semaphore(5)for i in range(20):Thread(target=func,args=(i,sm)).start()