python编程之进程
进程：运行中的程序
进程和操作系统的关系：进程是操作系统调度和资源分配的最小单位，是操作系统的结构基础。
那么为什么要有进程呢？
程序在运行时，会使用各种硬件资源，如果他们之间没有界限，那么程序之间的数据必然会产生混乱。所以为了实现资源的隔离，就有了进程的概念。
进程的调度方式：
1，先到先服务算法（FCFS）
先请求的进程就先进行处理。缺点：大作业先到，就会使后面的短作业不能得到及时处理。
2，短作业优先算法
处理起来简短的作业先进行处理。缺点：一些大的作业将会长时间得不到处理。
3，时间片轮转算法
给每个进程分配时间片，然后轮转者进行处理。缺点：一些重要任务将无法及时处理。
4，多级反馈算法
处理分多个级别，由高到低，高级别先执行，但是级别越低分配的时间越长。当一个进程进来时，先按FCFS在最高级别排队，当其在时间片内没有执行完成时，就把它放进下一个级别的，依次类推。因为低级别分配的时间更长，长进程就能得到更多的资源来完成处理。
进程的并行和并发
并行：多核处理器，同时进行多个进程的工作
并发：资源有限的情况下，比如单核处理器，多个进程交替使用资源
区别：并行是真正的同时运行，而并发只是宏观上看起来像是同时运行
进程的同步和异步
同步
import time from multiprocessing import Process # multiprocessing模块：综合处理进程的包 def func(): time.sleep(1) return '同步' if __name__ == '__main__': p = Process(target=func) ret = func() print(ret) # 像这种上个工作完成下面才能进行的，就叫做同步进程
异步
import time from multiprocessing import Process # multiprocessing模块：综合处理进程的包 def func(): time.sleep(1) print('子进程') # 后打印 if __name__ == '__main__': p = Process(target=func) # 创建一个进程对象 参数target传函数的名字 p.start() # 开始进程 print('父进程') # 先打印 # 像这种只是开始一个进程，而不管其结果，就进行自己接下来的工作的，就是异步进程
阻塞和非阻塞
阻塞：需要等待信息才能继续执行时，是会产生阻塞。例如：input输入时，time.sleep时等。
import time input('>>>') print('1') time.sleep(2) print('2')
非阻塞：和阻塞相反的状态。
进程三种状态之间的转换
守护进程
守护进程：使守护进程在父进程执行完成后就结束，不会像正常的子进程那样，主进程在执行完成后还要等子进程执行完成。 1，守护进程的开启设置一定要放在进程开启之前 2，守护进程中不能再开启进程
举例
import time from multiprocessing import Process def func(): while True: time.sleep(10) print('过去了10秒') if __name__ == '__main__': p = Process(target=func) p.daemon = True # 一定在进程开启之前设置 p.start() for i in range(100): time.sleep(1) print('*'*i)
进程的几个方法和属性查看
# is_alive和terminate import time from multiprocessing import Process def func(): print('1') time.sleep(1) print('2') if __name__ == '__main__': p = Process(target=func) p.start() print(p.is_alive()) # True 判断子进程是否还存在 time.sleep(0.1) p.terminate() # 结束子进程 通过操作系统来完成 time.sleep(1) print(p.is_alive())
# pid和name 属性查看 from multiprocessing import Process def func(): pass if __name__ == '__main__': p = Process(target=func) p.start() print(p.pid) # 28716 查看子进程的进程id print(p.name) # Process-1 查看子进程的进程名
进程锁
锁：在并发编程中，保证数据的安全。使多个进程不能同时对数据进行操作，从而造成数据处理逻辑混乱。
来一个买火车票的例子
创建ticket文件，里面模拟序列化内容：{"count": 4}，定义4张票。
import time import random import json from multiprocessing import Lock from multiprocessing import Process def search(): with open('ticket') as f: print('票数：%d' %json.load(f)['count']) def get(i): with open('ticket') as f: ticket_num = json.load(f)['count'] if ticket_num > 0: time.sleep(random.random()) with open('ticket', 'w') as f: json.dump({'count': ticket_num-1}, f) print('%s，买到票了' %i) else: print('%s，没有票了' %i) def func(i, lock): search() lock.acquire() # 等待人来拿钥匙开门 没有人来就阻塞 get(i) lock.release() # 处理完事情后离开关上门并放回钥匙 if __name__ == '__main__': lock = Lock() # 创建一个锁对象 for i in range(10): p = Process(target=func, args=(i, lock)) p.start()
信号量
信号量：和进程锁类似它也是限定多进程的并发，但它可以指定能同时进行的进程数，而不单单是一次只能一个。
import time import random from multiprocessing import Process from multiprocessing import Semaphore def func(p, S): S.acquire() # 和进程锁相同，等待钥匙开门 只是这里同时开了4道门 print('%s办理取钱' %p) time.sleep(random.randint(1, 10)) S.release() # 和进程锁相同，关门并放回钥匙 print('%s完成办理' %p) if __name__ == '__main__': sem = Semaphore(4) # 创建一个信号量对象，指定能同时接收的信号量为4 for i in range(20): Process(target=func, args=(i, sem)).start()
事件
事件：异步阻塞 用于主进程控制其他进程的执行。 1，waite 事件实例化之后默认为阻塞 2，set 将阻塞状态变为非阻塞 3，clear 将非阻塞状态变为阻塞 4，is_set 判断事件的阻塞状态 True为非阻塞 False为阻塞
import time import random from multiprocessing import Process from multiprocessing import Event def traffic_light(e): while True: if e.is_set(): time.sleep(3) print('红灯亮') e.clear() else: time.sleep(3) print('绿灯亮') e.set() def car(i, e): e.wait() print(i) if __name__ == '__main__': event = Event() # 创建一个事件对象 Process(target=traffic_light, args=(event,)).start() for i in range(100): if i % random.randint(2, 5) == 0: time.sleep(random.randint(1, 3)) Process(target=car, args=(i, event)).start()
队列
队列：先进先出 实现不同进程之间的通信 queue = Queue() 不限定队列的长度 queue = Queue(10) 限定队列的长度为10 1，put 放入数据 当队列有限制且数据放满时，阻塞 2，get 取出数据 当队列为空时，阻塞
import time from multiprocessing import Process from multiprocessing import Queue def producer(q): for i in range(50): q.put('包子%d' %i) def consumer(q): while True: time.sleep(1) print(q.get()) if __name__ == '__main__': queue = Queue(10) Process(target=producer, args=(queue,)).start() Process(target=consumer, args=(queue,)).start()
JoinableQueue
创建可连接的共享进程队列。这就像是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。
JoinableQueue() 实例化后放数据和取数据和队列相同
join：接收数据处理完成后的消息，判断全部完成后再结束进程
task_done：完成处理后告诉对应的数据生产者
import time import random from multiprocessing import Process from multiprocessing import JoinableQueue def producer(q): for i in range(20): q.put('数据%d' %i) # 生产数据 time.sleep(random.randint(1, 3)) q.join() # 接收数据处理完成后的消息，全部完成后结束进程 def consumer(q): while True: print(q.get()) # 消费数据 q.task_done() # 完成处理后告诉对应的生产者 if __name__ == '__main__': queue = JoinableQueue() p1 = Process(target=producer, args=(queue,)) p1.start() p2 = Process(target=producer, args=(queue,)) p2.start() c1 = Process(target=consumer, args=(queue,)) c1.daemon = True # 守护进程 c1.start() c2 = Process(target=consumer, args=(queue,)) c2.daemon = True # 守护进程 c2.start() c3 = Process(target=consumer, args=(queue,)) c3.daemon = True # 守护进程 c3.start() p1.join() # 阻塞，子进程p1结束后停止阻塞 p2.join() # 阻塞，子进程p2结束后停止阻塞
管道
管道：双向通信 但是数据不安全 相当于没有锁的队列
send：发送数据
recv：接收数据 当管道另一边关闭，且管道中没有内容时就会报错(EOFError)
close: 关闭管道口 一般在进程中用不到的管道口就可以先关闭掉
import time from multiprocessing import Pipe from multiprocessing import Process def func1(p): open1, open2 = p open2.close() for i in range(100): time.sleep(0.1) open1.send(i) open1.close() def func(p, i): open1, open2 = p open1.close() while True: try: print(i, open2.recv()) except EOFError: open2.close() break if __name__ == '__main__': open1, open2 = Pipe() # 创建一个管道，得到一个元组，里面的两个元素相当于管道的两端 pr1 = Process(target=func1, args=((open1, open2),)).start() p1 = Process(target=func, args=((open1, open2), 1)).start() p2 = Process(target=func, args=((open1, open2), 2)).start() p3 = Process(target=func, args=((open1, open2), 3)).start() open1.close() open2.close()
进程池
进程池：因为设备的硬件资源有限，所以不能无限的开启进程，更合理的协调进程数和硬件之间的关系，才能拥有更高的数据处理效率
进程池就是为了合理利用资源，减小进程调度难度，节省过多进程开启消耗的时间。
import time import random from multiprocessing import Pool from multiprocessing import Process def func(s): s += 1 if __name__ == '__main__': pool = Pool(9) # 进程池对象，参数指定同时处理的进程数，一般是CPU核数加一 start = time.time() pool.map(func, range(100)) # 循环处理100个任务 pool.close() # 不允许再添加任务 pool.join() print(time.time() - start) # 0.13385581970214844 start = time.time() lis = [] for i in range(100): p = Process(target=func, args=(i,)) p.start() lis.append(p) [j.join() for j in lis] print(time.time() - start) # 2.0339081287384033
import time import random from multiprocessing import Pool def func(s): time.sleep(random.randint(1, 3)) s += 1 print(s) if __name__ == '__main__': pool = Pool(9) for i in range(10): ret = pool.apply(func, args=(i,)) # 同步提交任务 可以接收子进程的返回值 print(ret) print('主进程') # 最后打印
if __name__ == '__main__': pool = Pool(9) for i in range(20): pool.apply_async(func, args=(i,)) # 异步提交任务 也可以接收子进程返回值 pool.close() pool.join() # 阻塞 否则主进程会直接结束
回调函数
多用于爬虫，处理高I/O操作
import os from multiprocessing import Pool def func(s): return s*'*' def call(arg): # 回调函数，在主进程中执行，参数只能接收子进程的返回值 print('回调函数%s' %os.getpid()) # 回调函数20828 print(arg) if __name__ == '__main__': pool = Pool(5) print('主进程%s' %os.getpid()) # 主进程20828 for i in range(10): pool.apply_async(func, args=(i,), callback=call) # callback设置回调函数，将开启的子进程的返回值作为参数传给函调函数 pool.close() pool.join()
Manger模块
提供多种数据类型用于进程之间的数据共享，但是不够安全
from multiprocessing import Manager from multiprocessing import Process def func(dic): dic['count'] -= 1 if __name__ == '__main__': manager = Manager() # 创建Manager对象 d = manager.dict({'count': 100}) # 对象.数据类型 创建共享数据类型 lis = [] for i in range(100): p = Process(target=func, args=(d,)) p.start() lis.append(p) [j.join() for j in lis] print(d) # 打印{'count': 2} 数据不安全
