同步异步

港控/mmm° 2023-08-17 15:25 122阅读 0赞

### 阻塞 非阻塞 同步 异步 ###

进程运行的三个状态:运行, 就绪,阻塞

#### 两个角度分析 执行和提交任务 ####

执行角度

**阻塞 : 程序运行时遇到 IO,程序挂起,CPU 被切走**

**非阻塞:程序没有遇到 IO ,程序遇到 IO 但是我通过某种手段,让 CPU 强行运行我的程序**

提交任务的角度

**同步:提交一个任务,自任务开始运行,直到此任务结束,(可能有 IO)返回一个返回值之后,我再提交下一个任务**

**异步:提交多个任务,我就直接执行下一行代码**

**返回结果如何回收??**

举个例子说明一下什么是同步和异步

同步:

先告知第一个老师完成写书的任务,我在原地等待,等待两三天之后完成后,告诉完事了,我再发布下一个任务

异步:

直接将三个任务告知三个老师,我就忙我的,直到三个老师完成后,告知我

#### 同步异步 代码层的分析 ####

**1.异步调用**

#  1. 异步调用
    #  异步调用返回值如何接收? 未解决
    from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    import os
    import random
    def task(i):
        print(f"{os.getpid()}开始任务")
        time.sleep(random.randint(1,3))
        print(f"{os.getpid()}任务结束")
        return i
    if __name__ == '__main__':
        pool = ProcessPoolExecutor ()
        for i in range(10):
            pool.submit(task,i)
        pool.shutdown(wait = True)
        #shutdown 让我的主进程等待进程池中所有的子进程都结束任务后
        #再执行,有点类似于 join
        # 在上一个进程池没有完成所有的任务之前,不允许添加新的任务
        # 一个任务是通过函数实现的,任务完成了他的返回值就是函数的返回值
    
        print('====主')
        
        结果是一次性给的

**2.同步调用**

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    import random
    import os
    def task(i):
        print(f"{os.getpid()}开始任务")
        time.sleep(random.randint(1,3))
        print(f"{os.getpid()}任务结束")
        return i
    if __name__ == '__main__':
        pool = ProcessPoolExecutor()
        for i in range(10):
            obj = pool.submit(task,i)
            # obj是一个动态对象,返回当前的对象状态,有可能运行中,
            # 可能(就绪阻塞),还可能是结束了
            # obj.result() 必须等到这个任务完成后,返回了结果之后
            # 再执行下一个任务
            print(f"任务结果:{obj.result()}")
        pool.shutdown(wait = True)
        print('===主')
        
        
       结果是一个一个来的

**3.异步如何返回结果**

方式一:异步调用,统一回收结果

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    import os
    import random
    def task(i):
        print(f"{os.getpid()}开始任务")
        time.sleep(random.randint(1,3))
        print(f"{os.getpid()}任务结束")
        return i
    if __name__ == '__main__':
        pool = ProcessPoolExecutor()
        l1 = []
        for i in range(10):
            obj = pool.submit(task,i)
            l1.append(obj)
        pool.shutdown(wait = True)
        for i in l1:
            print(i.result())
        print('====主')
    ## 统一回收结果:我不能马上收到任何一个已经完成的任务的返回值,
    # 我只能等到所有的任务全部结束后统一回收

方式二:

#### 异步调用 + 回调函数 ####

#### 爬虫 ####

浏览器工作原理,向服务端发送一个请求,服务端验证你的请求,如果正确,给你的浏览器返回一个文件,浏览器接收到文件,将文件里的代码渲染成你看到的漂亮模样

**什么叫 爬虫??**

1.  利用代码模拟一个浏览器,进行浏览器的工作流程得到一堆源代码
2.  对源代码进行数据清洗得到我想要的数据

import requests
    ret = requests.get('http://www.baidu.com')
    if ret.status_code == 200:
        print(ret.text)  #  得到源代码

版本一:

版本一:
    
         1. 异步发出10个任务,并发的执行,但是统一的接收所有的任务的返回值.(效率低,不能实时的获取结果)
    
         2. 分析结果流程是串行,影响效率.
    
              for res in obj_list:
    
                 print(parse(res.result()))
                 
                 
           版本一:
             线程池设置4个线程, 异步发起10个任务,每个任务是通过网页获取源码, 并发执行,
             最后统一用列表回收10个任务, 串行着分析源码.(没有对数据进行操作)

代码分析

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    import random
    import os
    import requests
    def task(url):
        ret = requests.get(url)
        if ret.status_code == 200:
            return ret.text
    
    def parse(content):
        return len(content)
    
    if __name__ == '__main__':
        ret = task('http://www.baidu.com')
        print(parse(ret))
    
        ret = task('http://www.JD.com')
        print(parse(ret))
    
        ret = task('http://www.taobao.com')
        print(parse(ret))
    
        ret = task('https://www.cnblogs.com/jin-xin/articles/7459977.html')
        print(parse(ret))
        #  开启线程池,并发并行的执行
        url_list = [
             'http: // www.baidu.com',
                'http://www.JD.com',
                'http://www.JD.com',
                'http://www.JD.com',
                'http://www.taobao.com',
                'https://www.cnblogs.com/jin-xin/articles/7459977.html',
                'https://www.luffycity.com/',
                'https://www.cnblogs.com/jin-xin/articles/9811379.html',
                'https://www.cnblogs.com/jin-xin/articles/11245654.html',
                'https://www.sina.com.cn/',
        ]
        pool = ThreadPoolExecutor(4)
        obj_list = []
        for url in url_list:
            obj = pool.submit(task,url)
            obj_list.append(obj)
        pool.shutdown(wait = True)
        for res in obj_list:
            print(parse(res.result()))

版本二

版本二:
    
            线程池设置4个线程, 异步发起10个任务,每个任务是通过网页获取源码+数据分析, 并发执行,
    
             最后将所有的结果展示出来.
    
             耦合性增强了.
    
             并发执行任务,此任务最好是IO阻塞,才能发挥最大的效果

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
    import time
    import random
    import os
    import requests
    def task(url):
        ret = requests.get(url)
        if ret.status_code == 200:
            return parse(ret.text)
    def parse(content):
        return len(content)
    if __name__ == '__main__':
        url_list = [
                'http://www.baidu.com',
                'http://www.JD.com',
                'http://www.JD.com',
                'http://www.JD.com',
                'http://www.taobao.com',
                'https://www.cnblogs.com/jin-xin/articles/7459977.html',
                'https://www.luffycity.com/',
                'https://www.cnblogs.com/jin-xin/articles/9811379.html',
                'https://www.cnblogs.com/jin-xin/articles/11245654.html',
                'https://www.sina.com.cn/',
            ]
        pool = ThreadPoolExecutor(4)
        obj_list = []
        for url in url_list:
            obj = pool.submit(task,url)
            obj_list.append(obj)
    
        pool.shutdown(wait = True)
        for res in obj_list:
            print(res.result())
            
            
    2381
    100180
    100180
    100180
    143902
    47067
    2708
    21634
    48110
    571508

版本三

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
    
    import time
    
    import random
    
    import os
    
    import requests
    def task(url):
    
        '''模拟的就是爬取多个源代码 一定有IO操作'''
    
        ret = requests.get(url)
    
        if ret.status_code == 200:
    
            return ret.text
    def parse(obj):
    
        '''模拟对数据进行分析 一般没有IO'''
    
        print(len(obj.result()))
    
    if __name__ == '__main__':
    
        # 开启线程池,并发并行的执行
    
        url_list = [
    
            'http://www.baidu.com',
    
            'http://www.JD.com',
    
            'http://www.JD.com',
    
            'http://www.JD.com',
    
            'http://www.taobao.com',
    
            'https://www.cnblogs.com/jin-xin/articles/7459977.html',
    
            'https://www.luffycity.com/',
    
            'https://www.cnblogs.com/jin-xin/articles/9811379.html',
    
            'https://www.cnblogs.com/jin-xin/articles/11245654.html',
    
            'https://www.sina.com.cn/',
    
    
    
        ]
    
        pool = ThreadPoolExecutor(4)
        for url in url_list:
    
            obj = pool.submit(task, url)
    
            obj.add_done_callback(parse)
    
    
    
        '''
    
        线程池设置4个线程, 异步发起10个任务,每个任务是通过网页获取源码, 并发执行,
    
        当一个任务完成之后,将parse这个分析代码的任务交由剩余的空闲的线程去执行,你这个线程继续去处理其他任务.
    
        如果进程池+回调: 回调函数由主进程去执行.
    
        如果线程池+回调: 回到函数由空闲的线程去执行.
    
        '''
    
    
    
    # 异步 回调是一回事儿?
    
    # 异步站在发布任务的角度,
    
    # 站在接收结果的角度: 回调函数 按顺序接收每个任务的结果,进行下一步处理.
    
    
    
    # 异步 + 回调:
    
    # 异步处理的IO类型.
    
    # 回调处理非IO

转载于:https://www.cnblogs.com/hualibokeyuan/p/11414125.html