线程,进程和协程
线程
线程的概念
并发
任务数大于cpu核载,通过系统的各种任务跳读算法,是任务“在一起”执行任务！ 假的多任务
并行
任务数小于cpu核数，即任务真的在一起执行
多线程
1 同时执行
下面例子中test1和test2是同时执行
import threading import time def tes1(): for i in range(3): print("--test1--%d" % i) time.sleep(1) def tes2(): for i in range(3): print("--test2--%d" % i) time.sleep(1) if __name__ == "__main__": t1 = threading.Thread(target=test1) t2 = threading.Thread(target=test2) t1.start() # 启动线程,让线程开始执行 t2.start() # 执行结果 --test1--0 --test2--0 (间隔1秒) --test1--1 --test2--1 (间隔1秒) --test1--2 --test2--2
2 顺序执行
test1先执行,test2后执行
import threading import time def tes1(): for i in range(3): print("--test1--%d" % i) def tes2(): for i in range(3): print("--test2--%d" % i) if __name__ == "__main__": t1 = threading.Thread(target=test1) t2 = threading.Thread(target=test2) t1.start() time.sleep(1) print("test1 is over") t2.start() time.sleep(1) print("test2 is over") # 执行结果 --test1--0 --test1--1 --test1--2 (间隔1秒) test1 over --test2--0 --test2--1 --test2--2 (间隔1面) test2 over
多线程全局变量
全局变量
import threading import time g_num = 100 def test1(): global g_num g_num += 1 print("--in test1 g_num=%d" % g_num) def test2(): print("--in test2 g_num=%d" % g_num) if __name__ == "__main__": t1 = threading.Thread(target=test1) t2 = threading.Thread(target=test2) t1.start() time.sleep(1) t2.start()+ time.sleep(1)
去函数那个笔记了解全局变量
多线程全局变量实参
import threading import time g_num = 100 def test1(temp): #传递实参的方式 temp.append(33) print("--in test1 temp=%s" % str(temp)) 545. def test2(): print("--in test2 temp=%s" % str(temp)) g_num = [11,22] if __name__ == "__main__": # 创建线程 t1 = threading.Thread(target=test1, args=(g_num,)) t2 = threading.Thread(target=test2, args=(g_num,)) t1.start() time.sleep(1) t2.start() time.sleep(1)
多线程共享全局变量资源竞争
import threading import time g_num = 0 def test1(): glibal g_num for i in range(num): g_num += 1 print("--in test1 g_num=%d" % g_num) def test2(): glibal g_num for i in range(num): g_num += 1 print("--in test2 g_num=%d" % g_num) if __name__ == "__main__": # 创建线程 t1 = threading.Thread(target=test1,args=(100,)) t2 = threading.Thread(target=test2,args=(100,)) # t1 = threading.Thread(target=test1,args=(10000,)) # t2 = threading.Thread(target=test2,args=(10000,)) t1.start() t2.start()
多线程解决全局变量资源竞争01
使用互斥锁
import threading import time g_num = 0 def test1(): glibal g_num # 上锁,如果之前没有上锁,那么此时上锁成功 # 如果之前上过锁,那么就会堵塞在这里,知道这个锁解开为止 muext.acquire() for i in range(num): g_num += 1 # 解锁 muext.release() print("--in test1 g_num=%d" % g_num) def test2(): glibal g_num muext.acquire() for i in range(num): g_num += 1 muext.release() print("--in test2 g_num=%d" % g_num) # 建立一个互斥锁,默认是没有上锁的 muext = threading.Lock() if __name__ == "__main__": t1 = threading.Thread(target=test1,args=(10000,)) t2 = threading.Thread(target=test2,args=(10000,)) t1.start() t2.start() # 上述代码上锁和解锁在for循环外，解释：子线程t1和t2不知道谁先执行,假如是t1先执行,在上锁的后,一直执行for循环，知道循环结束为止然后在解锁，在执行t2此时全局变量从0变成了10000,直到for循环结束解锁变成2000，程序解锁
多线程解决全局变量资源竞争02
import threading import time g_num = 0 def test1(): glibal g_num for i in range(num): muext.acquire() g_num += 1 muext.release() print("--in test1 g_num=%d" % g_num) def test2(): glibal g_num for i in range(num): muext.acquire() g_num += 1 muext.release() print("--in test2 g_num=%d" % g_num) muext = threading.Lock() if __name__ == "__main__": t1 = threading.Thread(target=test1,args=(10000,)) t2 = threading.Thread(target=test2,args=(10000,)) t1.start() t2.start() # 如果上锁和解锁在for循环内部，不管t1和t2谁先执行，每次执行+1结束后解锁，然后在分配t1和t2谁先执行，这个先后是没有规律的,可能是t1执行很多次之后再是执行t2，可能反之,所以其中一个是for循环执行结束后得到20000，但是另外一个一定是执行10000后还在叠加
多任务版UDP聊天
import socket import threading if __name__ == "__main__": # 创建套接字 udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定端口 udp_socket.bind(("", 7788)) # 获得对方ip和port dest_ip = input("请输入ip：") dest_port = input("请输入port：") # 接受数据 while True: recv_data = udp_socket.recvfrom(1024) print(recv_data) # 发送数据 while True: send_data = input("输入数据:") udp_socket.sendto(send_data.encode("utf-8"), dest_ip,dest_port) # 利用多线程 import socket import threading def recv_msg(udp_socket): # 接受数据 while True: recv_data = udp_socket.recvfrom(1024) #print(recv_data) print("[%s]:%s" %(recv_data[1], str(recv_data[0].decode("utf-8")))) # 显示发送的对方地址和信息 def send_msg(udp_socket,dest_ip,dest_port): # 发送数据 while True: send_data = input("输入数据:") udp_socket.sendto(send_data.encode("utf-8"), dest_ip,dest_port) if __name__ == "__main__": # 创建套接字 udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定端口 udp_socket.bind(("", 7788)) # 获得对方ip和port dest_ip = input("请输入ip：") dest_port = int(input("请输入port：")) # 注意 t_recv = threading.Thread(target=recv_msg, args=(udp_socket,)) t_send = threading.Thread(target=send_msg, args=(udp_socket,dest_ip,dest_port)) t_recv.start() t_send.start()
进程
进程的概念
一个程序运行起来,代码+用到的资源称之为进程，他是操作系统分配资源的基本单位元
导入multiprocessing模块
子进程的传递参数
import multiprocessing # import os # 导入路径模块 import time def test(a,b,c,*args, **kwargs): print(a) print(b) print(c) print(args) # 拆包(元组) print(kwargs) # 拆包(字典) if __name__ == "__main__": p = multiprocessing.Process(target=test, args=(1,2,3,4,5,6,7,8), kwargs={"name":"Lily"}) # 当导入元素和元组的时候，统一以元组的形式导入 # 当传入kwargs的时候，在创建p类的时候,传入字典形式 p.start()
多进程之间不共享全局变量
进程之间是两个独立的程序不共享全局变量
import multiprocessing import time nums = [1,2,3] #设定全局变量 def test1(): nums.append(4) # 利用方法改变全局变量 print("在test1中nums=%s" % str(nums)) def test2(): print("在test2中nums=%s" % str(nums)) if __name__ == "__main__": # 创建进程 p1 = multiprocessing.Proess(target=test1) p2 = multiprocessing.Proess(target=test2) p1.start() p1.join() # 确保p1在执行结束后再执行p2 time.sleep(1) # 或者是在p1执行后停顿1秒 p2.start() # 得出结果是test1中[1,2,3,4], test2中[1,2,3] # 在进程中不共享全局变量
进程和线程的区别
简单的对比
进程:能够完成多任务,例如一台电脑上可以运行多个QQ
(进程是系统进行资源的分配和调度的一个独立单位)
线程:能够完成多任务,例如在同一个QQ可以开多个聊天窗口
(线程属于进程,是进程的一个实体,是cpu调度和分配的基本单位,能更小的独立运行的基本单位，线程自己使用系统资源)
区别
1 一个程序至少有一个进程,一个进程至少有一个线程
2 线程的划分尺度小于进程(就是占用资源比进程少)
3 进程在执行过程中拥有独立的内存单元，而多个线程共享内存,提高工作效率
4 线程不能独立的运行，必须依存在进程中
5 进程就好比工厂的流水线,线程就好比流水线的员工
进程之间的通信-Queue队列
实例（仅限一台电脑或是服务器中的两个进程之间的数据共享）
import multiprocessing # 一个进程向Queue中写入数据,另一个进程从Queue获取数据 # 通过Queue完成了多歌需要配合进程间的数据共享 def down(q): # 下载数据 # 模拟在网上下载数据，就简单的创建下载好的列表 data = [1,2,3,4] # 向队列写入数据 for temp in data: q.put(temp) print("--数据已经存到队列中---") def fenxi(q): # 数据处理 fenxi_data = list() #或者是fenxi_list = [] # 向保存好的队列中获取数据 while True: new_data = q.get() # new_data是获取的数据 fenxi_data.append(new_data) # 判断：如果队被取空的话,就退出 if q.empty(): break if __name__ == "__main__": # 创建一个队列 q = multiprocessing.Queue() # 创建进程 # 传入实参队列在创建的子进程中调用q p1 = multiprocessing.Process(target=down, args=(q,)) p2 = muultiprocessing.Proess(target=fenxi, args=(q,)) p1.start() # p1.join() p2.start() # 以上操作有问题,创建的子进程p1和p2，不能确定那个子进程先运行，会导致p1还没有下载好，p2就直接获取数据，所以在p1.start()后添加一个p1.join(), p1.join()的功能就是让p1执行完之后再执行其他的进程
补充说明
初始化Queue()对象时(例如q=Queue())，有下列方法
q.put() # 向队列导入写入数据
q.get() # 向队列下载获取数据
q.empty() # 如果队列是空的,返回True, 反之False
q.full() # 如果列队满了,返回True,反之False
进程池
进程之间的通信
进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。广义上这也是进程间通信的手段，但是一般都不把这算作“进程间通信”。因为那些通信手段的效率太低了，而人们对进程间通信的要求是要有一定的实时性。
进程间通信主要包括管道, 系统IPC(包括消息队列,信号量,共享存储), SOCKET.
进程和线程区别
定义的区别：进程是系统进行资源分配和调度的一个独立的单位；线程是进程的实体，是cpu调度和分配的基本单位
一个程序至少有一个进程，一个进程至少有一个线程;
线程的划分尺度小于进程(资源比进程少)，使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率
线线程不能够独立执行，必须依存在进程中
可以将进程理解为工厂中的一条流水线，而其中的线程就是这个流水线上的工人
优缺点：线程执行开销小，效率高,，但不利于资源的管理和保护；而进程正相反。
协程
协程概念
用到更少的资源，：在一个线程中的某个函数，可以在任何地方保存当前函数的一 些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函 数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开 发者自己确定
协程和线程的区别
在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简 单。 操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数 据，操作系统还会帮你做这些数据的恢复操作。 所以线程的切换非常耗性 能。但是协程的切换只是单纯的操作CPU的上下，所以⼀秒钟切换个上百 万次系统都抗的住。
如何实现协程
1 生成器实现简单的协程
import time def f1(): while True: print("---1----") yield time.sleep(1) def f2(): while True: print("---2----") yield time.sleep(1) if __name__ == "__main__": ff1 = f1() ff2 = f2() while True: next(ff1) next(ff2)
2 greenlet实现协程 (了解)
from greenlet import greenlet import time def w1(): while True: print("---1---") ww1.switch() # 使用greenlet模块中swtich()方法 time.sleep(1) def w2(): while True: print("---1---") ww2.switch() # 使用greenlet模块中swtich()方法 time.sleep(1) if __name__ == "__main__": ww1 = greenlet(w1) ww2 = greenlet(w2) ww1.switch()
3 gevent实现协程（重要）
import gevent def f(n): for i in range(n): print(gevent.getcurrent(), i) g1 = gevent.spawn(f,5) g2 = gevent.spawn(f,5) g3 = gevent.spawn(f,5) g1.join() g2.join() g3.join() # 执行结果 <Greenlet "Greenlet-0" at 0x7f9e6251a748: f(5)> 0 <Greenlet "Greenlet-0" at 0x7f9e6251a748: f(5)> 1 <Greenlet "Greenlet-0" at 0x7f9e6251a748: f(5)> 2 <Greenlet "Greenlet-0" at 0x7f9e6251a748: f(5)> 3 <Greenlet "Greenlet-0" at 0x7f9e6251a748: f(5)> 4 <Greenlet "Greenlet-1" at 0x7f9e6251a948: f(5)> 0 <Greenlet "Greenlet-1" at 0x7f9e6251a948: f(5)> 1 <Greenlet "Greenlet-1" at 0x7f9e6251a948: f(5)> 2 <Greenlet "Greenlet-1" at 0x7f9e6251a948: f(5)> 3 <Greenlet "Greenlet-1" at 0x7f9e6251a948: f(5)> 4 <Greenlet "Greenlet-2" at 0x7f9e6251aa48: f(5)> 0 <Greenlet "Greenlet-2" at 0x7f9e6251aa48: f(5)> 1 <Greenlet "Greenlet-2" at 0x7f9e6251aa48: f(5)> 2 <Greenlet "Greenlet-2" at 0x7f9e6251aa48: f(5)> 3 <Greenlet "Greenlet-2" at 0x7f9e6251aa48: f(5)> 4 # 达成任务切换 import gevent def f(n): for i in range(n): print(gevent.getcurrent(), i) # 用来模拟一个耗时操作，不是用time模块 gevent.sleep(1) g1 = gevent.spawn(f,5) g2 = gevent.spawn(f,5) g3 = gevent.spawn(f,5) g1.join() g2.join() g3.join() # 执行结果 <Greenlet "Greenlet-0" at 0x7fc93b84d748: f(5)> 0 <Greenlet "Greenlet-1" at 0x7fc93b84d948: f(5)> 0 <Greenlet "Greenlet-2" at 0x7fc93b84da48: f(5)> 0 <Greenlet "Greenlet-0" at 0x7fc93b84d748: f(5)> 1 <Greenlet "Greenlet-1" at 0x7fc93b84d948: f(5)> 1 <Greenlet "Greenlet-2" at 0x7fc93b84da48: f(5)> 1 <Greenlet "Greenlet-0" at 0x7fc93b84d748: f(5)> 2 <Greenlet "Greenlet-1" at 0x7fc93b84d948: f(5)> 2 <Greenlet "Greenlet-2" at 0x7fc93b84da48: f(5)> 2 <Greenlet "Greenlet-0" at 0x7fc93b84d748: f(5)> 3 <Greenlet "Greenlet-1" at 0x7fc93b84d948: f(5)> 3 <Greenlet "Greenlet-2" at 0x7fc93b84da48: f(5)> 3 <Greenlet "Greenlet-0" at 0x7fc93b84d748: f(5)> 4 <Greenlet "Greenlet-1" at 0x7fc93b84d948: f(5)> 4 <Greenlet "Greenlet-2" at 0x7fc93b84da48: f(5)> 4
进程，线程和协程的对比(面试重点)
A 进程是资源分配的单位
B 线程是操作系统调度的单位
C 进程切换需要的资源最大，效率低
D 线程切换需要的资源一般，效率也很一般
E 协程切换任务资源小，效率高
F 多进程，多线程根据cpu的核数不一样可能并行，但是协程是在一个线程中，所以是并发的
G 进程不共享资源，线程共享资源
GIL(全局解释器锁)(面试重点)
每个线程在执行过程中都需要先获取GIL，保证同一时刻只有一个线程可以执行代码，所以线程是并发的，都是讲并发运行成串行，由此来控制同一时间内共享数据只能被一个任务修改，进而保证数据的安全!
底层知识
因为python的线程是调用操作系统的原生线程，这个原生线程就是C语言写的原生线程。因为python是用C写的，启动的时候就是调用的C语言的接口。因为启动的C语言的远程线程，那它要调这个线程去执行任务就必须知道上下文，所以python要去调C语言的接口的线程，必须要把这个上限问关系传给python，那就变成了一个在加减的时候要让程序串行才能一次计算。就是先让线程1，再让线程2.......
多线程用于IO密集型，如socket，爬虫，web
多进程用于计算密集型，如金融分析
互斥锁(面试重点)
当多个线程几乎同时修改一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全的竞争资源，最简单的同步机制就是引入互斥锁
如何运行：某个线程需要更改共享数据的时候，先锁定，此时资源状态为锁定状态，其他线程不能更改，直到该线程释放资源，将资源的状态变成非锁定状态，其他线程才能再次锁定该资源，互斥锁保证每次只有一个线程进行操作，从而保证多线程情况的数据正确性!
优点：确保某段关键代码只能有一个线程从头到尾完整的执行
缺点：A--阻止了多线程的并发，包含锁的某段代码只能以单线程的模式执行，效率大打折扣。B--由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方的锁，可能会造成死锁！