2. threading.local的作用？ import threading # 创建全局ThreadLocal对象: localVal = threading.local() localVal.val = "Main-Thread" def process_student(): print( '%s (in %s)' % (localVal.val, threading.current_thread().name)) def process_thread(name): #赋值 localVal.val = name process_student() t1 = threading.Thread(target= process_thread, args=('One',), name='Thread-A') t2 = threading.Thread(target= process_thread, args=('Two',), name='Thread-B') t1.start() t2.start() t1.join() t2.join() print(localVal.val) #打印结果： ''' One (in Thread-A) Two (in Thread-B) Main-Thread ''' ''' threading。local()这个方法:用来保存一个全局变量，但是这个变量只能被当前线程访问 localVal.val = name这条语句可以储存一个变量到当前线程，如果在另外一个线程里面再次 对localVal.val进行赋值，那么会在另外一个线程单独创建内存空间来存储，也就是说在不同 的线程里面赋值 不会覆盖之前的值，因为每个线程里面都有一个单独的空间来保存这个数据, 而且这个数据是隔离的，其他线程无法访问。本质上是在不同的线程在使用这个方法的时候为其 创建了一个独立的内存空间！ ''' ''' 用处; 多线程下载，实现同时下载多个歌曲，用这个方法来保存每个下载线程的数据 ''' 3. 进程之间如何进行通信？ 可以利用queue,joinablequeue，pipe来实现 7、多道技术 最初：操作系统将硬盘中的应用程序一个个读到内存，操作系统将内存中的应用程序交给cpu执行 ，遇到io就等待。 多道技术：将硬盘上的多个数据全部读到内存中，操作系统为其划分不同的内存空间，此时不同内存空间内的应用程序，内存空间，操作系统对其的调度称为进程。 空间复用:由于将不同的程序放到不同的内存空间，实现了空间复用 时间复用：一个程序遇到io阻塞，操作系统会切换另外一个进程，交给cpu去执行 ，实现了时间复用 8、分时系统 即使当前在cpu里运行的程序没有遇到io,操作系统会在一定的时间后自动切换为另外一个进程 ，这样的切换其实没有提高cpu的效率，牺牲了一些效率，但是实现了多个程序共同执行的效果。 9、进程的概念 进程 是指应用程序，内存空间，操作系统的调度 称为一个进程。 竞争计算机系统有限资源的基本单位，进行处理机调度的基本单位。 10、并发与并行 并发：单个cpu下+多道技术就可以实现并发， 并行：同时运行，多核cpu才能实现并行 11、同步 异步 同步：提交任务后等待任务的返回结果，导致下一个任务只能在上一个任务结束后才能运行 异步：，任务的提交互不影响 12、阻塞 非阻塞 阻塞：遇到io操作 等待是阻塞的副作用 非阻塞：没有遇到io操作 13、同步阻塞 同步非阻塞 异步阻塞 异步非阻塞 同步阻塞：相当于一个线程在等待 同步非阻塞：相当于一个线程在正常运行 异步阻塞：多个线程都在等待 异步非阻塞：多个线程都在正常运行。 14、io 指的是读入和写出数据的过程，和等待读入/写出数据的过程，一旦拿到数据后就变成数据 操作了，就不是io了。即一个是等待数据的过程，一个是读写拷贝数据的过程。 15、阻塞io 非阻塞io 阻塞io:用户线程被阻塞在等待数据或拷贝数据上 非阻塞io:用户线程没有因为io的事情出现阻塞，即数据已经拷贝好后，采取通知用户线程，一上来将就可以直接操作数据 16、同步io 同步阻塞io 同步io指的是发起io请求后，必须拿到io的数据才能继续执行。 同步阻塞io: 在等待数据和拷贝数据过程中，线程都在阻塞，这就是同步阻塞io; 在等待数据的过程中，线程采用死循环式轮询，在拷贝数据的过程，线程在阻塞！ 在io上，同步和非阻塞是互斥的，所以不存在同步非阻塞io. 所以，同步io一定是阻塞io,同步io也就是同步阻塞io. 17、异步io 和 异步阻塞/非阻塞io 异步io 发起io请求后，不用拿到io数据就可以继续执行。 异步阻塞io:等待数据的过程，用户线程继续执行，拷贝数据的过程 ，线程在阻塞。 异步非阻塞io: 等待和拷贝的过程中，用户线程都在继续执行。 本质上是因为用户线程既没有参与 等待，也没用参与拷贝的过程，所以是异步的。当其接到通知时，数据已经准备好了！没有因为io而阻塞，所以是非阻塞的。 18、进程的创建： 1）、系统初始化(前台进程负责与用户交互，后台 运行的进程与用户无关，运行在后台且需要时才被唤醒的进程，称为守护进程，如电子邮件，web页面) 2）、一个进程在运行过程中开启了子进程，如nginx开启多进程 3）、用户的交互式请求，如双击暴风影音 4）、一个批处理作业的初始化 19、进程的结束; 正常退出 出错退出 严重错误 try...except捕获异常 被其他进程杀死 20、进程的同步部分 进程之间数据不共享，但是共享同一套文件系统，同一个打印终端，共享带来的就是竞争，竞争带来的就是数据紊乱，可以加锁处理 例如：开启多进程打印时，终端显示的数据有先有后，可以选择加锁让数据排列的整齐一些。 21、进程的数据共享，进程间的数据通信 1）、基于queue队列拉实现 from multiprocessing import Queue q = Queue(3) q.put(3) q.put(3) q.put(3) #q.put(4) 再放一个，队列已满，程序会停在这，直到数据被取走 try: q.put_nowait(3) # 使用这种 格式，队列满了不会阻塞，但是会直接报错 except: print('队列满了') # 因此可以在取数据之前查看队列的状态 print(q.full()) # 满了就True,否则为False print(q.get()) print(q.get()) print(q.get()) # print(q.get()) # 和put类似，队列空了的话，再取会阻塞 try： q.get_nowait(3) # 可以使用这种格式，队列空了不会阻塞，但是会直接报错 except: print('队列已空') #关于q.empty() # 在空队列上放置q.empty时，可能会返回True,因为存在无限小的延迟。 # 基于队列生产者消费者模型，在队列空了以后，程序会阻塞，进程不会结束。消费者在取空队列后，一直处于死循环中的等待数据被生产！ 2） JoinableQueue from multiprocessing import JoinableQueue, Process import random, time def producer(name, food, q): for i in range(5): data = '%s拉出了%s,%s' % (name, food, i) time.sleep(random.randint(1, 3)) print(data) q.put(data) # 将数据放入队列中 def consumer(name, q): while True: data = q.get() time.sleep(random.randint(1, 3)) print('%s消化了%s' % (name, data)) q.task_done() # 告诉队列，已经将数据取出并消化完毕 if __name__ == '__main__': q = JoinableQueue() # 生产一个队列对象 a1 = Process(target=producer, args=('tank', '披萨', q)) a2 = Process(target=producer, args=('egon', '面包', q)) b1 = Process(target=consumer, args=('owen', q)) b2 = Process(target=consumer, args=('fuck', q)) a1.start() a2.start() b1.daemon = True b2.daemon = True b1.start() b2.start() # 等待生产者生产完所有的数据 a1.join() a2.join() # 等待队列里的数据全部取出 q.join() print('主进程') ''' q.join():生产者调用该方法进行阻塞，直到队列里的所有数据全部被拿走， 阻塞将持续到队列里每一个项目均调用q.task_done()方法为止，也就是队列里的所有数据都被get取走了 ''' 3)、管道 from multiprocessing import Process,Pipe def f(conn): conn.send('hello boy') # 子进程发送的消息，任何数据类型都可以 conn.close() if __name__ == '__main__': parent_conn,child_conn = Pipe() # 建立管道，拿到管道的两端，双方都可以收发数据 p = Process(target=f,args=(child_conn,)) p.start() print(parent_conn.recv()) # 主进程接收的消息 p.join() ''' 管道通信不安全： 返回的两个通信对象，每个对象都有recv和send方法。 如果两个进程或线程在同一端读取或写入数据，那么管道中的数据可能会损坏！ ''' 22、信号量 Semaphore 23、event事件 24、全局解释器锁GIL 这是 针对cpython而言的，为了保证在同一时间内只能存在一个线程去执行。我程序员控制的同步数据是针对于可见的变量，而GIL同步的是解释器后台爱的不可见变量，例如为了进行垃圾回而维护的引用计数，如果没有GIL,那么可能出现线程切换导致对同一个对象释放两次的情况！GIL是解释器相关的，而不是python这种语言的特性！ 存在的意义： 相当于执行权限，保护着线程之间共享的数据； 拿到gil后才能拿到互斥锁，其他线程也可以拿到gil,但是发现互斥锁没有被释放的话，gil权限要立刻交出来！ 25、互斥锁 用来实现对共享资源的同步访问。 import threading r = reading.Lock() r.acquire() ''' 对公共数据的操作部分 ''' r.release() 26、死锁 两个或者两个以上的进程或线程在执行过程中，抢夺资源而造成的一种互相等待的现象，若无外力干预下，将一直保持这种状态！ 解决;采用递归锁 27、递归锁 from threading import Rlock Rlock内部维持着一个Lock和counter变量，后者记录acquire的次数，从而可以使得资源被多次require, 直到一个线程所有的acquire都被release，其他线程才能获得资源 28、线程之间的通信 线程队列 ''' import queue 队列 q = queue.Queue(3) # 里面的参数可以不传 q.put(1) q.put(2) q.put(3) try: q.put_nowait(4) except: print('队列已满') print(q.get()) print(q.get()) print(q.get()) try: print(q.get_nowait()) except: print('队列已空') # 结果 为先进先出 ''' ''' import queue q = queue.LifoQueue() # 类似于栈 q.put(1) q.put(2) q.put(3) #q.put_nowait() print(q.get()) print(q.get()) print(q.get()) # print(q.get_nowait()) #结果：先进后出 ''' ''' import queue q = queue.PriorityQueue() # 排序 q.put((10,'a')) q.put((11,'b')) q.put((12,'a')) print(q.get()) print(q.get()) print(q.get()) #对于优先级，元组里的第一个元素通常是数字，也可以是非数字之间去比较大小 #比较的结果中，该元素越小，优先级越高 ''' 29、线程池 进程池 concurrent.futures模块提供了高度封装的 异步调用接口 from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor pool = ThreadPoolExecutor() pool.submit(fn,*args,**kwargs).add_done_callback(fn) 小点： map (func,*iterables,timeout=None) 取代佛如循环submit的操作 add_done_callback(fn)：回调函数 result；回调函数拿到的形参.result 可以拿到上一个函数的返回值。 shutdown（wait=True) 相当于进程池的pool.close()+pool.join()操作 wait = True 等待池里所有的任务执行完毕回收完资源后才继续 wait = False 立即返回，不等待池子里的所有线程结束。 但是不管wait为何值，整个程序都会等所有任务执行完毕。 submit和map需在sutdown之前。 30、协程 本质上是线程，之前线程任务的切换是由操作系统来完成的，遇到io就切换，现在我们自己可以利用协程实现 较操作系统来切换更少的开销。主要是用在 开关线程，创建寄存器，堆栈等，自己用程序去控制任务的切换！ 协程是一个用户态的轻量级的线程，线程由用户程序区控制调度。 1）、关于生成器的知识点瑕疵复习的时候再去研究！！ 2）、yield实现协程 - 任务的切换与保存 import time def consumer(): while True: x = yield time.sleep(1) print('接收了数据{}'.format(x)) def producer(): g = consumer() next(g) # 需要先得到初始化一次的生成器 for i in range(10000): g.send(i) print('发送了数据{}'.format(i)) start = time.time() producer() end = time.time() print(end-start) ''' 实际上利用yield仅仅只是实现了切换与保存状态，即并发的效果 并没有节省i/o时间，没有提高效率 ''' 3)、Greenlet 对于上者，可以利用该模块去实现，不过同样遇到io就原地阻塞。没有实现遇到io就自动切换的功能 4）、协程所在的库 Gevent Gevent是一个第三方库，可以通过其实现并发同步和 异步编程。 4.1）简单用法: import gevent def eat(name): print('%s eat 1'%name) gevent.sleep(2) print('%s eat 2'%name) def play(name): print('%s play 1'%name) gevent.sleep(1) print('%s play 2'%name) if __name__ == '__main__': g1 = gevent.spawn(eat,'michael') g2 = gevent.spawn(play,'tank') gevent.joinall([g1,g2]) print('主线程') # 结果： ''' michael eat 1 tank play 1 tank play 2 michael eat 2 主线程 ''' ''' 之所以用到 gevent.sleep() 是因为gevent可以识别这种类型的阻塞 而time.sleep()或者其他类型的 阻塞是不能直接识别的，必须加上补丁 ''' 4.2）、gevent之同步异步： from gevent import spawn, joinall, monkey monkey.patch_all() import time def task(pid): time.sleep(1) print('task %s done' % pid) def synchronous(): # 同步 for i in range(10): task(i) def asynchronous(): # 异步的 g_l = [spawn(task, i) for i in range(10,20)] joinall(g_l) if __name__ == '__main__': print('synchronous:') synchronous() print('asynchronous:') asynchronous() ''' 上面程序先是执行synchronous，然后在执行asynchronous 后者内部是协程，遇到阻塞通过协程实现自动切换，从而达到单线程下实现并发的效果 '''