并发编程 Process 互斥锁

进程理论

程序与进程的区别

'''
程序不是存在硬盘上的代码，相对来说是静态的
进程表示程序在执行的过程，是动态的
'''

进程的调度

• 先来先服务调度算法

  '''对长作业有利，对短作业无益'''
  

• 短作业优先调度算法

  '''对短作业有利，长作业无益'''
  

两对重要的概念

• 同步和异步

  '''描述的是任务的提交方式'''
  同步：任务提交之后，原地等待任务的返回结果，等待过程中不做任何事情程序表面上表现出来的感觉就是卡住了
  异步：任务提交之后，不原地等待任务返回的结果，直接去做其他事情
  		事后，任务的返回结果会有一个任务回调机制自动处理
  

• 阻塞和非阻塞

  '''描述的是程序的运行状态'''
  阻塞：阻塞态
  非阻塞：就绪态、运行态
  

上述概念的组合：最高效的一种组合就是异步非阻塞

开启进程的方式

from multiprocessing import Process
import time

def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over'%name)

if __name__ == '__main__':
  # 1、创建一个对象 target=>要执行的任务
    p = Process(target=task,args=('卡卡西里',))
    # 容器类型哪怕里面只有一个元素 建议要用逗号隔开
    # 2 开启进程
    p.start() # 告诉系统帮你创建一个进程 异步
    print('主进程')

总结

'''创建进程就是在内存中申请一块内存空间将需要运行的代码丢进去
一个进程对应在内存中就是一块独立的内存空间
多个进程对应在内存中就是多块独立的内存空间
进程与进程之间默认情况下是无法直接交互的，想要交互借助于第三方工具、模块
'''

join方法

jion 是让其他主进程等待子进程代码运行结束之后，再继续运行。不影响其他子进程的执行

from multiprocessing import Process
import time

def task(name):
    print('%s is running' % name)
    time.sleep(3)
    print('%s is over' % name)

if __name__ == '__main__':
    p1 = Process(target=task, args=('卡卡西里1',))
    p2 = Process(target=task, args=('卡卡西里2',))
    p3 = Process(target=task, args=('卡卡西里3',))
    start = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    print('主进程',time.time()-start)

 '''输出结果
卡卡西里2 is running
卡卡西里1 is running
卡卡西里3 is running
卡卡西里2 is over
卡卡西里1 is over
卡卡西里3 is over
主进程 3.0681638717651367
 '''

# for 循环 开启进程 join
from multiprocessing import Process
import time

def task(name, n):
    print('%s is running' % name)
    time.sleep(n)
    print('%s is over' % name)

if __name__ == '__main__':
    p_list = []
    start = time.time()
    for i in range(1,4):
        p = Process(target=task, args=('进程%s' % i, i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('主进程', time.time() - start)

Process参数

Process的父类里面的属性要传以下参数

'''group=None, target=None, name=None, args=(), kwargs={},
                 *, daemon=None'''

# target表示的是需要执行的任务，或函数

# name表示的是进程的名字 不传入的话，默认名字是Process-1 后面依次递增
# 也可以传值进行修改
p1 = Process(target=task,name='kakaxili_1' args=('卡卡西里1',))

# args 传入的是元组，传的是任务函数需要的参数 按位置传入

# kwargs 闯入的是字典，传的是任务函数需要的参数，关键字传入

Process类方法

p.start()  开启进程
p.join()   jion 是让其他主进程等待子进程代码运行结束之后，再继续运行。不影响其他子进程的执行
p.run()   没有开启子进程，而是把它当作一个进程执行了，相当于串行了
p.termainate() 终止该进程，但是需要时间
p.is_alive() 判断进程是否存活，存活返回True，否则返回False

Process属性

p.pid  p进程的id 在主进程中查看的
p.name p进程的进程名称
p.daemon = True  daemon默认传入的是False 设为True设置守护进程，主进程如果运行结束，子进程也跟着结束，但是必须放在start之前

获取进程ID的方法

import os

def func():
  print(os.getpid()) # 获取当前进程的id
  print(os.getppid())  # 获取父进程的id

互斥锁

在python的多线程和多进程中，当我们需要对多线程或多进程的共享资源或对象进行修改操作时，往往会出现因cpu随机调度而导致结果和我们预期不一致的问题，这时就需要对线程或者进程加锁，以保证一个线程或进程在对共享对象进行修改时，其他的线程或进程无法访问这个对象，直至获取锁的线程的操作执行完毕后释放锁。所以，锁在多线程和多进程中起到一个同步的作用，以保护每个线程和进程必要操作的完整执行。

import multiprocessing
import os
import time
from multiprocessing import Process, Lock

def task(i, lock):
    lock.acquire()  # 获得锁
    print('%s号进程，ID:%s 开始执行' % (i, os.getpid()))
    time.sleep(2)
    print('%s号进程，ID:%s 执行结束' % (i, os.getpid()))
    lock.release()  # 释放锁

if __name__ == '__main__':
    # 实例化得到一把锁
    multiprocessing.set_start_method('fork') # mac 解决办法
    lock = Lock()
    for i in range(1, 5):
        p = Process(target=task, args=(i, lock))
        p.start()

学习Python3 互斥锁遇到的mac系统遇到的错误 FileNotFoundError: [Errno 2] No such file or directory

mac系统
python3.4更新后，默认用“spawn”，开启进程，我们要主动指定为“fork”
spawn：使用此方式启动的进程，只会执行和 target 参数或者 run() 方法相关的代码。Windows 平台只能使用此方法，事实上该平台默认使用的也是该启动方式。相比其他两种方式，此方式启动进程的效率最低。
fork：使用此方式启动的进程，基本等同于主进程（即主进程拥有的资源，该子进程全都有）。因此，该子进程会从创建位置起，和主进程一样执行程序中的代码。注意，此启动方式仅适用于 UNIX 平台，os.fork() 创建的进程就是采用此方式启动的。
forserver：使用此方式，程序将会启动一个服务器进程。即当程序每次请求启动新进程时，父进程都会连接到该服务器进程，请求由服务器进程来创建新进程。通过这种方式启动的进程不需要从父进程继承资源。注意，此启动方式只在 UNIX 平台上有效。

在实例化锁之前添加
multiprocessing.set_start_method('fork')