并发编程

并发编程：
- 操作系统：
知识点解析:
- 多道技术解决的问题：
进程：
- - 概念：
  - 进程的创建：
创建进程的两种方法：
- 函数-创建进程：
- 类-创建进程(了解)：
进程PID：
进程之间数据隔离：
join方法：
进程对象的其他属性：
- 僵尸进程：
- 孤儿进程：
- 守护进程：
进程之间的通信方式：
互斥锁：
队列：
- - 队列模式：
- 队列参数：
抢售模型 (并行示例)：
生产者消费者模型(并发示例)：
线程：
开启线程的两种方式：
线程的方法：
守护线程：
线程互斥锁：
- - join：
互斥锁：
线程死锁现象：
递归锁：
信号量：
GIL锁：
验证Python开发效率：
GIL锁和互斥锁关系：
线程池：
阻塞，非阻塞：
同步：
- - 同步示例：
异步：
- - 异步示例：
异步+回调机制：
队列模式：
事件Event：
协程：

并发编程：

程序：
- 程序就是一堆文件
进程：
- 进程是分配资源的基本单位，为线程提供资源，一个程序可以开启多个进程
进程被谁运行：
- CPU最终运行你的程序
  - 操作系统调度作用，将你磁盘上的程序加载到内存，然后交给CPU处理，一个CPU在运行的一个程序，就是开启了一个进程
操作系统：
- 操作系统定义：
  - 操作系统是存在于硬件与软件之间，管理，协调，控制软件与硬件的交互
- 操作系统的作用：
  - 如果没有操作系统，去写一个程序，你要完成两层功能：
    - 第一层：你要学会底层硬件：CPU，内存，磁盘是如何工作使用的
    - 第二层：去调度这些底层的硬件
  - 操作系统两个作用：
    - 1，将一些复杂的硬件操作封装成简单的接口，便于使用
    - 2，操作系统可以合理的调度分配多个进程与CPU的关系，让其有序化
- 操作系统（计算机）的发展史：
  - 第一代电子计算机：操作插线与你的程序结合
  - 第二代计算机：磁带存储，批处理系
  - 第三代计算机：集成电路，多道程序系统

知识点解析:

多道技术解决的问题：
- 多道技术是在不同任务间切换执行，由于计算机切换速度非常快，用户是无感状态
- 时间复用：
  - 利用闲置时间，进行复用，一个进程占用cpu时间太长也会切换
- 空间复用：
  - 一个内存可以加载多个进程，提高内存的利用率
- 数据隔离：
  - 解决软件之间的隔离，互不影响

进程：

程序就是一堆代码
进程是分配资源的基本单位，为线程提供资源，一个程序可以开启多个进程
概念：
- 串行：所有的进程有CPU一个一个解决
- 并行：多个CPU，真正的同时运行多个进程
- 并发：单个CPU，同时执行多个进程(来回切换)，看起来像是同时运行，空间复用
- 阻塞：遇到IO(recv，input)才会阻塞
- 非阻塞：没有IO

tail -f access.log |grep '404'
执行程序tail，开启一个子进程，执行程序grep，开启另外一个子进程，两个进程之间基于管道'|'通讯，将tail的结果作为grep的输入。
进程grep在等待输入（即I/O）时的状态称为阻塞，此时grep命令都无法运行

进程的创建：
- 什么是开启多个进程：socket：server，client两个进程
- python中，如果一次想开启多个进程，必须是一个主进程，开启多个子进程
- linux，windows：有主进程开启子进程
- 相同点：主进程开启子进程，两个进程都有相互隔离的独立空间，互不影响
- 不同点：
  - linux：子进程空间的初始数据完全是从主(父)进程copy一份
  - windows：子进程空间初始数据完全是从主(父)进程copy一份，但是有所不同

创建进程的两种方法：

函数-创建进程：

#这样的实例虽然创建了子进程，但是在生产环境中子进程结束的时间不定
from multiprocessing import Process
import time
#当前py文件就是主进程，先运行主进程
def task(name):
    print(f"{name}is running")
    time.sleep(3)  #阻塞
    print(f"{name}is done")

if __name__ == '__main__':                  #windows开启必须写在mian下面
     p = Process(target=task,args=("海洋",)) #target要封装的内容，对象args一定是个元祖形式
     p.start()      #子进程 通知操作系统在内存中开辟一个空间，将p这个进程放进去，让cpu执行
     print("___主进程")

类-创建进程(了解)：

from multiprocessing import Process
import time
class MyProcess(Process):

    def __init__(self,name):
        super().__init__()      #放在最上面，必须要继承父类init
        self.name = name

    def run(self):
        print(f"{self.name}is running")
        time.sleep(3)  #阻塞
        print(f"{self.name}is done")

if __name__ == '__main__':
    p = MyProcess("海洋")
    p.start()
    print("====主进程")

进程PID：

tasklist | findstr pycharm win查看某个进程
import os print(os.getpid()) 查看当前的pid
import os print(os.getppid()) 查看父进程

进程之间数据隔离：

import time
from  multiprocessing import  Process
X = 1000

def task():
    global x
    x = 2

if __name__ == '__main__':
    p1 = Process(target = task,)
    p1.start()
    time.sleep(1)
    print(f"主进程{X}")
    print(f"主进程{X}")

import time
from  multiprocessing import  Process
X = 256                                #满足小数据池

def task():
   print(f"子进程{id(X)}")

if __name__ == '__main__':
    print(f"主进程{id(X)}")
    p1 = Process(target = task,)
    p1.start()
    time.sleep(1)
    print()

join方法：

join 主进程等待子进程结束之后，在执行

join开启一个进程：

from multiprocessing import Process
import time

def task(name):
    time.sleep(1)
    print(f"{name}is running")

if __name__ == '__main__':
     p = Process(target=task,args=("海洋",))
     p.start()
     p.join()           #告知主进程，p进程结束之后，主进程在结束，join有些阻塞的意思
     print("___主进程")

#      p1.start()
#      p2.start()       #p1,p2,p3三个子进程先后运行顺序不定，start只是通知一下操作系统
#      p3.start()       #操作系统调用cpu先运行谁，谁先执行

join串行：

from multiprocessing import Process
import time

def task(name,sec):
    time.sleep(sec)
    print(f"{name}is running")

if __name__ == '__main__':
     p1 = Process(target=task, args=("海洋",1))
     p2 = Process(target=task, args=("俊丽",2))
     p3 = Process(target=task ,args=("宝宝",3))
     start_time = time.time()

     p1.start()
     p1.join()
     p2.start()
     p2.join()
     p3.start()
     p3.join()

     print(f"主进程{time.time() - start_time}")

join并发:

from multiprocessing import Process
import time

def task(sec):
    time.sleep(sec)
    print(f"is running")

if __name__ == '__main__':
     start_time = time.time()
     list = []

     for i in range(1,4):
          p = Process(target=task, args=(i,))
          p.start()
          list.append(p)

     for i in list:
          i.join()

     print(f"主进程{time.time() - start_time}")

进程对象的其他属性：

属性：

from multiprocessing import Process
import time

def task(name):
    print(f"{name}is running")
    time.sleep(3)
    print(f"{name}is done")

if __name__ == '__main__':
     p = Process(target=task,args=("海洋",),name="俊丽")  #name给进程对象设置name属性
     p.start()
     # print(p.pid)         #获取到进程号

     time.sleep(1)          #睡一秒，子进程已经执行完成
     p.terminate()          #强制结束子进程,强制执行也会有执行时间
                            #terminate跟start一样工作原理，都要通知操作系统开启子进程
                            #内存终止或者开启都要需要时间的
                
     time.sleep(1)          #睡一秒，让terminate杀死
     print(p.is_alive())    #判断子进程是否存活，只是查看内存中p子进程是否还运行
     print("主进程")

僵尸进程：

init是所有进程的父进程：

僵尸进程，僵尸是什么，死而没有消失

主进程创建多个短暂周期的子进程，当子进程退出，是需要等待父进程处理，而父进程没有及时对子进程回收，那么子进程的进程符仍然保存在系统中，这种进程就是僵死进程

什么进程描述符：每一个进程都有描述符，io请求，数据指针

from multiprocessing import Process
import time
import os

def task(name):
    print(f"{name}is running")
    print(f"子进程开始了：{os.getpid()}")
    time.sleep(50)


if __name__ == '__main__':
    for i in range(100):
        p = Process(target=task, args=("海洋",))
        p.start()
        print(f"___主进程:{os.getpid()}")

孤儿进程：

孤儿进程：孤儿进程是因为主进程的退出，他下面的所有子进程都变成孤儿进程了，init会对孤儿进行回收，释		   放掉占用系统的资源，这种回收也是为了节省内存。

孤儿进程无害，如果僵尸进程挂了，init会对孤儿进程回收，init是所有进程的祖进程，linux中为1,0系统

守护进程：

将一个子进程设置成守护进程，当父进程结束，子进程一定会结束，避免孤儿进程产生，应为回收机制
父进程不能创建子进程

#守护进程会在主进程代码执行结束后终止，守护进程内无法在开启子进程

from multiprocessing import Process
import time
import os

def task(name):
    print(f"{name}is running")
    print(f"子进程开始了：{os.getpid()}")
    time.sleep(50)

if __name__ == '__main__':
     p = Process(target=task,args=("海洋",))
     p.daemon = True  #将p子进程设置成守护进程，守护子进程，只要主进程结束
                      #子进程无论执行与否都马上结束,daemon,开启在start上面
     p.start()
     print(f"___主进程:{os.getpid()}")

进程之间的通信方式：

第一种：基于文件+锁的形式：效率低，麻烦
第二种：基于队列，推荐的使用形式
第三种：基于管道，管道自己加锁，底层可能会出现数据丢失损坏，队列和管道都是将数据存放于内存中

互斥锁：

互斥锁保证了每次只有一个线程进行写入操作，只有当这个线程解锁，在运行其他资源，上锁和解锁都需要自己添加

三台电脑同时调用打印机去打印，开启三个进程使用互斥锁，实现公平抢占资源

#上锁：
#一定要是同一把锁：只能按照这个规律，上锁一次，解锁一次

#互斥锁与join区别：
#共同点:都是完成了进程之间的串行
#区别：join认为控制进程的串行，互斥锁是解决抢占的资源，保证公平性

from multiprocessing import Process
from multiprocessing import Lock
import time
import os
import random

def task1(lock):
    print("test1")                     #验证CPU遇到IO切换
    lock.acquire()
    print("task1 开始打印")
    time.sleep(random.randint(1,3))
    print("task1 打印完成")
    lock.release()

def task2(lock):
    print("test2")
    lock.acquire()                      #上锁
    print("task2 开始打印")
    time.sleep(random.randint(1,3))#阻塞，cpu切换任务，别的任务都在锁，回来继续执行这个程序
    print("task2 打印完成")
    lock.release()                      #解锁

def task3(lock):
    print("test2")
    lock.acquire()
    # lock.acquire()                    #死锁错误示例
    print("task3 开始打印")
    time.sleep(random.randint(1,3))
    print("task3 打印完成")
    lock.release()

if __name__ == '__main__':
     lock = Lock()                              #一把锁

     p1 = Process(target=task1,args=(lock,))    #三个进程哪个先到先执行
     p2 = Process(target=task2,args=(lock,))
     p3 = Process(target=task3,args=(lock,))

     p1.start()
     p2.start()
     p3.start()

互斥锁买票示例：

#买票系统：
#买票之前先要查票，在你查票的同时，100个人也在查看此票
#买票时，你要从服务端获取到票数，票数>0 ，买票，然后服务端票数减一，中间有网络延迟

#多进程原则上是不能互相通信的，他们在内存级别是有数据隔离，不代表磁盘上的数据隔离，他们可以共同操作一个文件
#多个进程抢占同一个资源，要想公平按照顺序，只能串行

from multiprocessing import Process
from multiprocessing import Lock
import random
import json
import time
import os

def search():
    time.sleep(random.random())  #一秒之内
    with open("db.json", encoding="utf-8") as f1:
        dic = json.load(f1)
    print(f"剩余票数{dic['count']}")

def get():
    with open("db.json",encoding="utf-8") as f1:
        dic = json.load(f1)
    time.sleep(random.randint(1,3))  #时间延迟

    if dic['count'] > 0:
        dic['count'] -= 1
        with open("db.json",encoding="utf-8",mode="w") as f1:
            json.dump(dic,f1)
        print(f'{os.getpid()}用户购买成功')
    else:
        print("没票了")

def task(lock):
    search()

    lock.acquire()
    get()
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        p = Process(target=task,args=(lock,))
        p.start()
缺点：
	1.操作文件效率低
    2.自己加锁很麻烦，很容易出现死锁，递归锁

队列：

进程之间的通信最好的方式是基于队列
队列是实现进程之间通信的工具，存在内存中的一个容器，最大的特点是符合先进先出的原则
队列模式：
- 多个进程抢占一个资源：串行，有序以及数据安全，买票
- 多个进程实现并发的效果：生产者消费模型

队列参数：

from multiprocessing import Queue
q = Queue(3)                #可以设置元素个数,当数据已经达到上限，在插入夯住

def func():
    print("in func")

q.put("海洋")               #插入数据
q.put({"count":1})
q.put(func)
q.put("333",block=False)    #默认为True 当你插入的数据超过最大限度，默认阻塞
# q.put(333,timeout=8)      #超过八秒在put不进数据，就会报错

print(q.get())
print(q.get())
ret = q.get()
ret()
# q.get()  #当你将数据取完，夯住，等待队列put值，起另一个进程往队列中插入数据

#q.put()
#1，maxsize()    #数据量不易过大，精简的重要数据
#2，put bolck    #默认为True阻塞 当你插入的数据超过最大限度，可以设置报错
#3，put timeout  #延时报错，超过三秒在put不进数据，就会报错

#get
#2，get bolck    #取值为空报错
#3，get timeout  #取值超过三秒报错

抢售模型 (并行示例)：

#小米:抢手机,预期发售10个,100人去抢
from multiprocessing import Queue
from multiprocessing import Process
import os

def task(q):
    try:
        q.put(f'{os.getpid()}')
    except Exception:
        return

if __name__ == '__main__':
    q = Queue(10)             #创建队列，可以存放十个人

    for i in range(100):
        p = Process(target=task,args=(q,))
        p.start()

    for i in range(1,11):  #数量超过队列会取
        print(f'排名第{i}的用户：{q.get()}') #获取队列中的信息，先进来的先取出来

#利用队列进行进程之间的通信：简单，方便，不用自己手动加锁，队列自带阻塞，可持续化取数据

生产者消费者模型(并发示例)：

利用队列进行通信，生产者生产数据，消费者获取数据使用，平衡了生产力和消费力，生产者和消费者是一种解耦合性(通过容器解决)，可持续化取数据
模型，设计模式，归一化设计，理论等等，教给你一个编程的思路，以后遇到类似的情况，以后直接调用就即可
生产者：生产数据的进程
消费者：生产出来的数据进行处理

#吃包子:厨师生产包子，不可能直接给你喂到嘴里，放在一个盆里，消费者从盆中取出包子食用
#三个主体：生产者(厨师)，容器队列(盘 缓冲区)，消费者(人)

#如果没有容器，生产者与消费者强解耦性，不合理，所以我们要有一个容器，缓冲区平衡了生产力与消费力

# 生产者消费者多应用于并发：
from multiprocessing import Queue
from multiprocessing import Process
import time
import random

def producer(name,q):
    for i in range(1,6):
        time.sleep(random.randint(1,3))
        res = f'{i}号包子'
        q.put(res)
        print(f'生产者{name}:生产了{res}')

def consumer(name,q):
    while 1:
        try:
            time.sleep(random.randint(1, 3))
            ret = q.get(timeout = 5)           #五秒还吃不到退出
            print(f'消费者{name}：吃了{ret}')
        except Exception:
            return

if __name__ == '__main__':
    q = Queue()    #盆

    p1 = Process(target=producer,args=("俊丽",q,))  #生产
    p2 = Process(target=consumer,args=("海洋",q,))  #消费

    p1.start()
    p2.start()

线程：

进程：进程是分配资源的基本单位，内存中开辟空间，为线程提供资源，一个程序可以开启多个进程
线程：CPU调度的最小单位，执行单位，线程也被称作为轻量级的进程，动态的
- 主线程是进程空间存活在内存中的一个必要条件
开启QQ：开启一个进程，在内存中开辟空间加载数据，启动一个线程执行代码
线程依赖进程的一个进程可以包含多个线程，但是一定有一个主线程，线程才是CPU执行的最小单元
进程线程对比:
- 1,开启多进程开销非常大，10-100倍，而开启线程开销非常小
- 2.开启多进程速度慢，开启多线程速度快
- 3.进程之间数据不共享，线程共享数据
多线程应用场景：
- 并发：一个CPU可以来回切换(线程之间切换)，多进程并发，多线程的并发
- 多进程并发：开启多个进程，并发的执行
- 多线程并发：开启线程，并发的执行
- 如果遇到并发：多线程居多

开启线程的两种方式：

线程绝对要比进程开启速度快

函数开启：

#先打印海洋，线程要比进程速度快，如果是进程先打印主线程
from threading import Thread

def task(name):
    print(f'{name} is running')

if __name__ == '__main__':
    t = Thread(target=task,args=("海洋",))
    t.start()
    print("主线程")
    
#子进程睡眠3秒，先运行主进程
from threading import Thread
import time
x = 1000

def task():
    time.sleep(3)
    print('子线程....')

def main():
    print('111')
    print('222')
    print('333')

if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    main()

类开启：

from threading import Thread

class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print(f'{self.name} is running')

if __name__ == '__main__':
    t = MyThread("海洋")
    t.start()
    print("主线程")

线程pid：

#主线程和子线程pid一样
from threading import Thread
import os

def task():
    print(f'子线程：{os.getpid()}')

if __name__ == '__main__':
    t = Thread(target=task,)
    t.start()
    print(f"主线程:{os.getpid()}")

线程之间数据共享：

from threading import Thread
x = 1000
def task():
    global x
    x = 0

if __name__ == '__main__':
    t = Thread(target=task, )
    t.start()
    t.join()  # 告知主线程，等待子线程运行完毕在执行
    print(f'主线程：{x}')

线程的方法：

from threading import Thread
import threading
import time

def task(name):
    time.sleep(1)
    print(f'{name} is running')

if __name__ == '__main__':
    for i in range(5):
        t = Thread(target=task,args=("海洋",))
        t.start()              #线程对象的方法
    # print(t.is_alive())     #判断线程是否存活
 			
    #threading模块的方法
    print(threading.current_thread().name)  #返回线程对象.name
    print(threading.enumerate())            #返回列表，返回的是所有线程对象
    print(threading.active_count())         #获取活跃的线程数量（包括主线程）
    print("主线程")

守护线程：

守护线程必须等待主线程结束才结束，主线程必须等待所有的非守护线程结束才能结束，因为主线程的结束意味着进程的结束，这就是一个守护机制
多线程是同一个空间，同一个进程，进程代表，空间，资源，静态的：

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('egon',))
    t.setDaemon(True) #必须在t.start()之前设置
    t.start()

    print('主线程')
    print(t.is_alive())   #判断进程是否存在也是主线程

from threading import Thread
import time

def foo():
    print(123)
    time.sleep(3)
    print("end123")

def bar():
    print(456)
    time.sleep(1)
    print("end456")

if __name__ == '__main__':

    t1=Thread(target=foo)
    t2=Thread(target=bar)

    t1.daemon = True
    t1.start()
    t2.start()		      #t2非守护线程，主线程等待子线程结束
    print("main-------")

线程互斥锁：

join：

from threading import Thread
import time
x = 100

def task(name):
    global x
    temp = x
    time.sleep(3)
    temp -= 1
    x = temp

if __name__ == '__main__':
    t = Thread(target=task,args=("海洋",))
    t.start()
    t.join()
    print(f"主线程{x}")
    
#多个线程抢占一个资源
from threading import Thread
import time
x = 100

def task(name):
    global x
    temp = x
    time.sleep(3)
    temp -= 1
    x = temp

if __name__ == '__main__':
    tl = []
    for i in range(100):
        t = Thread(target=task,args=("海洋",))
        tl.append(t)
        t.start()

    for i in tl:
        i.join()

    print(f"主进程{x}")   #多个线程抢占一个资源

互斥锁：

所有线程串行执行，多个线程共同抢占一个数据，保证了数据安全：

from threading import Thread
from threading import Lock
import time
x = 100

def task(lock):
    lock.acquire()
    global x
    temp = x
    time.sleep(0.1)
    temp -= 1
    x = temp
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    tl = []
    for i in range(100):
        t = Thread(target=task,args=(lock,))
        tl.append(t)
        t.start()

    for i in tl:
        i.join()

    print(f"主线程{x}")   #多个线程抢占一个资源，join让主线程等待子线程执行完成在执行，结果0

线程死锁现象：

多个线程或者进程竞争资源，如果开启的互斥锁过多，遇到互相抢锁造成互相等待情况,程序夯住，
还有一种是给同时给一个线程或者进程连续加锁多次，利用递归锁解决Rlock

from threading import Thread
from threading import Lock
import time

lock_A = Lock()
lock_B = Lock()

class Mtthread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        lock_A.acquire()
        print(f"{self.name}谁拿到A锁")

        lock_B.acquire()
        print(f"{self.name}谁拿到B锁")
        lock_B.release()

        lock_A.release()

    def f2(self):
        lock_B.acquire()
        print(f"{self.name}谁拿到B锁")

        time.sleep(1)
        lock_A.acquire()
        print(f"{self.name}谁拿到A锁")
        lock_A.release()

        lock_B.release()

if __name__ == '__main__':
    t1 = Mtthread()
    t1.start()

    t2 = Mtthread()
    t2.start()

    t3 = Mtthread()
    t3.start()
    print(f"主进程")

递归锁：

递归锁上有引用次数，每次引用计数+1，解锁计数-1，只有计数为0.在运行下个进程

#递归锁：
#递归锁是一把锁，锁上有记录，只要acquire一次，锁上就计数一次，acquire2次就计数两次
#release 1次减一，只要递归锁计数不为0，其他线程不能抢

from threading import Thread
from threading import RLock
import time

lock_A = lock_B = RLock()

class Mtthread(Thread):
    def run(self):
        # lock_A.acquire()
        # lock_B.acquire()
        # print(111)
        # lock_A.release()
        # lock_B.release()

        self.f1()
        self.f2()

    def f1(self):
        lock_A.acquire()
        print(f"{self.name}谁拿到A锁")

        lock_B.acquire()
        print(f"{self.name}谁拿到B锁")
        lock_B.release()

        lock_A.release()

    def f2(self):
        lock_B.acquire()
        print(f"{self.name}谁拿到B锁")

        time.sleep(1)
        lock_A.acquire()
        print(f"{self.name}谁拿到A锁")
        lock_A.release()

        lock_B.release()

if __name__ == '__main__':
    t1 = Mtthread()
    t1.start()
    t2 = Mtthread()
    t2.start()
    t3 = Mtthread()
    t3.start()
    print(f"主进程")

信号量：

信号量准许多个线程或者进程同时进入

from  threading import Thread
from  threading import current_thread
from  threading import Semaphore
import time
import random

sm = Semaphore(4)

def chi():
    sm.acquire()
    print(f"{current_thread().name}正在吃饭")
    time.sleep(random.randint(1,3))
    sm.release()

if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=chi)
        t.start()

GIL锁：

全局解释器锁，就是一把互斥锁，将并发变成串行，同一时刻只能有一个线程进入解释器，自动加锁和释放锁，牺牲效率保护python解释器内部数据安全
优点：
- 强行加锁，保证解释器里面的数据安全
缺点：
- 多进程可以利用多核，多进程的每个进程里面都有python解释器程序
- 单进程的多线程不能利用多核，python解释器内部程序，不支持多线程同时解释
讨论：
- python-单核处理IO阻塞的多线程，java多核处理IO阻塞问题，效率差不多
- 单核处理三个IO线程，多核处理三个IO线程，多核快些
代码的执行：
- CPython独有GIL锁：
  - 将你的py文件当做实参传送给解释器传换成c语言字节码，在交给虚拟机转换成010101机器码，这些代码都是线程执行，进程进行调度资源
- lpython：交互式解释器，可以补全代码
- Jpython：java语言字节码，剩下的一样
- pypy：动态编译，JAT技术，执行效率要比Cpython块，但是技术还有缺陷bug

验证Python开发效率：

单核CPU：
- 一核，都是单进程多线程并发快，因为单核开启多进程也是串行。
多核CPU：
- 计算密集型：
  - 多进程的并行比多线程的并发执行效率高很多（因为不同进程运行在不同核心上，并行执行）
- IO密集型：
  - 多线程要比多进程处理速度快，因为进程开销大，而线程处理其实也是串行，只不过处理速度比进程更快些，线程一次只能处理一个事情（空间复用）
  - 开启150个进程(开销大，速度慢)，执行IO任务耗时长
  - 开启150个线程(开销小，速度快)，执行IO任务耗时短
如果你的任务是io密集型并且任务数量大，用单进程下的多线程处理阻塞效率高

计算密集型：

from multiprocessing import Process
from threading import Thread
import time
import os
# print(os.cpu_count())

def task1():
    res = 1
    for i in range(1, 100000000):
        res += i
def task2():
    res = 1
    for i in range(1, 100000000):
        res += i
def task3():
    res = 1
    for i in range(1, 100000000):
        res += i
def task4():
    res = 1
    for i in range(1, 100000000):
        res += i

if __name__ == '__main__':
    # 四个进程 四个cpu 并行 效率
    start_time = time.time()
    p1 = Process(target=task1)
    p2 = Process(target=task2)
    p3 = Process(target=task3)
    p4 = Process(target=task4)

    p1.start()
    p2.start()
    p3.start()
    p4.start()

    p1.join()
    p2.join()
    p3.join()
    p4.join()
    print(f'主: {time.time() - start_time}')   # 10.125909328460693

# 一个进程 四个线程
#     start_time = time.time()
#     p1 = Thread(target=task1)
#     p2 = Thread(target=task2)
#     p3 = Thread(target=task3)
#     p4 = Thread(target=task4)
#
#     p1.start()
#     p2.start()
#     p3.start()
#     p4.start()
#
#     p1.join()
#     p2.join()
#     p3.join()
#     p4.join()
#     print(f'主: {time.time() - start_time}')  # 22.927688121795654

计算IO密集型：

from multiprocessing import Process
from threading import Thread
import time
import os
# print(os.cpu_count())

def task1():
    res = 1
    time.sleep(3)

if __name__ == '__main__':
# 开启150个进程(开销大,速度慢),执行IO任务, 耗时 8.382229089736938
#     start_time = time.time()
#     l1 = []
#     for i in range(150):
#         p = Process(target=task1)
#         l1.append(p)
#         p.start()
#     for i in l1:
#         i.join()
#     print(f'主: {time.time() - start_time}')

# 开启150个线程(开销小,速度快),执行IO任务, 耗时 3.0261728763580322
#     start_time = time.time()
#     l1 = []
#     for i in range(150):
#         p = Thread(target=task1)
#         l1.append(p)
#         p.start()
#     for i in l1:
#         i.join()
#     print(f'主: {time.time() - start_time}')

GIL锁和互斥锁关系：

线程计算密集型：
- 当程序执行，开启100个线程时，第一个线程先要拿到GIL锁，然后拿到lock锁，执行代码，释放lock锁，最后释放GIL锁
线程IO密集型：
- 当程序执行，开启100个线程时，第一个线程先要拿到GIL锁，然后拿到lock锁，遇到阻塞，CPU切走，GIL释放，第一个线程挂起
- 第二个线程执行，抢到GIL锁，进入要抢lock,但是lock锁还没释放，阻塞挂起
自己加互斥锁，一定要加在处理共享数据的地方，加的范围不要扩大，范围过大，影响并发
GIL锁单进程的多线程不能利用多核，不能并行，但是可以并发
互斥锁：
- GIL自动上锁解锁，文件中的互斥锁Lock，手动上锁解锁
- GIL锁，保护解释器的数据安全，互斥锁是保护的文件的数据安全

线程池：

线程池在系统启动时创建了大量的空闲线程，线程执行直接调用线程池中已经开启好的空闲线程，当线程执行结束，该线程不会死亡，而是将线程变成空闲状态，放回进程池。
线程池提高效率，资源复用
进程池：放置进程的一个容器
线程池：放置线程的一个容器
完成一个简单的socket通信，服务端必须与一个客户端交流完毕，并且这个客户端断开连接之后，服务端才能接待下一个客户：

#开启进程池或者线程池：
#线程池好还是进程池好：io阻塞或者计算密集型
from  concurrent.futures import ProcessPoolExecutor
from  concurrent.futures import ThreadPoolExecutor
import time
import os
import random

def task(name):
    # print(name)
    print(f"{os.getpid()}准备接客")
    time.sleep(random.randint(1,3))

if __name__ == '__main__':
    # p = ProcessPoolExecutor(max_workers=5)  #限制进程数量，默认为cpu个数
    p = ThreadPoolExecutor()  				  #线程默认是CPU个数的五倍

    for i in range(23):
        p.submit(task,1)                      #给进程池放置任务启动，1为传参

阻塞，非阻塞：

程序运行中的状态，阻塞，运行，就绪
阻塞：当你程序遇到IO阻塞挂起，CPU切换，等到IO结束之后再执行
非阻塞：程序没有IO，或者遇到IO通过某种手段让cpu去执行其他任务，尽可能的占用CPU

同步：

任务发出去之后等待，直到这个任务最终结束之后，给我一个返回值，发布下一个任务
同步示例：

from concurrent.futures import ProcessPoolExecutor
import os
import time
import random

def task():
    print(f"{os.getpid()}is running")
    time.sleep(1)
    return f'{os.getpid()} is finish'

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)

    for i in range(10):
        obj = p.submit(task,)
        print(obj.result())      #同步等待一个进程内容全部执行完成在执行下一个

异步：

将任务发给进程，不管任务如何，直接运行下一个
异步示例：

from concurrent.futures import ProcessPoolExecutor
import os
import time
import random

def task():
    print(f'{os.getpid()} is running')
    time.sleep(random.randint(0,2))
    return f'{os.getpid()} is finish'

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)
    obj_l1 = []
    for i in range(10):
        obj = p.submit(task,)   # 异步发出.
        obj_l1.append(obj)

    # time.sleep(3)
    p.shutdown(wait=True)
    # 1. 阻止在向进程池投放新任务,
    # 2. wait = True 十个任务是10,一个任务完成了-1,直至为零.进行下一行.
    for i in obj_l1:
        print(i.result())

异步+回调机制：

异步发布任务，就不管任务结果
回调：
- 回调是你异步发布任务执行完成后，将结果丢给回调函数add_done_callback，回调函数帮你分析结果，进程继续完成下一个任务
- 回调就是对特定的事件或者条件进行响应

爬虫：游览器做的事情很简单：
- 浏览器封装头部，发送一个请求--->www.taobao.com ----> 服务器获取到请求信息，分析正确--->给你返回一个文件，--->游览器将这个文件的代码渲染，就成了你看的样子
- 爬虫：利用reauests模块功能模拟游览器封装头，给服务器发送一个请求，骗过服务器之后，服务器也会给你返回一个文件，爬虫拿到文件，进行数据清洗获取到你想要的信息
爬虫分两步：
- 第一步：爬取服务器端的文件（IO阻塞）
- 第二部：拿到文件，进行数据分析（非IO，IO极少）

错误版本示例：

import requests
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Process
import time
import random
import os

def get(url):
    response = requests.get(url)
    print(f'{os.getpid()} 正在爬取:{url}')
    time.sleep(random.randint(1,3))
    if response.status_code == 200:
        return response.text

def parse(text):
    print(f'{os.getpid()} 分析结果:{len(text)}')

if __name__ == '__main__':
    url_list = [
        'http://www.taobao.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.baidu.com',
        'https://www.cnblogs.com/jin-xin/articles/11232151.html',
        'https://www.cnblogs.com/jin-xin/articles/10078845.html',
        'http://www.sina.com.cn',
        'https://www.sohu.com',
        'https://www.youku.com',
    ]
    pool = ProcessPoolExecutor(4)
    obj_list = []
    for url in url_list:
        obj = pool.submit(get, url)
        obj_list.append(obj)

    pool.shutdown(wait=True)

    for obj in obj_list:          #抓取网页是串行，输出的结果
        parse(obj.result())

#爬取一个网页需要2s,并发爬取10个网页:2.多s.
#分析任务: 1s.    10s. 总共12.多秒.
 
# 现在这个版本的过程:
# 异步发出10个爬取网页的任务,然后4个进程并发(并行)的先去完成4个爬取网页的任务,然后谁先结束,谁进行下一个
# 爬取任务,直至10个任务全部爬取成功.
# 将10个爬取结果放在一个列表中,串行的分析.


import requests
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Process
import time
import random
import os

def get(url):
    response = requests.get(url)
    print(f'{os.getpid()} 正在爬取:{url}')
    time.sleep(random.randint(1,3))
    if response.status_code == 200:
        parse(response.text)

def parse(text):
    print(f'{os.getpid()} 分析结果:{len(text)}')

if __name__ == '__main__':
    url_list = [
        'http://www.taobao.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.baidu.com',
        'https://www.cnblogs.com/jin-xin/articles/11232151.html',
        'https://www.cnblogs.com/jin-xin/articles/10078845.html',
        'http://www.sina.com.cn',
        'https://www.sohu.com',
        'https://www.youku.com',
    ]
    pool = ProcessPoolExecutor(4)
    for url in url_list:
        obj = pool.submit(get, url)

    # pool.shutdown(wait=True)
    print('主')
#异步发出10个 爬取网页+分析 的任务,然后4个进程并发(并行)的先去完成4个爬取网页+分析 的任务,
#然后谁先结束,谁进行下一个 爬取+分析 任务,直至10个爬取+分析 任务全部完成成功.

正确版本示例：

import requests
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Process
import time
import random
import os

def get(url):
    response = requests.get(url)
    print(f'{os.getpid()} 正在爬取:{url}')
    if response.status_code == 200:
        return response.text

def parse(obj):
    time.sleep(1)
    print(f'{os.getpid()} 分析结果:{len(obj.result())}')

if __name__ == '__main__':

    url_list = [
        'http://www.taobao.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.JD.com',
        'http://www.baidu.com',
        'https://www.cnblogs.com/jin-xin/articles/11232151.html',
        'https://www.cnblogs.com/jin-xin/articles/10078845.html',
        'http://www.sina.com.cn',
        'https://www.sohu.com',
        'https://www.youku.com',
    ]
    start_time = time.time()
    pool = ProcessPoolExecutor(4)
    for url in url_list:
        obj = pool.submit(get, url)
        obj.add_done_callback(parse)
        # 增加一个回调函数
        # 现在的进程完成的还是网络爬取的任务,拿到了返回值之后,结果丢给回调函数add_done_callback,
        # 回调函数帮助你分析结果
        # 进程继续完成下一个任务.
    pool.shutdown(wait=True)   #阻止发布新的任务，代替join

    print(f'主: {time.time() - start_time}')
    
# 回调函数是主进程帮助你实现的, 回调函数帮你进行分析任务. 明确了进程的任务: 只有一个网络爬取.
# 分析任务: 回调函数执行了.对函数之间解耦.

# 极值情况: 如果回调函数是IO任务,那么由于你的回调函数是主进程做的,所以有可能影响效率.

# 回调不是万能的,如果回调的任务是IO,
# 那么异步 + 回调机制 不好.此时如果你要效率只能牺牲开销,再开一个线程进程池.

队列模式：

FIFO 先进先出原则：

import queue
q = queue.Queue(3)
q.put(1)
q.put(2)
q.put('海洋')

print(q.get())
print(q.get())
print(q.get())

LIFO 栈.-先进后出：

import queue
q = queue.LifoQueue()
q.put(1)
q.put(3)
q.put('海洋')

print(q.get())
print(q.get())
print(q.get())

优先级队列：

# 需要元组的形式,(int,数据) int 代表优先级,数字越低,优先级越高.
import queue
q = queue.PriorityQueue(3)

q.put((10, '垃圾消息'))
q.put((-9, '紧急消息'))
q.put((3, '一般消息'))

print(q.get())
print(q.get())
print(q.get())

事件Event：

并发的执行某个任务，多进程多线程，几乎同时执行，一个线程执行到中间时，通知另一个线程开始执行

import time
from threading import Thread
from threading import current_thread
from threading import Event
			
event = Event()  # 默认是False
def task():
    print(f'{current_thread().name} 检测服务器是否正常开启....')
    time.sleep(3)   # 先运行task阻塞三秒，在将event修改为True
    event.set()     # 改成了True

def task1():
    print(f'{current_thread().name} 正在尝试连接服务器')
    # event.wait()  # 轮询检测event是否为True,当其为True,继续下一行代码. 阻塞
    event.wait(1)
    # 设置超时时间,如果1s中以内,event改成True,代码继续执行.
    # 设置超时时间,如果超过1s中,event没做改变,代码继续执行.
    print(f'{current_thread().name} 连接成功')
    
if __name__ == '__main__':
    t1 = Thread(target=task1,)
    t2 = Thread(target=task1,)
    t3 = Thread(target=task1,)

    t = Thread(target=task)
    t.start()

    t1.start()
    t2.start()
    t3.start()

协程：

协程的本质也是一个线程，而使用协程目的是为了减少系统开销，协程是我们通过程序来控制任务切换，协程速度比系统更快，最大限度的利用CPU，更加轻量级
线程协程的区别：
- 协程没有锁，协程又称微线程
- 线程和协程不同的是，线程是抢占式调度切换，而协程是需要自己调度
- 线程和进程，调度是CPU决定的，而协程就是上帝，在一个线程中规定某个代码块的执行顺序

1,协程切换开销更小，属于程序级别的切换，操作系统完全感知不到，更加轻量级
2.单线程内就可以实现并发的效果，最大限度的利用CPU
3.修改共享的数据不需要加锁
协程就像线程一样也是在多任务间来回切换
在其他语言中，协程的意义不大，多线程即可以解决I/O问题，在python中有GIL锁，在同一时间只有一个线程在工作，所以一个线程里面IO操作特别多，协程比较适用
串行：多个任务执行时，一个任务从开始执行，遇到IO等待，等待IO阻塞结束之后再执行下一个
并行：多核多个线程或者进程同时执行，四个CPU同时执行四个任务
并发：多个任务看起来是同时执行，CPU在多个任务之间来回切换，遇到IO阻塞，计算密集型执行时间过长
- 并发本质：遇到IO阻塞，计算密集型执行时间过长，保持原来的状态
一个线程实现开发：
- 多进程:操作系统控制，多个进程的多个任务切换 + 保持状态
- 多线程程:操作系统控制，多个线程的多个任务切换 + 保持状态
- 协程：程序控制一个线程的多个任务的切换以及保持状态
  - 微并发，处理任务不宜过多
  - 协程他会调度CPU，如果协程管控的任务中，遇到阻塞，他会快速的(比操作系统快)，切换到另一个任务，并且能将上一个任务挂起（保持状态），让操作系统以为CPU一直在工作

串行和协程对比：

密集型数据串行和协程对比，肯定串行速度快，因为协程运行还要来回切换

import time
def task1():
    res = 1
    for i in range(1,100000):
        res += i

def task2():
    res = 1
    for i in range(1,100000):
        res -= i

start_time = time.time()
task1()
task2()
print(f'串行消耗时间:{time.time()-start_time}')  # 串行消耗时间:0.012489557266235352


def task1():
    res = 1
    for i in range(1, 100000):
        res += i
        yield res

def task2():
    g = task1()
    res = 1
    for i in range(1, 100000):
        res -= i
        next(g)

start_time = time.time()
task2()
print(f'协程消耗时间:{time.time() - start_time}')  # 协程消耗时间:0.02991938591003418

开启协程：

遇到gevent阻塞切换：

import gevent
import time
def eat(name):
    print('%s eat 1' %name)     # 1
    gevent.sleep(2)              #协程识别gevent,可以进行IO切换
    # time.sleep(300)            #协程不识别切换不了,不可切换
    print('%s eat 2' %name)     # 4

def play(name):
    print('%s play 1' %name)    # 2
    gevent.sleep(1)
    # time.sleep(3)
    print('%s play 2' %name)    # 3

g1 = gevent.spawn(eat, '海洋')
g2 = gevent.spawn(play, name='俊丽')   #协程异步发布任务
# g1.join()
# g2.join()
#或者gevent.joinall([g1,g2])
gevent.joinall([g1,g2])                #主线程等待协程执行完毕
print('主')                            #5

所有IO阻塞都可以切换：

import threading
from gevent import monkey
monkey.patch_all()         # 将你代码中的所有的IO都标识.

import gevent              # 直接导入即可
import time

def eat():
    print(f'线程1:{threading.current_thread().getName()}')    # 1
    print('eat food 1')                                      # 2
    time.sleep(3)          # 加上mokey就能够识别到time模块的sleep了
    print('eat food 2')                                      # 6

def play():
    print(f'线程2:{threading.current_thread().getName()}')    # 3
    print('play 1')                                          # 4
    time.sleep(1)  
    # 来回切换，直到一个I/O的时间结束，这里都是我们个gevent做得，不再是控制不了的操作系统了。
    print('play 2')                                          # 5

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print(f'主:{threading.current_thread().getName()}')          # 7

posted @ 2019-07-19 17:20 海洋1994 阅读(503) 评论(0) 编辑收藏举报

刷新页面返回顶部

海洋

并发编程

并发编程：

操作系统：

操作系统定义：

操作系统的作用：

操作系统（计算机）的发展史：

知识点解析:

多道技术解决的问题：

时间复用：

空间复用：

数据隔离：

进程：

概念：

进程的创建：

创建进程的两种方法：

函数-创建进程：

类-创建进程(了解)：

进程PID：

进程之间数据隔离：

join方法：

进程对象的其他属性：

僵尸进程：

孤儿进程：

守护进程：

进程之间的通信方式：

互斥锁：

队列：

队列模式：

队列参数：

抢售模型 (并行示例)：

生产者消费者模型(并发示例)：

线程：

开启线程的两种方式：

函数开启：

类开启：

线程pid：

线程之间数据共享：

线程的方法：

守护线程：

线程互斥锁：

join：

互斥锁：

线程死锁现象：

递归锁：

信号量：

GIL锁：

优点：

缺点：

讨论：

代码的执行：

CPython独有GIL锁：

验证Python开发效率：

单核CPU：

多核CPU：

计算密集型：

GIL锁和互斥锁关系：

线程计算密集型：

线程IO密集型：

互斥锁：

线程池：

阻塞，非阻塞：

同步：

同步示例：

异步：

异步示例：

异步+回调机制：

爬虫：游览器做的事情很简单：

爬虫分两步：

错误版本示例：

正确版本示例：

队列模式：

FIFO 先进先出原则：

LIFO 栈.-先进后出：

优先级队列：

事件Event：

协程：

串行和协程对比：

密集型数据串行和协程对比，肯定串行速度快，因为协程运行还要来回切换

开启协程：