目录
一、进程（Process）
概念:一个正在运行的程序或者软件就是一个进程
进程（有时被称为重量级进程）是程序的一次执行。
每个进程都有自己的地址空间，内存，数据栈以及其它记录其运行轨迹的辅助数据。
操作系统管理在其上运行的所有进程，并为这些进程公平地分配时间。
进程也可以通过fork 和spawn 操作来完成其它的任务。不过各个进程有自己的内存空间，数据栈等，所以只能使用进程间通讯（IPC），而不能直接共享信息。
导入进程包
import multiprocessingtarget:执行的目标任务名
args:以元祖方式给执行任务传参
kwargs:以字典方法给执行任务传参
name:进程名字
启动进程
启动进程使用start方法、
代码
import time import multiprocessing # 导入多进程模块 def new_time(): # 格式化时间 return time.asctime(time.localtime(time.time())) def func(x): print("inner_time", new_time()) print(x) time.sleep(5) print("inner_end", new_time()) if __name__ == '__main__': print("outer_start", new_time()) # target : 执行的方法 args：传参 p1 = multiprocessing.Process(target=func, args=(2,)) # 实例化进程对象 p1.start() # 开启在子进程 time.sleep(5) print("outer_end", new_time()) outer_start Sun Apr 17 09:37:38 2022 inner_time Sun Apr 17 09:37:38 2022 2 outer_end Sun Apr 17 09:37:43 2022 inner_end Sun Apr 17 09:37:43 2022 参数代码
import multiprocessing import time # 跳舞任务 def dance(): for i in range(5): print("跳舞中....") time.sleep(0.2) # 唱歌任务 def sing(): for i in range(5): print("唱歌中....") time.sleep(0.2) if __name__ == '__main__': # 当程序自己运行自己的时候 # 创建跳舞的子进程 dace_process = multiprocessing.Process(target=dance, name="myprocees1") sing_process = multiprocessing.Process(target=sing) # 启动子进程执行对应的任务 dace_process.start() sing_process.start() 跳舞中.... 唱歌中.... 唱歌中.... 跳舞中.... 跳舞中.... 唱歌中.... 唱歌中.... 跳舞中.... 唱歌中.... 跳舞中.... print(dace_process.name)>>>myprocees1 print(sing_process.name)>>>Process-2(name可以自己命名)执行带有参数的任务
import multiprocessing multiprocessing.Process() # 显示信息的任务 def show_info(name, age): print(name, age) if __name__ == '__main__': # 创建子进程 # args:以元祖形式 args=("李四", 22) 如果是传入一个参数时，后面一定要加逗号 # kwargs:以字典形式,字典里面的key要和函数里面的参数名保持一致，没有顺序要求 sub_process = multiprocessing.Process(target=show_info, kwargs={'age':22,'name':'李四'} ) sub_process.start()
多进程模式最大的优点就是稳定性高，因为一个子进程崩溃了，不会影响主进程和其他子进程。（当然主进程挂了所有进程就全挂了，但是主进程只负责分配任务，挂掉的概率低）Apache最早就是采用多进程模式。
多进程模式的缺点是创建进程的代价大，在Unix/Linux系统下，用fork调用还行，在Windows下创建进程开销巨大。另外，操作系统能同时运行的进程数也是有限的，在内存和CPU的限制下，如果有几千个进程同时运行，操作系统连调度都会成问题。
二、线程（threading）
什么是线程？
线程（有时被称为轻量级进程）跟进程有些相似，
不同的是，所有的线程运行在同一个进程中，共享相同的运行环境。
它们可以想像成是在主进程或“主线程”中并行运行的“迷你进程”。
线程有开始，顺序执行和结束三部分。
它有一个自己的指令指针，记录自己运行到什么地方。
线程的运行可能被抢占（中断），或暂时的被挂起（也叫睡眠），让其它的线程运行，这叫做让步。
一个进程中的各个线程之间共享同一片数据空间，所以线程之间可以比进程之间更方便地共享数据以及相互通讯。
线程一般都是并发执行的，正是由于这种并行和数据共享的机制使得多个任务的合作变为可能。
实际上，在单CPU 的系统中，真正的并发是不可能的，每个线程会被安排成每次只运行一小会，然后就把CPU 让出来，让其它的线程去运行。
在进程的整个运行过程中，每个线程都只做自己的事，在需要的时候跟其它的线程共享运行的结果。
当然，这样的共享并不是完全没有危险的。如果多个线程共同访问同一片数据，则由于数据访问的顺序不一样，有可能导致数据结果的不一致的问题。这叫做竞态条件(racecondition)。幸运的是，大多数线程库都带有一系列的同步原语，来控制线程的执行和数据的访问。
另一个要注意的地方是，由于有的函数会在完成之前阻塞住，在没有特别为多线程做修改的情况下，这种“贪婪”的函数会让CPU 的时间分配有所倾斜。导致各个线程分配到的运行时间可能不尽相同，不尽公平
导入线程模块
import threading threading.Thread()target:执行的目标任务名
args:以元祖的方式给执行 任务传参
kwargs:以字典方法给执行任务传参
name;线程名，一般不用设置
启动线程
启动线程使用start方法
import time # import multiprocessing # 导入多进程模块 import threading # 导入线程模块 def new_time(): # 格式化时间 return time.asctime(time.localtime(time.time())) def func(x): print("inner_time", new_time()) print(x) time.sleep(5) print("inner_end", new_time()) if __name__ == '__main__': print("outer_start", new_time()) # target : 执行的方法 args：传参 # p1 = multiprocessing.Process(target=func, args=(2,)) # 实例化进程对象 # p1.start() # 开启在子进程 t1 = threading.Thread(target=func, args=(5,)) # 实例化线程对象 t1.start() # 启动在子线程 time.sleep(5) print("outer_end", new_time())线程带参数
import threading import time # 带有参数的任务 def task(count): for i in range(count): print("任务执行中....") time.sleep(0.2) else: print("任务执行完成") if __name__ == '__main__': # 创建子线程 # args :以元祖的方法给任务传入参数 # kwargs:以字典方式传入参数,要保证字典里面的key和函数胡的参数名保持一致 # sub_thread = threading.Thread(target=task, args=(5,)) sub_thread = threading.Thread(target=task, kwargs={'count':3}) sub_thread.start()小结
导入线程模块
import threading
创建子线程并执行的任务
启动线程执行任务
sub_thread.start()
多线程模式通常比多进程快一点，但是也快不到哪去，而且，多线程模式致命的缺点就是任何一个线程挂掉都可能直接造成整个进程崩溃，因为所有线程共享进程的内存。
在Windows上，如果一个线程执行的代码出了问题，你经常可以看到这样的提示：“该程序执行了非法操作，即将关闭”，其实往往是某个线程出了问题，但是操作系统会强制结束整个进程。
#coding=utf-8
import threading
from time import ctime,sleep
import time
def func1(arg):
time.sleep(1)
print("Hi %s. %s" %(arg,ctime()))
def func2(arg):
time.sleep(5)
print("Hello %s! %s" %(arg,ctime()))
threads = []
t1 = threading.Thread(target=func1,args=(u'C语言',))
threads.append(t1)
t2 = threading.Thread(target=func2,args=(u'python',))
threads.append(t2)
if __name__ == '__main__':
for t in threads:
#t.setDaemon(True)
t.start()
# 等待所有线程完成
for t in threads:
t.join()
print("all over %s" %ctime())
三、协程（gevent）
什么是协程： 协程，又称微线程，纤程。英文名Coroutine。 子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。 所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。 子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。 协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行。 协程的特点在于是一个线程执行，那和多线程比，协程有何优势？ 最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。 第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多 import time def consumer(): """ 消费者模型 """ while True: x = yield print(f'处理了数据{x}') def producer(): """ 生产者 """ g = consumer() next(g) # 预激活 for i in range(1, 21): time.sleep(1) print(f'生成了数据{i}') g.send(i) producer()概念
这里的生产者与消费者，既不是进程实现，也不是线程实现，而是两个生成器之间的相互协同完成的，这种就称为协程
四：进程、线程、协程的区别？
进程是资源分配的单位，真正执行代码的是线程，操作系统真正调度的是线程。
进程没有线程效率高，进程占用资源多，线程占用资源少，比线程更少的是协程。
协程依赖于线程、线程依赖于进程，进程一死线程必挂，线程一挂协程必死
一般不用多进程，可以考虑使用多线程，如果多线程里面有很多网络请求，网络可能会有堵塞，此时用协程比较合适
例：
进程：每个人都领一套工具（环境，上下文）去干活，人多（核多）就可以做的更快。
线程：一个人有一套工具后干活，但要干很多工作，先干哪个要听老板的（系统），遇见需要等待的事，老板会叫你先干别的。但老板不明白你干的什么活，比如你挖一个坑埋一个萝卜然后盖上土，结果他让你挖坑，埋土，放萝卜。这时候就要用锁告诉老板这个必须先放了萝卜才能埋土。
协程：一个人有一套工具后干活，但要干很多工作，先干哪个听自己的，同样遇见要等待的事情，你自个会先干别的，比如现在没有萝卜，你就不能盖土，可以继续挖下一个坑，等有萝卜时，执行放萝卜，盖土，对于老板来说，协程内的工作属于一个包的事，他会下命令让你种萝卜，但不会规定你种萝卜的顺序。正是因为省去了老板这一工作量，才大大提高了效率，毕竟是领导的工作量，先洗澡还先吃饭也要问领导不得慢成啥。
无：一个人有一套工具后干活，但要干很多工作，先干哪个完全按写好的清单来，遇见要等待的事情，就等他完了再下一个
协程的好处：
无需线程上下文切换的开销
无需原子操作锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：
无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序
五queue：队列
put()方法 ，向队列中存放数据。如果队列已满，此方法将阻塞至有空间可用为止。
get()返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。 get_nowait(): 不等待，直接抛出异常
full()如果q已满，返回为True empty() 如果调用此方法时 q为空，返回True。
六：多任务控制
1.join:主进程等待子任务结束
import multiprocessing import time # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("inner_start", new_time()) time.sleep(5) # 模拟耗时操作 print("inner_end", new_time()) if __name__ == '__main__': print('outet_start', new_time()) p1 = multiprocessing.Process(target=func) # 实例化进程对象 p1.start() time.sleep(5) p1.join() # 主进程等待子任务结束p1执行完后才继续往下执行 print('outer_end', new_time())terminate() 强制关闭子任务import multiprocessing import time # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("inner_start", new_time()) time.sleep(5) # 模拟耗时操作 print("inner_end", new_time()) if __name__ == '__main__': print('outet_start', new_time()) p1 = multiprocessing.Process(target=func) # 实例化进程对象 p1.start() time.sleep(5) # p1.join() # 主进程等待子任务结束 p1.terminate() # 强制终止子进程 print('outer_end', new_time())2.获取当前进程
这种方法一般可以很方便的看到哪个进程出问题了
比如我们现在有三个方法，有三个子进程，在运行过程中，发现有一个进程没有执行，那么 此时我们可以用这个方法去分别打印出三个方法的进程对象，那么哪个进程没有出现就是哪个进程出现了问题。
import multiprocessing import time print(multiprocessing.current_process()) # 获取当前进程对象方法 # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("inner_start", new_time()) print(multiprocessing.current_process()) # 获取当前进程对象 time.sleep(10) # 模拟耗时操作 print("inner_end", new_time()) if __name__ == '__main__': print('outet_start', new_time()) p1 = multiprocessing.Process(target=func, daemon=True) # 实例化进程对象 守护模式 daemon=True p1.start() time.sleep(5) # p1.join() # 主进程等待子任务结束 p1.terminate() # 强制终止子进程 # res = input("是否继续执行子任务Y/N:") # if res == "Y": # p1.join() # elif res == 'N': # p1.terminate() # else: # print("请输入正确的指令") print('outer_end', new_time())3.获取进程id -- pid知道进程ID我们可以结束进程
import multiprocessing import time # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("内部开始时间", new_time()) time.sleep(10) # 模拟耗时操作 print("内部结束时间", new_time()) if __name__ == '__main__': print('外部开始时间', new_time()) p1 = multiprocessing.Process(target=func) # 实例化进程对象 守护模式 daemon=True p1.name = '子进程1' print("before_start", p1.pid) # 获取进程id p1.start() print("after_start", p1.pid) time.sleep(5) p1.join() # 主进程等待子任务结束 print('外部结束时间', new_time())4.获取线程id -- ident
import time import threading # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("内部开始时间", new_time()) time.sleep(2) # 模拟耗时操作 print("内部结束时间", new_time()) if __name__ == '__main__': print('外部开始时间', new_time()) t1 = threading.Thread(target=func) t1.start() # 开启线程 print(t1.ident) # 获取线程id time.sleep(2) print('外部结束时间', new_time()) 5.生命周期
作用：查看进程有没有在做事
import multiprocessing import time # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("内部开始时间", new_time() time.sleep(10) # 模拟耗时操作 print("内部结束时间", new_time()) if __name__ == '__main__': print('外部开始时间', new_time()) p1 = multiprocessing.Process(target=func) # 实例化进程对象 守护模式 daemon=True p1.name = '子进程1' print("开启之前", p1.is_alive()) # 判断是否处生命周期之中 p1.start() print("开启之后", p1.is_alive()) time.sleep(5) p1.join() # 主进程等待子任务结束 print('外部结束时间', new_time())守护模式:
1.如果某个子线程的daemon属性为False，主线程结束时会检测该子线程是否结束，如果该子线程还在运行，则主线程会等待它完成后再退出；
2.如果某个子线程的daemon属性为True，主线程运行结束时不对这个子线程进行检查而直接退出，同时所有daemon值为True的子线程将随主线程一起结束，而不论是否运行完成。
import multiprocessing import time # 返回现在时间方法 def new_time(): return time.asctime(time.localtime(time.time())) def func(): print("inner_start", new_time()) time.sleep(10) # 模拟耗时操作 print("inner_end", new_time()) if __name__ == '__main__': print('outet_start', new_time()) p1 = multiprocessing.Process(target=func, daemon=True) # 实例化进程对象 守护模式 daemon=True p1.start() time.sleep(5) print('outer_end', new_time())线程的注意点
1.线程之间在执行是无序的
import threading import time def task(): time.sleep(1) print("当前线程：",threading.current_thread().name) if __name__ == '__main__': for _ in range(5): sub_thread = threading.Thread(target=task) sub_thread.start()2.主线程会等待所有的子线程执行结束再结束
import threading import time def show_info(): while True: print("......任务执行中中") time.sleep(0.3) if __name__ == '__main__': # daemon=True 表示创建的子线程 守护主线程，主线程退出子线程直接销毁 sub_thread = threading.Thread(target=show_info, daemon=True) sub_thread.start() # 主线程延时1秒 time.sleep(1) print("over")3.线程之间共享全局变量
import threading import time # 定义全局变量 my_list = list() # 写入数据任务 def write_data(): for i in range(5): # 每循环一次把是数据添加到全局变量 my_list.append(i) print("add：", i) time.sleep(0.1) print("write_data：", my_list) # 读取数据任务 def read_data(): print("read_data", my_list) if __name__ == '__main__': # 创建写入数据的线程 write_thread = threading.Thread(target=write_data) # 创建读取数据的线程 read_thread = threading.Thread(target=read_data()) # 启动线程执行对应的任务 write_thread.start() time.sleep(1) write_thread.join() print("开始读取数据啦") read_thread.start()
线程之间共享全局变量数据出现错误问题
414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
