并发编程

目录：

　　一、进程前戏

　　二、进程介绍

　　三、进程补充知识

　　四、线程

　　五、协程

　　

　　 

一、进程前戏

　　1、 操作系统

　　核心CPU的调度 操作系统负责控制  调度 协调 管理 硬件（计算机硬件）资源 和软件资源（应用程序）

　　负责数据运算和逻辑运算

　　2、多道技术：a>>>>>IO>>>>

　　　　　　　　　利用a 程序在执行IO时加载b 程序到内存 

　　　　　　　　　核心

　　　　　　　　　1、空间上的复用 多个程序共用同一套计算机系统硬件

　　　　　　　　　2、时间上的复用  在执行一个程序的IO时 加载另一个成序到内存空间 节省时间  特点 会保存上一次的IO的状态 回到就绪态》》》》排队再进入运行态》》》阻塞态

　　　　　　　　　eg:比如我们在洗衣服的时间30 分钟内可以去做其他事 做饭 烧水  互不影响

　　　　　　　　　（1）切换+保存切换时状态

　　　　　　　　　　什么时候才会切换

　　　　　　　　　　>>>1 当一个程序的执行过程遇到IO操作时 操作系统会剥夺程序的CPU的执行权限（切换+保存运行当前的状态）

　　　　　　　　　   >>>2 当一个程序长时间占用CPU 操作系统也会剥夺改程序的CPU的执行权限

   　　　　　　　　　优点：

　　　　　　　　　　　　提高了CPU的利用率，并且也不会影响程序的执行 

　　　  单道技术：等待A程序全部执行完毕才会执行 下一个程序  实际上是 一个 同步

　　

　　3、进程三态状态装换图

1 、程序在运行之后并不是直接进入运行态而是 在就绪态等待操作系统的调度 开始执行

2、阻塞态遇到IO操作 会进入阻塞态 如 input time.sleep print()  阻塞态结束 input  time.sleep print 运行结束 并不是直接回到运行态的 而是 进入就绪态等待 

　　操作系统的重新调用 开始执行 到之前切换的状态 

3.运行结束释放 退出

　　4、进程调度（算法）

　　　　1、FCFS  先进先出

　　　　2、短作业优先调度算法

　　　　3、时间片轮法

二、进程

　　1、进程和程序

　　　 程序：一堆代码块 

　　　 进程：正在运行的程序

　　2、如何创建进程

　　方法一

# 方法一函数的方法
import time
from multiprocessing import Process


def run(name):
    print('%s dancing' % name)
    time.sleep(2)
    print('%s dancing over' % name)


if __name__ == '__main__':
    p = Process(target=run, args=('Lufei',))  # 产生一个进程对象

    p.start()  # 告诉操作系统帮你创一个进程
    print('主进程')
"""
# windows创建进程会将代码以模块的方式 从上往下执行一遍
# linux会直接将代码完完整整的拷贝一份
# 
创建进程就是内存中开辟一块内存空间
将允许产生的代码丢进去
一个进程对应在内存就是一块独立的内存空间

进程与进程间数是相互隔离的 无法直接的进行交互 
但是可以通过某些技术实现简介交互

"""

　　方法二

　　类继承

# 类继承
import time
from multiprocessing import Process


class Myprocess(Process):
    def __init__(self,name):
        super().__init__()  # 继承父类进程名称空间
        self.name = name

    def run(self):
        print('%s is dancing' % self.name)
        time.sleep(2)
        print('%s is over' % self.name)


if __name__ == '__main__':
    p = Myprocess('jason')  # 类继承的方法 继承Process 的属性 调用super().__init__() 重写自己的名称空间
    p.start()  # 告诉操作系统帮你创建一个进程
    print('主进程')

　　3、进程的join 的方法

　　# 控制子所有子进程的结束才会结束主进程。。。如果不加的话主进程一结束所有的子进程也会随之结束，不合理啊有些子进程都没有运行

　　# 如何使用 

# 创建多个进程 所有的代码都会复制一份 
# join 的先让 所有自尅执行完毕才会执行 主进程
from multiprocessing import Process
import time

def run(name,i):
    print("%s is dancing" % name)
    time.sleep(i)
    print('%s is over' % name)

if __name__ == '__main__':
    p_list = []
    for i in range(5):
        p = Process(target=run, args=('第一号%s子进程 '%i,i))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()  # 等待子进程运行完毕 内部机制 
    print('主进程')

原始版本 不加for 循环

# 创建多个进程
# join 的先让 所有自尅执行完毕才会执行 主进程
from multiprocessing import Process
import time

def run(name,i):
    print("%s is dancing" % name)
    time.sleep(i)
    print('%s is over' % name)


if __name__ == '__main__':
    # p_list = []
    # for i in range(5):
    #     p = Process(target=run, args=('第一号%s子进程 '%i,i))
    #     p.start()  # 让操作系统帮我们创建进程
    #     p_list.append(p)
    # for p in p_list:

    #     p.join()  # 等待子进程运行完毕 内部机制
    # print('主进程')
    # 原始状态
    p = Process(target=run, args=('jsaon',1))
    p1 = Process(target=run, args=('tank',2))
    p2 = Process(target=run, args=('egon',3))
    p3 = Process(target=run, args=('mmm',4))
    p.start()
    p1.start()
    p2.start()
    p3.start()
    p.join()
    p1.join()
    p2.join()
    p3.join()
    print('主进程')

　　4、进程间的数据是否可以通用？代码验证

# 进程间的数据是不能直接获取的
from multiprocessing import Process
num = 99
# 可变数据类型是不需要进行全局的 

def run():
    global num  # global 是将局部修改全局
    num = 100
    # print(num)  #


if __name__ == '__main__':
    p = Process(target=run, args=())  # 没有参数的话是可以不写
    p.start()  # 让操作系统帮我们创建一个进程
    p.join()
    print(num)  # 99

　　5、进程对象及其它方法 

　　子进程的pid号和父进程的pid 好的 查询方法 

　　僵尸进程和孤儿进程 

　　6、守护进程

　　7、互斥锁（*****）

　　# 开多进程会将

import json
import time
from multiprocessing import Process, Lock

# 进程互斥锁
""";操作同一份数据会造成数据的错乱 所以需要加锁

1.代码由并行变成了串行虽然牺牲了效率 降低的这执行效率到但是保证了数据的安全性

"""


#
def check(i):
    with open('data', 'r', encoding='utf-8')as f:
        # 获取数据
        res = f.read()

    my_dic = json.loads(res)
    print('%s用户查询的火车票为%s' % (i, my_dic.get('ticket')))


# 买之前还得再获取数据的
def buy(i):
    #
    with open('data', 'r', encoding='utf-8')as f:
        res = f.read()
    my_dic = json.loads(res)

    time.sleep(2)
    if my_dic['ticket'] > 0:
        my_dic['ticket'] -= 1

        with open('data', 'w', encoding='utf-8')as f:

            json.dump(my_dic, f)
        print('%s用户买票成功' % i)
    else:
        print('没有票了')


def run(i, mutex):
    check(i)
    # 枪锁
    mutex.acquire()  # 枪锁
    buy(i)
    # 释放锁
    mutex.release()  # 释放锁


if __name__ == '__main__':
    # 创建进程
    # 将锁放在主进程中
    mutex = Lock()  # 生成一把锁
    for i in range(10):
        p = Process(target=run, args=((i, mutex)))
        p.start()
7用户查询的火车票为2
5用户查询的火车票为2
0用户查询的火车票为2
1用户查询的火车票为2
4用户查询的火车票为2
6用户查询的火车票为2
3用户查询的火车票为2
2用户查询的火车票为2
8用户查询的火车票为2
9用户查询的火车票为2
7用户买票成功
5用户买票成功
没有票了
没有票了
没有票了
没有票了
没有票了
没有票了
没有票了
没有票了

 作业：FTP上传文件

需求：

　　  1 用户认证加密

　　2 允许同时多个用户登录

　　3 每个用户都有自己的家目录（home),并且只能访问自己的home 目录

允许访问自己的家目录

　　4 允许用户在FTPserver 上随意切换目录

　　5 允许传输过程中显示进度条

　　6 附加功能 支持文件的端点的端点续传

　三、进程补充

　　1、进程间的相互通信   间接 通过Quueue 实现 

　　队列可以实现通讯的本质 利用Qqueue 在一个进程中存 q.put() 的所有变量 存放到队列中的名称空间中 

　　可以在另一个进程中通过q.get() 获取 另一个进程的值 就相当于一个链接 进程之间的通道

　　也可以比作一座桥梁

　　2.

Pipe(管道)

The Pipe() function returns a pair of connection objects connected by a pipe which by default is duplex (two-way).

　　

# 简单版本的进程间相互通信是类简介通信的
import os
import time
from multiprocessing import Process, Queue

# q = Queue(5)
# q.put(1)
# q.put(2)
# q.put(3)
# # print(q.full())
# q.put(4)
#
# q.put(5)
# # print(q.full())
#
#
# # 取值
# q.get()
# q.get()
# q.get()
# q.get()
# print(q.get_nowait())
# print(q.empty())
# # print(q.get_nowait())
#
#
# print(q.get())  # q.get() 如果没有取到值则会一致等
#
# print(q.empty())
#
# """
#
# """

　　2、进程间通过Queue进行通信的代码

实现过程：

money = 6666


def task(q):
    global money
    money = 9999
    q.put('Hello i love')


def consumer(q):
    print(q.get(),'haha')


if __name__ == '__main__':
    q1 = Queue()
    p = Process(target=task, args=(q1,))
    c = Process(target=consumer,args=(q1,))
    c.start()
    p.start()
    p.join()  # 等待所有的子进程结束才结束
    # print(money)
    print(q1.get(),'luelie')  #

 2.PIpe进程实现通信

from multiprocessing import Process, Pipe

def f(conn):
    conn.send('11')
    conn.send('22')
    print("from parent:",conn.recv())
    print("from parent:", conn.recv())
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()   #生成管道实例，可以互相send（）和recv（）

    p = Process(target=f, args=(child_conn,))
    p.start()

    print(parent_conn.recv())      # prints "11"
    print(parent_conn.recv())      # prints "22"
    parent_conn.send("33")         # parent 发消息给 child
    parent_conn.send("44")
    p.join()

Pipe

　　3.Manage

进程之间是相互独立的 ,Queue和pipe只是实现了数据交互，并没实现数据共享，Manager可以实现进程间数据共享 。

Manager还支持进程中的很多操作 , 比如Condition , Lock , Namespace , Queue , RLock , Semaphore等

from multiprocessing import Process, Manager
import os

def f(d, l):
    d[os.getpid()] =os.getpid()
    l.append(os.getpid())
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()  #{} #生成一个字典，可在多个进程间共享和传递

        l = manager.list(range(5))     #生成一个列表，可在多个进程间共享和传递
        p_list = []
        for i in range(2):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list: #等待结果
            res.join()
        print(d)
        print(l)

　　4、进程中的IPC机制

　　生产者和消费者模型

　　# 

"""
生产者消费者模型
1.生产者：生产制造数据的
2、消费者:消费处理数据的
应用场景：解决生产与消费的供需不平衡的问题
供==求
列子：
···老王 开了一家面馆10碗面 老二 开了包子10个包子铺>>>>> 生产者
···小明 小红 吃面和包子 

"""

def producer(name, food, q):
    for i in range(10):
        data = '%s生产的%s 个数：%d' % (name, food,i)
        # 生产需要时间的所以
        # time.sleep(random.random())
        time.sleep(random.random())
        q.put(data)
        print(data)


def consumer(name, q):
    # 消费者
    while True:
        data = q.get()
        # print(data)
        # if data == None:  # q.task_done() 其实已经帮我们处理完毕所有的数值
        #     break
        print("%s吃了%s"%(name,data))
        time.sleep(random.random())
        q.task_done()  # 告诉队列你已经从你的队列中取出一个值并且已经处理完毕


if __name__ == '__main__':
    # 创建进程可等待队列
    q = JoinableQueue()
    p1 = Process(target=producer, args=('大厨San', '包子', q))
    p2 = Process(target=producer, args=('二厨tank', '生蚝', q))
    p1.start()
    p2.start()

    c1 = Process(target=consumer, args=('吃货lufei', q))
    c2 = Process(target=consumer, args=('吃货Nami', q))
    # 守护进程 c1 c2 等待 运行完毕 运行主进程结束程序
    c1.daemon = True
    c2.daemon = True

    c1.start()  # 让操作系统帮我们创建一个消费者进程
    c2.start()
    # 让是生产进程全部执行完毕 才走 消费 进程
    p1.join()
    p2.join()
    # print('zhu')
    q.join()  # 等待队列中的所有值取完

　　5.进程池

　　pass

四、线程和进程的关系

#

"""
进程:进程是资源单位，每个进程下面自带了一个线程
线程：是正真运行代码的执行单位
并发：单核下是一个进程下的多个线程进行IO切换


eg: 进程好比一个工厂 线程是里面的一条条流水线

"""

1 主进程，父进程和子进程之间的关系
父子进程之间的定义：当一个进程创建一个或多个子进程时，那么这个进程可以称之这些进程的父进程， 他们之间是父子关系，也可以说是继承关系，子进程会继承父进程的属性。
进程是一个资源单位，在进程创建的过程，系统会自动为其开辟一块独立的内存空间。因此，在子进程的创建的过程中，系统会自动为其开辟一块独立的内存空间 ，并且会将父进程的代码拷贝到这个内存空间中。
一般来说，主进程默认是最初始的父进程。
所以在Python中创建子进程的过程中为了避免无限递归主进程的问题，必须将创建子进程的代码放在if name == ‘__main__’下面
2 主线程，父线程和子线程之间的关系
父线程和子线程之间的关系类似与主进程和子进程之间的关系，但是在线程的创建过程中并不需要开辟内存空间吗，而且线程与线程之间是没有主次之分的，他们共享同一块内存资源。每一个进程都自带一个线程，
这个线程称之为主线程。一般来说，主线程不会是父线程，他与子线程是同等地位的，这一点与进程有很大的不同。主线程创建的子线程只会去执行主线程交给他的任务，不会去执行子线程的创建任务，所以在线程的创建的过程不需要加if判断。
注意：如果子线程执行的是函数任务，函数的加载并不会在子线程中创建，他只是去执行这个函数体代码，而不会去执行创建过程，创建过程在主线程中完成。

2、创建线程的两种方法

·　　1、函数的方法

# def producer(name):
#     print('%s is runing'% name)
#     time.sleep(1)
#     print('%s is over'% name)
#
#
# def consumer(name):
#     print('%s is runing '% name)
#     time.sleep(1)
#     print('% is over'% name)
#
#
# # 线程可以不用在双下__main__
# t1 = Thread(target=producer, args=('san',))
#
# t2 = Thread(target=producer, args=('Nami',))
# t1.start()  # 创建线程的资源开支小于 进程 时间消耗也小于进程 不需要开辟内存空间
# t2.start()  # 所以执行创建线程
# print('主线程')

　　2、类继承创建线程

# 类继承
class MyThread(Thread):
    def __init__(self, name):  #
        super().__init__()
        self.name = name

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


# if __name__ == '__main__':
t1 = MyThread('San')
t1.task()
t1.start()

t1.join()
print('主线程', os.getpid())


# #

# 创建多个线程


def task1(i):
    print('%s is running' % i)
    time.sleep(1)
    print('%s is over' % i)
    # print('主线程1', os.getppid())  # 主线程1 32092
    # print('子线程', os.getpid())  # 子线程 38928


for i in range(6):
    t = Thread(target=task1, args=(i,))
    t.daemon = True
    t.start()
    # print('主线程2', os.getpid())  # 主线程2 38928
    # print('主主',os.getppid())  # 主主 32092

#

小结： 

"""
主线程的结束也就意味进程的结束
主线程必须等待其他非守护线程的结束才能结束
（意味子线程云运行的时候需要使用进程中的资源，而主线程一旦结束资源也就销毁了）

"""

3、线程中的是可以进行相互通信的 因为同一进程下的线程是可以共用进程的所有资源单位的

from threading import Thread

money = 6666


def task():
    global money
    money = 9999


t = Thread(target=task)


t.start()
t.join()
print(money)

4、线程中的互斥锁 当多个线程对同一份数据进行操作的时候 会造成数据的错乱 所以需要进行加锁 虽然牺牲了效率 但保证数据的安全 

# 多个线程对同一份数据的操作 会造成数据的错乱
# 需要加锁 保障数据的安全
import time
from threading import Thread,Lock
num = 100
def task(mutex):

    # print('%s is running' % i)
    # time.sleep(2)
    # print('%s is over '% i)
    global num
    mutex.acquire()  # 加到要操作的数据上
    temp = num
    time.sleep(0.01)
    num = temp-1
    mutex.release()  # 操作完毕进行释放锁



t_list = []
mutex = Lock()  # 加锁的位置
for i in range(100):
    t = Thread(target=task, args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(num)  # 多个线程在操作同一份的数据的时候 会造成数据的错乱的 所以需要对我们的操作的数据加锁

#

五、协程

1.简介

协程(Coroutine) : 是单线程下的并发 , 又称微线程 , 纤程 . 协程是一种用户态的轻量级线程 , 即协程有用户自己控制调度

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。

协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态

使用协程的优缺点

优点 :

1. 协程的切换开销更小 , 属于程序级别的切换 , 更加轻量级
2. 单线程内就可以实现并发的效果 , 最大限度利用CPU

缺点 :

1. 协程的本质是单线程下 , 无法利用多核 , 可以是一个程序开启多个进程 , 每个进程内开启多个线程 , 每个线程内开启协程
2. 协程指的是单个线程 , 因而一旦协程出现阻塞 将会阻塞整个线程

2.Greenlet

greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator

·　　greenlet
为了更好使用协程来完成多任务，python中greenlet模块对其封装，从而使得切换任务变得更加简单
安装方式

pip install greenlet 

from greenlet import greenlet

def test1():
    print(12)
    gr2.switch()      #到这里切换到gr2，执行test2（）
    print(34)
    gr2.switch()      #切换到上次gr2运行的位置

def test2():
    print(56)
    gr1.switch()      #切换到上次gr1运行的位置
    print(78)

gr1 = greenlet(test1)      #启动一个协程gr1
gr2 = greenlet(test2)      #启动一个协程gr2

gr1.switch()        #开始运行gr1

greenlet

3、gevent
greenlet已经实现了协程，但是这个工人切换，是不是觉得太麻烦了，不要着急，python还有一个比greenlet更强大的并且能够自动切换任务的模块`gevent`
其原理是当一个greentlet遇到IO（指的是input ouput输入输出，比如网络、文件操作等）操作时，比如访问网络，就自动切换到其他的greenlet,等到IO完成，再适当的时候切换回来继续执行。

由于IO操作非常耗时，经常使程序处于等待状态，有了gevent我们自动切换协程，就保证总有greenlet在运行，而不是等待IO

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。
由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：

安装：

　　

pip install gevent 

import gevent

def f(n):
for i in range(n):
　　print(gevent.getcurrent(), i)
　　# 用来模拟一个耗时操作，注意不是time模块中的sleep
　　gevent.sleep(1)

g1 = gevent.spawn(f, 5)
g2 = gevent.spawn(f, 5)
g3 = gevent.spawn(f, 5)
g1.join()
g2.join()
g3.join()