并发编程 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')

巴特西