feat: 添加对爬虫类Spider的优化，包括引入psutil库来监控CPU和内存使用情况，以及使用tracemalloc库来追踪内存使用。同时，删除了冗余的代码和注释，使代码更加简洁。

B 高性能模式/000 普通做法.py

@@ -1,74 +1,22 @@
-"""
-根据提供的关键词列表，爬取天水市人民政府网站上指定日期内与关键词相关的新闻的标题，并将其存储至数据库中。
-
-考虑到相关因素，因此本代码只爬取前10页的新闻内容，即最多100条新闻作为测试。
-
-此方法为普通做法，即使用requests库通过Post请求爬取网页内容，再使用json提取新闻内容。
-
-注意：本代码中的关键词列表默认为['灾害']，日期范围默认为2018年1月1日至2018年12月31日。
-
-Args:
-    keywords: 用于搜索新闻的关键词列表
-    begin_date: 开始日期，用于搜索
-    end_date: 结束日期，用于搜索
-    size: 一次请求返回的新闻或政策的最大数量
-
-Examples:
-    ```
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
-    ```
-"""
 import util
-import logging
-from typing import List
-
-import tqdm
-
 
-@util.timeit
-def main(keywords: List[str], begin_date: str, end_date: str, size: int = 10):
-    """
-    爬取与提供的关键词列表相关的新闻.
 
-    Args:
-        keywords: 用于搜索新闻的关键词列表
-        begin_date: 开始日期，用于搜索
-        end_date: 结束日期，用于搜索
-        size: 一次请求返回的新闻或政策的最大数量
-    """
-    logging.basicConfig(level=logging.INFO,
-                        format="%(asctime)s - %(levelname)s - %(message)s",
-                        datefmt="%Y-%m-%d %H:%M:%S",
-                        filename='log.txt',
-                        encoding='utf-8')
+@util.measure_performance
+def compute_task():
+    for _ in range(5):
+        util.compute_task()
 
-    logging.info("开始运行普通爬取")
 
-    spider = util.Spider(keywords=keywords,
-                         begin_date=begin_date,
-                         end_date=end_date,
-                         size=size)
+@util.measure_performance
+def io_task():
+    for url in util.urls:
+        util.fetch_url(url)
 
-    pbar = tqdm.tqdm(total=size * 10, desc='普通爬取进度', unit='条', ncols=80)
-    title_list = []
-    for keyword in keywords:
-        for current in range(1, 11):
-            logging.info(f'keyword: {keyword}, current: {current}')
-            config = spider.get_config(keyword, current)
-            data = spider.fetch(config)
-            title_list += spider.parse(data)
-            pbar.update(size)
 
-    spider.save(title_list)
-    pbar.close()
-    logging.info("爬取完成")
+def main():
+    compute_task()
+    io_task()
 
 
 if __name__ == "__main__":
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
+    main()

B 高性能模式/010 多进程.py

@@ -1,86 +1,34 @@
-"""
-根据提供的关键词列表，爬取天水市人民政府网站上指定日期内与关键词相关的新闻的标题，并将其存储至数据库中。
-
-考虑到相关因素，因此本代码只爬取前10页的新闻内容，即最多100条新闻作为测试。
-
-此方法为多进程做法，即使用多进程并发爬取网页内容，再使用json提取新闻内容。
-
-注意：本代码中的关键词列表默认为['灾害']，日期范围默认为2018年1月1日至2018年12月31日。
-
-Args:
-    keywords: 用于搜索新闻的关键词列表
-    begin_date: 开始日期，用于搜索
-    end_date: 结束日期，用于搜索
-    size: 一次请求返回的新闻或政策的最大数量
-
-Examples:
-    ```
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
-    ```
-"""
 import util
-import logging
-from typing import List
 import multiprocessing
 
-import tqdm
-
-lock = multiprocessing.Lock()
-
-
-@util.timeit
-def main(keywords: List[str], begin_date: str, end_date: str, size: int = 10):
-    """
-    爬取与提供的关键词列表相关的新闻.
-
-    Args:
-        keywords: 用于搜索新闻的关键词列表
-        begin_date: 开始日期，用于搜索
-        end_date: 结束日期，用于搜索
-        size: 一次请求返回的新闻或政策的最大数量
-    """
-    logging.basicConfig(level=logging.INFO,
-                        format="%(asctime)s - %(levelname)s - %(message)s",
-                        datefmt="%Y-%m-%d %H:%M:%S",
-                        filename='log.txt',
-                        encoding='utf-8')
-
-    logging.info("开始运行普通做法")
-
-    spider = util.Spider(keywords=keywords,
-                         begin_date=begin_date,
-                         end_date=end_date,
-                         size=size)
 
-    title_list = []
-    pbar = tqdm.tqdm(total=size * 10, desc='多进程爬取进度', unit='条', ncols=80)
+@util.measure_performance
+def compute_task():
+    processes = [
+        multiprocessing.Process(target=util.compute_task) for _ in range(5)
+    ]
+    for process in processes:
+        process.start()
+    for process in processes:
+        process.join()
 
-    with multiprocessing.Pool(processes=5) as pool:
-        results = []
-        for keyword in keywords:
-            for current in range(1, 11):
-                logging.info(f'keyword: {keyword}, current: {current}')
-                config = spider.get_config(keyword, current)
-                results.append(pool.apply_async(spider.fetch, (config, )))
 
-        for result in results:
-            data = result.get()
-            title_list += spider.parse(data)
+@util.measure_performance
+def io_task():
+    processes = [
+        multiprocessing.Process(target=util.fetch_url, args=(url, ))
+        for url in util.urls
+    ]
+    for process in processes:
+        process.start()
+    for process in processes:
+        process.join()
 
-            lock.acquire()
-            pbar.update(size)
-            lock.release()
 
-    spider.save(title_list)
-    pbar.close()
-    logging.info("爬取完成")
+def main():
+    compute_task()
+    io_task()
 
 
 if __name__ == "__main__":
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
+    main()

B 高性能模式/020 多线程.py

@@ -1,89 +1,52 @@
-"""
-根据提供的关键词列表，爬取天水市人民政府网站上指定日期内与关键词相关的新闻的标题，并将其存储至数据库中。
-
-考虑到相关因素，因此本代码只爬取前10页的新闻内容，即最多100条新闻作为测试。
-
-此方法为多线程做法，即使用多线程并行爬取网页内容，再使用json提取新闻内容。
-
-注意：本代码中的关键词列表默认为['灾害']，日期范围默认为2018年1月1日至2018年12月31日。
-
-Args:
-    keywords: 用于搜索新闻的关键词列表
-    begin_date: 开始日期，用于搜索
-    end_date: 结束日期，用于搜索
-    size: 一次请求返回的新闻或政策的最大数量
-
-Examples:
-    ```
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
-    ```
-"""
-
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import threading
 import util
-import logging
-from typing import List
 
-import tqdm
 
-lock = threading.Lock()
+@util.measure_performance
+def compute_task():
+    threads = [threading.Thread(target=util.compute_task) for _ in range(5)]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
 
 
-@util.timeit
-def main(keywords: List[str], begin_date: str, end_date: str, size: int = 10):
-    """
-    爬取与提供的关键词列表相关的新闻.
+@util.measure_performance
+def compute_task_threadpool():
+    with ThreadPoolExecutor(max_workers=5) as executor:
+        tasks = [executor.submit(util.compute_task) for _ in range(5)]
+        for future in as_completed(tasks):
+            future.result()
 
-    Args:
-        keywords: 用于搜索新闻的关键词列表
-        begin_date: 开始日期，用于搜索
-        end_date: 结束日期，用于搜索
-        size: 一次请求返回的新闻或政策的最大数量
-    """
-    logging.basicConfig(level=logging.INFO,
-                        format="%(asctime)s - %(levelname)s - %(message)s",
-                        datefmt="%Y-%m-%d %H:%M:%S",
-                        filename='log.txt',
-                        encoding='utf-8')
 
-    logging.info("开始运行多线程爬取")
+@util.measure_performance
+def io_task():
+    threads = [
+        threading.Thread(target=util.fetch_url, args=(url, ))
+        for url in util.urls
+    ]
+    for thread in threads:
+        thread.start()
+    for thread in threads:
+        thread.join()
 
-    spider = util.Spider(keywords=keywords,
-                         begin_date=begin_date,
-                         end_date=end_date,
-                         size=size)
 
-    pbar = tqdm.tqdm(total=size * 10, desc='多线程爬取进度', unit='条', ncols=80)
-    title_list = []
-    tasks = []
+# 多线程+线程池优化
+@util.measure_performance
+def io_task_threadpool():
     with ThreadPoolExecutor(max_workers=5) as executor:
-        for keyword in keywords:
-            for current in range(1, 11):
-                logging.info(f'keyword: {keyword}, current: {current}')
-
-                config = spider.get_config(keyword, current)
-                future = executor.submit(spider.fetch, config)
-                tasks.append(future)
-                # 更新进度条
-                lock.acquire()
-                pbar.update(size)
-                lock.release()
-
+        tasks = [executor.submit(util.fetch_url, url) for url in util.urls]
         for future in as_completed(tasks):
-            data = future.result()
-            title_list += spider.parse(data)
+            future.result()
+
 
-    spider.save(title_list)
-    pbar.close()
-    logging.info("爬取完成")
+def main():
+    compute_task()
+    compute_task_threadpool()
+    io_task()
+    io_task_threadpool()
 
 
 if __name__ == "__main__":
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
+    main()

B 高性能模式/030 协程.py

@@ -1,89 +1,21 @@
-"""
-根据提供的关键词列表，爬取天水市人民政府网站上指定日期内与关键词相关的新闻的标题，并将其存储至数据库中。
-
-考虑到相关因素，因此本代码只爬取前10页的新闻内容，即最多100条新闻作为测试。
-
-此方法为协程做法，即使用gevent库通过协程并发爬取网页内容，再使用json提取新闻内容。
-
-注意：本代码中的关键词列表默认为['灾害']，日期范围默认为2018年1月1日至2018年12月31日。
-
-Args:
-    keywords: 用于搜索新闻的关键词列表
-    begin_date: 开始日期，用于搜索
-    end_date: 结束日期，用于搜索
-    size: 一次请求返回的新闻或政策的最大数量
-
-Examples:
-    ```
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
-    ```
-"""
-
-import gevent
-from gevent import monkey
-
-# 打补丁，使标准库能够与gevent协同工作
-monkey.patch_all()
-
+import asyncio
 import util
-import logging
-from typing import List
-
-import tqdm
-
-
-@util.timeit
-def main(keywords: List[str], begin_date: str, end_date: str, size: int = 10):
-    """
-    爬取与提供的关键词列表相关的新闻.
-
-    Args:
-        keywords: 用于搜索新闻的关键词列表
-        begin_date: 开始日期，用于搜索
-        end_date: 结束日期，用于搜索
-        size: 一次请求返回的新闻或政策的最大数量
-    """
-    logging.basicConfig(level=logging.INFO,
-                        format="%(asctime)s - %(levelname)s - %(message)s",
-                        datefmt="%Y-%m-%d %H:%M:%S",
-                        filename='log.txt',
-                        encoding='utf-8')
-
-    logging.info("开始运行协程爬取")
 
-    spider = util.Spider(keywords=keywords,
-                         begin_date=begin_date,
-                         end_date=end_date,
-                         size=size)
 
-    pbar = tqdm.tqdm(total=size * 10, desc='协程爬取进度', unit='条', ncols=80)
-    title_list = []
+@util.measure_performance_async
+async def async_compute_task():
+    await asyncio.gather(*[util.async_compute_task() for _ in range(5)])
 
-    def fetch_and_parse(keyword, current):
-        logging.info(f'keyword: {keyword}, current: {current}')
-        config = spider.get_config(keyword, current)
-        data = spider.fetch(config)
-        titles = spider.parse(data)
-        title_list.extend(titles)
-        pbar.update(size)
 
-    jobs = [
-        gevent.spawn(fetch_and_parse, keyword, current) for keyword in keywords
-        for current in range(1, 11)
-    ]
+@util.measure_performance_async
+async def async_io_task():
+    await asyncio.gather(*[util.fetch_url_async(url) for url in util.urls])
 
-    gevent.joinall(jobs)
 
-    spider.save(title_list)
-    pbar.close()
-    logging.info("爬取完成")
+def main():
+    asyncio.run(async_compute_task())
+    asyncio.run(async_io_task())
 
 
 if __name__ == "__main__":
-    main(keywords=['灾害'],
-         begin_date='2018-01-01',
-         end_date='2018-12-31',
-         size=10)
+    main()

B 高性能模式/040 异步.py

@@ -1,85 +1,34 @@
-"""
-根据提供的关键词列表，爬取天水市人民政府网站上指定日期内与关键词相关的新闻的标题，并将其存储至数据库中。
-
-考虑到相关因素，因此本代码只爬取前10页的新闻内容，即最多100条新闻作为测试。
-
-此方法为多线程做法，即使用异步并行爬取网页内容，再使用json提取新闻内容。
-
-注意：本代码中的关键词列表默认为['灾害']，日期范围默认为2018年1月1日至2018年12月31日。
-
-Args:
-    keywords: 用于搜索新闻的关键词列表
-    begin_date: 开始日期，用于搜索
-    end_date: 结束日期，用于搜索
-    size: 一次请求返回的新闻或政策的最大数量
-
-Examples:
-    ```
-    asyncio.run(
-        main_async(keywords=['灾害'],
-                   begin_date='2018-01-01',
-                   end_date='2018-12-31',
-                   size=10))
-    ```
-"""
-
 import asyncio
+from multiprocessing import Process
+from concurrent.futures import ProcessPoolExecutor
 import util
-import logging
-from typing import List
-import tqdm
-
 
-@util.timeit_async
-async def main_async(keywords: List[str],
-                     begin_date: str,
-                     end_date: str,
-                     size: int = 10):
-    """
-    使用异步方式爬取与提供的关键词列表相关的新闻.
 
-    Args:
-        keywords: 用于搜索新闻的关键词列表
-        begin_date: 开始日期，用于搜索
-        end_date: 结束日期，用于搜索
-        size: 一次请求返回的新闻或政策的最大数量
-    """
-    logging.basicConfig(level=logging.INFO,
-                        format="%(asctime)s - %(levelname)s - %(message)s",
-                        datefmt="%Y-%m-%d %H:%M:%S",
-                        filename='log.txt',
-                        encoding='utf-8')
+@util.measure_performance
+def async_compute_task():
+    with ProcessPoolExecutor() as pool:
+        futures = [pool.submit(util.compute_task) for _ in range(5)]
+        for future in futures:
+            future.result()
 
-    logging.info("开始运行异步爬取")
 
-    spider = util.Spider(keywords=keywords,
-                         begin_date=begin_date,
-                         end_date=end_date,
-                         size=size)
+@util.measure_performance_async
+async def async_io_task():
+    chunk_size = len(util.urls) // 5
+    chunks = [
+        util.urls[i:i + chunk_size]
+        for i in range(0, len(util.urls), chunk_size)
+    ]
 
-    pbar = tqdm.tqdm(total=size * 10, desc='异步爬取进度', unit='条', ncols=80)
-    title_list = []
-    tasks = []
-    for keyword in keywords:
-        for current in range(1, 11):
-            logging.info(f'keyword: {keyword}, current: {current}')
-            config = spider.get_config(keyword, current)
-            task = asyncio.create_task(spider.fetch_async(config))
-            tasks.append(task)
+    for chunk in chunks:
+        tasks = [util.fetch_url_async(url) for url in chunk]
+        await asyncio.gather(*tasks)
 
-    for task in asyncio.as_completed(tasks):
-        data = await task
-        title_list += spider.parse(data)
-        pbar.update(size)
 
-    spider.save(title_list)
-    pbar.close()
-    logging.info("爬取完成")
+def main():
+    # async_compute_task()
+    asyncio.run(async_io_task())
 
 
 if __name__ == "__main__":
-    asyncio.run(
-        main_async(keywords=['灾害'],
-                   begin_date='2018-01-01',
-                   end_date='2018-12-31',
-                   size=10))
+    main()

B 高性能模式/os 机制.md

@@ -0,0 +1,17 @@
+
+段：存放的是全局变量和静态变量
+栈：系统自动分配释放，函数参数值，局部变量，返回地址等在此
+堆：存放动态分配的数据，由开发人员自行管理
+
+进程表会记录进程在内存的位置，PID 是多少，以及当前什么状态，内存给它分配了多大使用空间以及属于哪个用户
+
+每个用户态线程通过系统调用创建一个绑定的内核线程，Windows NT 即采用这种模型 ；
+n 个用户态线程对应 m 个内核态线程。m 通常设置为核数，Linux 即采用的这种模型 
+
+在 Linux 中，操作系统采用虚拟内存管理技术，使得进程都拥有独立的虚拟内存空间，理由也比较直接，物理内存不够用且不安全(用户不能直接访问物理内存)。Linux 内核看来只有进程而没有线程。Linux所谓的线程其实是与其他进程共享资源的轻量级进程。为什么说是轻量级呢？在于它只有一个执行上下文和调度程序所需的信息，与父进程共享进程地址空间 。 
+
+虚拟内存技术，把进程虚拟地址空间划分成用户空间和内核空间。
+在 32 位的操作系统中，4GB 的进程地址空间分为，用户空间和内核空间，用户空间为 0～3G，内核地址空间占据 3～4G，
+用户不能直接操作内核空间虚拟地址，只有通过系统调用的方式访问内核空间。
+
+线程共享虚拟内存和全局变量等资源，线程拥有自己的私有数据比如栈和寄存器。

B 高性能模式/readme.md

@@ -1,25 +1,269 @@
 
 
 # 目标
-本节使用一个爬虫任务来展示如何追求代码的性能 。
+本节使用一个爬虫任务和计算任务来展示如何追求代码的性能 。
 充分理解线程、协程、进程、同步、异步、阻塞、非阻塞等概念，并能够根据具体场景选择合适的并发模型。
 主线问题：如何解决IO和计算速度不匹配、如何任务分解、分发和协作 。
 
 # 任务
+## 1、CPU密集型/计算密集型：
+  将```sum(i * i for i in range(10**8))```作为一个子任务，运行5次，分别使用单线程、多线程、多进程、多协程、异步等方式，并对比运行时间、内存使用、CPU使用等指标。
 
+## 2、IO密集型：
 
 # 讨论分析
-普通做法连续进行了五次测试，时间分别为34.231s、34.091s、34.164s、34.226s、33.958s，平均时间为34.134s
-多进程（进程数=5）连续进行了五次测试，时间分别为7.719s、7.716s、7.690s、7.730s、7.711s，平均时间为7.7132s
-多线程（线程数=5）连续进行了五次测试，时间分别为7.185s、7.964s、6.983s、6.969s、7.035s，平均时间为7.2272s
-协程连续进行了五次测试，时间分别为3.775s、3.807s、3.733s、3.824s、3.744s，平均时间为3.776s
-异步连续进行了五次测试，时间分别为6.975s、7.675s、7.018s、7.032s、7.049s，平均时间为7.1498s
-注：为保证公平性，每一次Post请求后休眠3秒
-
-可以看出，协程的性能最好，普通做法的性能最差，多线程、多进程和异步的性能介于两者之间。
-考虑到多进程和多线程是故意开的5个进程和线程，而协程是单线程，所以协程的性能最好。
-另外，异步的性能最差，可能是由于异步的并发模型需要频繁地切换线程，导致性能下降。
-总的来说，协程的性能最好，多线程和多进程的性能介于两者之间，普通做法的性能最差。
+## 1、CPU密集型/计算密集型：
+  为控制变量，代码在同一台设备上运行，且关闭其他进程，保证CPU资源不被其他进程占用。测试结果如下：
+
+### 普通做法：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：53.3%
+
+#### 运行后：
+  CPU使用率：0.6%，内存使用率：53.0%，内存使用：0.003336MB，峰值内存使用：0.004216MB，单个子任务运行平均时间：7.86s，总运行时间：39.31s
+
+#### 运行结束30秒后：
+  CPU使用率：0.6%，内存使用率：53.0%
+
+### 多进程：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：52.8%
+
+#### 运行后：
+  CPU使用率：1.3%，内存使用率：52.9%，内存使用：0.096089MB，峰值内存使用：0.121865MB，单个子任务运行平均时间：0.654s，总运行时间：1.86s
+
+#### 运行结束30秒后：
+  CPU使用率：0.6%，内存使用率：52.7%
+
+### 多线程：
+#### 运行前：
+  CPU使用率：3.8%，内存使用率：53.1%
+
+#### 运行后：
+  CPU使用率：3.6%，内存使用率：53.1%，内存使用：0.001472MB，峰值内存使用：0.019296MB，单个子任务运行平均时间：38.89s，总运行时间：39.77s
+
+#### 运行结束30秒后：
+  CPU使用率：0.7%，内存使用率：52.9%
+
+### 多线程 + 线程池：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：52.9%
+
+#### 运行后：
+  CPU使用率：0.7%，内存使用率：53.1%，内存使用：0.000952MB，峰值内存使用：0.036604MB，单个子任务运行平均时间：40.49s，总运行时间：41.16s
+
+#### 运行结束30秒后：
+  CPU使用率：0.6%，内存使用率：52.9%
+
+### 多协程：
+#### 运行前：
+  CPU使用率：1.1%，内存使用率：53.4%
+
+#### 运行后：
+  CPU使用率：0.2%，内存使用率：53.4%，内存使用：0.009448MB，峰值内存使用：0.011027MB，单个子任务运行平均时间：9.14s，总运行时间：45.70s
+
+#### 运行结束30秒后：
+  CPU使用率：0.6%，内存使用率：53.4%
+
+
+### 多进程 + 异步：
+#### 运行前：
+  CPU使用率：0.8%，内存使用率：54.9%
+
+#### 运行后：
+  CPU使用率：0.6%，内存使用率：54.9%，内存使用：0.123481MB，峰值内存使用：0.188774MB，单个子任务运行平均时间：0.63s，总运行时间：1.85s
+
+#### 运行结束30秒后：
+  CPU使用率：0.9%，内存使用率：55.0%
+
+
+## 2、IO密集型：
+  为控制变量，代码在同一台设备上运行，关闭其他进程，并在相同的网络环境下运行，保证网络资源不被其他进程占用。
+
+### 普通做法：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：52.5%
+
+#### 运行后：
+  CPU使用率：0.9%，内存使用率：52.6%，内存使用：0.074968MB，峰值内存使用：4.162339MB，总运行时间：5.56s
+
+#### 运行结束30秒后：
+  CPU使用率：0.6%，内存使用率：52.5%
+
+
+### 多进程：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：52.7%
+
+#### 运行后：
+  CPU使用率：5.0%，内存使用率：52.8%，内存使用：0.03219MB，峰值内存使用：0.085236MB，总运行时间：5.81s
+
+#### 运行结束30秒后：
+  CPU使用率：1.2%，内存使用率：53.1%
+
+
+### 多线程：
+#### 运行前：
+  CPU使用率：0.0%，内存使用率：52.9%
+
+#### 运行后：
+  CPU使用率：0.1%，内存使用率：53.0%，内存使用：MB，峰值内存使用：MB，总运行时间：1.63s
+
+#### 运行结束30秒后：
+  CPU使用率：0.5%，内存使用率：52.9%
+
+
+### 多线程 + 线程池：
+#### 运行前：
+  CPU使用率：1.3%，内存使用率：53.2%
+
+#### 运行后：
+  CPU使用率：1.3%，内存使用率：53.1%，内存使用：0.092493MB，峰值内存使用：4.371028MB，总运行时间：1.47s
+
+#### 运行结束30秒后：
+  CPU使用率：0.8%，内存使用率：53.2%
+
+
+### 多协程：
+#### 运行前：
+  CPU使用率：1.1%，内存使用率：54.4%
+
+#### 运行后：
+  CPU使用率：0.8%，内存使用率：54.4%，内存使用：0.753684MB，峰值内存使用：15.09151MB，总运行时间：1.45s
+
+#### 运行结束30秒后：
+  CPU使用率：0.8%，内存使用率：54.4%
+
+
+### 多进程 + 异步：
+#### 运行前：
+  CPU使用率：1.5%，内存使用率：60.0%
+
+#### 运行后：
+  CPU使用率：0.8%，内存使用率：59.8%，内存使用：0.569592MB，峰值内存使用：6.360097MB，总运行时间：7.40s
+
+#### 运行结束30秒后：
+  CPU使用率：1.3%，内存使用率：59.6%
 
 # 总结
-协程的性能最好，多线程和多进程的性能介于两者之间，普通做法的性能最差。
+## 1、CPU密集型/计算密集型：
+|                          |  普通做法  |   多进程   |   多线程   | 多线程+线程池 |   多协程   | 多进程+异步 |
+| :----------------------: | :--------: | :--------: | :--------: | :-----------: | :--------: | :---------: |
+|     运行前CPU使用率      |    0.0%    |    0.0%    |    3.8%    |     0.0%      |    1.1%    |    0.8%     |
+|     运行后CPU使用率      |    0.6%    |    1.3%    |    3.6%    |     0.7%      |    0.2%    |    0.6%     |
+| 运行结束30秒后CPU使用率  |    0.6%    |    0.6%    |    0.7%    |     0.6%      |    0.6%    |    0.9%     |
+|     运行前内存使用率     |   53.3%    |   52.8%    |   53.1%    |     52.9%     |   53.4%    |    54.9%    |
+|     运行后内存使用率     |   53.0%    |   52.9%    |   53.1%    |     53.1%     |   53.4%    |    54.9%    |
+| 运行结束30秒后内存使用率 |   53.0%    |   52.7%    |   52.9%    |     52.9%     |   53.4%    |    55.0%    |
+|         内存使用         | 0.003336MB | 0.096089MB | 0.001472MB |  0.000952MB   | 0.009448MB | 0.123481MB  |
+|       峰值内存使用       | 0.004216MB | 0.121865MB | 0.019296MB |  0.036604MB   | 0.011027MB | 0.188774MB  |
+|  单个子任务运行平均时间  |   7.86s    |   0.654s   |   38.89s   |    40.49s     |   9.14s    |    0.63s    |
+|        总运行时间        |   39.31s   |   1.86s    |   39.77s   |    41.16s     |   45.70s   |    1.85s    |
+
+  根据表格中的数据，我们可以对不同的并发和并行编程方法进行详细的总结：
+
+### 普通做法
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明普通做法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大，表明普通做法对内存的影响较小。
+- **内存使用**：内存使用量和峰值内存使用量都很低。
+- **运行时间**：单个子任务和总任务的运行时间都较长，表明普通做法效率较低。
+
+### 多进程
+- **CPU使用率**：在任务运行后CPU使用率显著增加，表明多进程方法能够充分利用多核CPU的优势。
+- **内存使用率**：内存使用率略有增加，但变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较高，表明多进程方法对内存的需求较大。
+- **运行时间**：单个子任务和总任务的运行时间都显著减少，表明多进程方法在处理CPU密集型任务时效率最高。
+
+### 多线程
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明多线程方法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：单个子任务和总任务的运行时间都较长，表明多线程方法在处理CPU密集型任务时效率较低。
+
+### 多线程+线程池
+- **CPU使用率**：在任务运行后CPU使用率略有增加，但变化不大。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：单个子任务和总任务的运行时间都较长，表明多线程+线程池方法在处理CPU密集型任务时效率较低。
+
+### 多协程
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明多协程方法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：单个子任务和总任务的运行时间都较长，表明多协程方法在处理CPU密集型任务时效率较低。
+
+### 多进程+异步
+- **CPU使用率**：在任务运行后CPU使用率显著增加，表明多进程+异步方法能够充分利用多核CPU的优势。
+- **内存使用率**：内存使用率略有增加，但变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较高，表明多进程+异步方法对内存的需求较大。
+- **运行时间**：单个子任务和总任务的运行时间都显著减少，表明多进程+异步方法在处理CPU密集型任务时效率最高。
+
+### 结论
+- **多进程**和**多进程+异步**方法在处理CPU密集型任务时效率最高，能够充分利用多核CPU的优势，但对内存的需求较大。
+- **多线程**和**多线程+线程池**方法在处理CPU密集型任务时效率较低，主要是由于Python的全局解释器锁（GIL）的存在，无法实现真正的并行。
+- **多协程**方法在处理CPU密集型任务时效率较低，但在处理I/O密集型任务时可能会有更好的表现。
+- **普通做法**效率最低，无法充分利用系统资源。
+
+## 2、IO密集型：
+|                          |  普通做法  |   多进程   | 多线程 | 多线程+线程池 |   多协程   | 多进程+异步 |
+| :----------------------: | :--------: | :--------: | :----: | :-----------: | :--------: | :---------: |
+|     运行前CPU使用率      |    0.0%    |    0.0%    |  0.0%  |     1.3%      |    1.1%    |    1.5%     |
+|     运行后CPU使用率      |    0.9%    |    5.0%    |  0.1%  |     1.3%      |    0.8%    |    0.8%     |
+| 运行结束30秒后CPU使用率  |    0.6%    |    1.2%    |  0.5%  |     0.8%      |    0.8%    |    1.3%     |
+|     运行前内存使用率     |   52.5%    |   52.7%    | 52.9%  |     53.2%     |   54.4%    |    60.0%    |
+|     运行后内存使用率     |   52.6%    |   52.8%    | 53.0%  |     53.1%     |   54.4%    |    59.8%    |
+| 运行结束30秒后内存使用率 |   52.5%    |   53.1%    | 52.9%  |     53.2%     |   54.4%    |    59.6%    |
+|         内存使用         | 0.074968MB | 0.03219MB  |  N/A   |  0.092493MB   | 0.753684MB | 0.569592MB  |
+|       峰值内存使用       | 4.162339MB | 0.085236MB |  N/A   |  4.371028MB   | 15.09151MB | 6.360097MB  |
+|        总运行时间        |   5.56s    |   5.81s    | 1.63s  |     1.47s     |   1.45s    |    7.40s    |
+
+  根据表格中的数据，我们可以对不同的并发和并行编程方法进行详细的总结：
+
+### 普通做法
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明普通做法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大，表明普通做法对内存的影响较小。
+- **内存使用**：内存使用量和峰值内存使用量都很低。
+- **运行时间**：总运行时间为5.56秒，表明普通做法效率较低。
+
+### 多进程
+- **CPU使用率**：在任务运行后CPU使用率显著增加，表明多进程方法能够充分利用多核CPU的优势。
+- **内存使用率**：内存使用率略有增加，但变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：总运行时间为5.81秒，略高于普通做法，表明多进程方法在处理IO密集型任务时效率较高。
+
+### 多线程
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明多线程方法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：总运行时间为1.63秒，显著低于普通做法，表明多线程方法在处理IO密集型任务时效率较高。
+
+### 多线程+线程池
+- **CPU使用率**：在任务运行后CPU使用率略有增加，但变化不大。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较低。
+- **运行时间**：总运行时间为1.47秒，显著低于普通做法，表明多线程+线程池方法在处理IO密集型任务时效率较高。
+
+### 多协程
+- **CPU使用率**：在任务运行前、运行后和运行结束30秒后的CPU使用率都较低，表明多协程方法没有充分利用CPU资源。
+- **内存使用率**：内存使用率变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较高。
+- **运行时间**：总运行时间为1.45秒，显著低于普通做法，表明多协程方法在处理IO密集型任务时效率较高。
+
+### 多进程+异步
+- **CPU使用率**：在任务运行后CPU使用率显著增加，表明多进程+异步方法能够充分利用多核CPU的优势。
+- **内存使用率**：内存使用率略有增加，但变化不大。
+- **内存使用**：内存使用量和峰值内存使用量较高。
+- **运行时间**：总运行时间为7.40秒，略高于普通做法，表明多进程+异步方法在处理IO密集型任务时效率较低。
+
+### 结论
+- **多线程**、**多线程+线程池**和**多协程**方法在处理IO密集型任务时效率最高，能够显著减少总运行时间。
+- **多进程**方法在处理IO密集型任务时效率较高，但略低于多线程和多协程方法。
+- **多进程+异步**方法在处理IO密集型任务时效率较低，总运行时间较长。
+- **普通做法**效率最低，无法充分利用系统资源。
+
+<style>
+    h1{font:20pt "SimHei", sans-serif;}
+    h2{font:16pt "SimHei", sans-serif;}
+    p{font:12pt "SimSun", sans-serif;line-height:150%}
+    li{font:12pt "SimSun", sans-serif;line-height:150%}
+</style>

B 高性能模式/util.py

@@ -1,188 +1,107 @@
-"""
-
-"""
-import re
 import time
-import functools
-import json
-import asyncio
+import psutil
+import tracemalloc
 import requests
-from typing import Any, Dict, List
-
-
-class Spider:
-    """
-    爬虫类。
-
-    Args:
-        keywords (List[str]): 用于搜索新闻的关键词列表
-        begin_date (str): 开始日期，用于搜索
-        end_date (str): 结束日期，用于搜索
-        size (int): 一次请求返回的新闻或政策的最大数量
-
-    Attributes:
-        URL (str): 网址
-    """
-    # 天水市人民政府网站
-    URL = ('https://www.tianshui.gov.cn/aop_component/'
-           '/webber/search/search/search/queryPage')
-
-    def __init__(self, keywords: List[str], begin_date: str, end_date: str,
-                 size: int):
-        self.keywords = keywords
-        self.begin_date = begin_date
-        self.end_date = end_date
-        self.size = size
-
-    def get_config(self, keyword: str, current: int) -> Dict[str, Any]:
-        """
-        获取配置信息。
-
-        Args:
-            keyword (str): 关键词
-            size (int): 一次请求返回的新闻的最大数量
-
-        Returns:
-            Dict[str, Any]: 配置信息
-        """
-
-        return {
-            "aliasName": "article_data,open_data,mailbox_data,article_file",
-            "keyWord": keyword,
-            "lastkeyWord": keyword,
-            "searchKeyWord": False,
-            "orderType": "score",
-            "searchType": "text",
-            "searchScope": "3",
-            "searchOperator": 0,
-            "searchDateType": "custom",
-            "searchDateName": f"{self.begin_date}-{self.end_date}",
-            "beginDate": self.begin_date,
-            "endDate": self.end_date,
-            "showId": "c2ee13065aae85d7a998b8a3cd645961",
-            "auditing": ["1"],
-            "owner": "1912126876",
-            "token": "tourist",
-            "urlPrefix": "/aop_component/",
-            "page": {
-                "current": current,
-                "size": self.size,
-                "pageSizes": [2, 5, 10, 20, 50, 100],
-                "total": 0,
-                "totalPage": 0,
-                "indexs": []
-            },
-            "advance": False,
-            "advanceKeyWord": "",
-            "lang": "i18n_zh_CN"
-        }
-
-    def generate_headers(self) -> dict:
-        """
-        生成请求头。
-
-        Returns:
-            dict: 请求头
-        """
-        return {
-            'Authorization':
-            'tourist',
-            'User-Agent':
-            ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit'
-             '/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari'
-             '/537.36 Edg/124.0.0.0')
-        }
-
-    def fetch(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        普通做法。
-        Post请求获取网页内容，并返回请求结果。
-
-        Args:
-            config (Dict[str, Any]): 配置信息
-
-        Returns:
-            Dict[str, Any]: 请求结果
-        """
-        response = requests.post(self.URL,
-                                 headers=self.generate_headers(),
-                                 json=config).text
-        time.sleep(3)
-        return json.loads(response)
-
-    async def fetch_async(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        异步做法。
-        Post请求获取网页内容，并返回请求结果。
-
-        Args:
-            config (Dict[str, Any]): 配置信息
-
-        Returns:
-            Dict[str, Any]: 请求结果
-        """
-        response = requests.post(self.URL,
-                                 headers=self.generate_headers(),
-                                 json=config).text
-        await asyncio.sleep(3)
-        return json.loads(response)
-
-    def parse(self, data: Dict[str, Any]) -> List[str]:
-        """
-        解析网页内容。
-
-        Args:
-            data (Dict[str, Any]): 网页内容
-
-        Returns:
-            List[str]: 标题列表
-        """
-        title_list = []
-        records = data['data']['page']['records']
-        for i in range(self.size):
-            title = records[i]['title']
-            title = re.sub('<[^>]*>', '', title)  # 去除html标签
-            title_list.append(title)
-            # print(title)
-        return title_list
-
-    def save(self, title_list: List[str]):
-        """
-        保存数据。
-        """
-        pass
-
-
-# 时间装饰器
-def timeit(func):
-    """
-    计算函数运行时间。
-
-    Args:
-        func: 函数
-
-    Return:
-        函数
-    """
+import aiohttp
+
+
+def compute_task():
+    start_time = time.time()
+    result = sum(i * i for i in range(10**7))
+    end_time = time.time()
+    print(f"compute_task耗时：{end_time - start_time}秒")
+
+
+async def async_compute_task():
+    start_time = time.time()
+    result = sum(i * i for i in range(10**7))
+    end_time = time.time()
+    print(f"async_compute_task耗时：{end_time - start_time}秒")
 
-    def wrapper(*args, **kwargs):
-        start = time.time()
-        result = func(*args, **kwargs)
 
-        print(f'{func.__name__} cost: {time.time() - start}')
-        return result
+def measure_performance(func):
+
+    def wrapper(*args, **kwargs):
+        print(f"开始运行{func.__name__}")
+
+        time.sleep(30)
+        print(f"运行前的CPU使用率：{psutil.cpu_percent()}%")
+        print(f"运行前的内存使用率：{psutil.virtual_memory().percent}%")
+        print()
+
+        tracemalloc.start()
+        start_time = time.time()
+        func(*args, **kwargs)
+        end_time = time.time()
+        current, peak = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+        print(f"{func.__name__}耗时：{end_time - start_time}秒")
+        print(f"当前内存使用：{current / 10**6}MB, 峰值内存使用：{peak / 10**6}MB")
+        print(f"CPU使用率：{psutil.cpu_percent(interval=1)}%")
+        print(f"内存使用率：{psutil.virtual_memory().percent}%")
+        print()
+
+        time.sleep(30)
+        print(f"运行结束30秒后的CPU使用率：{psutil.cpu_percent()}%")
+        print(f"运行结束30秒后的内存使用率：{psutil.virtual_memory().percent}%")
+        print(f"运行结束{func.__name__}结束")
+        print()
 
     return wrapper
 
 
-def timeit_async(func):
+def measure_performance_async(func):
 
-    @functools.wraps(func)
     async def wrapper(*args, **kwargs):
-        start = time.time()
-        result = await func(*args, **kwargs)
-
-        print(f'{func.__name__} cost: {time.time() - start}')
-        return result
+        print(f"开始运行{func.__name__}")
+
+        time.sleep(30)
+        print(f"运行前的CPU使用率：{psutil.cpu_percent()}%")
+        print(f"运行前的内存使用率：{psutil.virtual_memory().percent}%")
+        print()
+
+        tracemalloc.start()
+        start_time = time.time()
+        await func(*args, **kwargs)
+        end_time = time.time()
+        current, peak = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+        print(f"{func.__name__}耗时：{end_time - start_time}秒")
+        print(f"当前内存使用：{current / 10**6}MB, 峰值内存使用：{peak / 10**6}MB")
+        print(f"CPU使用率：{psutil.cpu_percent(interval=1)}%")
+        print(f"内存使用率：{psutil.virtual_memory().percent}%")
+        print()
+
+        time.sleep(30)
+        print(f"运行结束30秒后的CPU使用率：{psutil.cpu_percent()}%")
+        print(f"运行结束30秒后的内存使用率：{psutil.virtual_memory().percent}%")
 
     return wrapper
+
+
+def fetch_url(url):
+    response = requests.get(url)
+
+
+async def fetch_url_async(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, ssl=False) as response:
+            await response.read()
+
+
+urls = [
+    "https://www.baidu.com", "https://www.qq.com", "https://www.taobao.com",
+    "https://www.tmall.com", "https://www.jd.com", "https://www.sina.com.cn",
+    "https://www.weibo.com", "https://www.163.com", "https://www.sohu.com",
+    "https://www.ifeng.com", "https://www.alipay.com", "https://www.youku.com",
+    "https://www.iqiyi.com", "https://www.tudou.com", "https://www.douyin.com",
+    "https://www.meituan.com", "https://www.xiaomi.com",
+    "https://www.oppo.com", "https://www.vivo.com", "https://www.dianping.com",
+    "https://www.autohome.com.cn", "https://www.hupu.com",
+    "https://www.xinhuanet.com", "https://www.chinadaily.com.cn",
+    "https://www.people.com.cn", "https://www.cctv.com", "https://www.cntv.cn",
+    "https://www.zol.com.cn", "https://www.pconline.com.cn",
+    "https://www.techweb.com.cn", "https://www.cs.com.cn",
+    "https://www.eastmoney.com", "https://www.hexun.com",
+    "https://www.yicai.com", "https://www.21jingji.com"
+]

B 高性能模式/概念.md

@@ -0,0 +1,54 @@
+
+## 进程、线程、协程
+
+运行一个软件就是开了一个进程 
+
+一个游戏，启动后为一个进程
+但一个游戏需要图形渲染，联网
+操作能同时运行
+所以将其各个部分设计为线程
+即一个进程有多个线程
+
+从操作系统层面而言
+进程是分配资源的基本单位
+进程之间是独立的
+一个进程无法访问另一个进程的空间
+一个进程运行的失败也不会影响其他进程的运行
+
+一个进程内可以包含多个线程
+线程是程序执行的基本单位，是进程中的实际运作单位
+线程是操作系统分配处理器时间的基本单元
+线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉
+协程运行在线程之上
+协程的调度完全由用户控制，协程拥有自己的寄存器上下文和栈
+
+
+## 并发/并行
+【顺序】 你做作业，然后看综艺，
+【并发】 你写程序到一半，综艺开始，看完综艺后继续写程序。两件事情都处于启动状态
+？并发把CPU运行划分成若干个时间段，在一个时间段线程代码运行时，其他线程挂起状态
+【并行】 你写程序到一半，综艺开始，你一边做作业一边写程序。两件事情同时做
+
+
+## 阻塞/非阻塞
+等候消息的过程中有没有干其他事
+“阻塞”是不能
+
+## 同步异步
+指的是消息通知的机制
+主动听消息则为同步(一直等,轮流取)、被动听消息则为异步
+异步过程调用发出后，可以继续执行其它操作
+通知调用者的三种方式，如下
+状态：即监听被调用者的状态（轮询），调用者没隔一段时间检查一次，效率会很低。
+通知：当被调用者执行完成后，发出通知告知调用者，无需消耗太多性能。
+回调：与通知类似，当被调用者执行完成后，会调用调用者提供的回调函数。
+
+老张要做两件事：烧水，看电视
+同步阻塞：老张烧水，等水开，然后看电视
+同步非阻塞：老张烧水，去客厅看电视，时不时去看看水开了没有(检查状态)
+老张买了把水开之后会提示音的水壶。
+异步阻塞：老张烧水，然后坐在旁边等着听那个烧开的提示音。（异步阻塞）
+异步非阻塞：老张烧水，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）
+实现异步可以采用多线程技术或则交给另外的进程来处理
+
+如果老张委派小张去烧水，自己看电视，那就是并行

B 高性能模式/进程、线程、协程.md

@@ -0,0 +1,54 @@
+
+Python中多进程、多线程、协程区别和应用场景
+
+多任务简单地说，就是操作系统可以同时运行多个任务。分为并行和并发两种。
+并行：指的是任务数小于等于CPU核数，即任务真的是一起执行的
+并发：指的是实际上一个时间只有一个任务在执行，那效率是怎么提升的？常常程序运行的时候，需要等待IO操作，比如访问数据库，等待网络服务器回传数据 。这个时候并发切换到其它任务就能节省时间了。
+
+进程是资源分配的单位
+线程是操作系统调度的单位
+进程切换需要的资源大
+线程切换需要的资源小
+协程切换任务资源很小，协程是在一个线程中所以是并发
+
+IO密集型指的是系统的CPU性能相对硬盘、内存要好很多，此时，系统运作，大部分的状况是CPU在等I/O (硬盘/内存) 的读/写操作，此时CPU Loading并不高。这可能是因为任务本身不太需要访问I/O设备。
+并行做i/o操作，多线程好些。简单的异步操作，用协程
+
+进程：进程是并行。没有运行的代码叫程序,运行的程序或代码就是一个进程。进程是系统进行资源分配的最小单位，进程拥有自己的内存空间，所以进程间数据不共享。多进程适合计算密集型任务
+通常我们所说的电脑配置几核就是最大可以创建的进程，注意因为电脑会切换进程，所以看起来电脑会同时运行的进程数会超过核数
+数据无法内存共享。各个进程之间无影响，更稳定和安全，不因个别崩溃而整个系统崩溃。
+
+当需要创建的子进程数量巨大时，就可以用到multiprocessing模块提供的Pool方法
+进程是通过Queue实现多进程之间的数据传递，Queue本身是一个消息队列程序。
+
+线程：线程是并发。 一个进程至少有一个线程，叫主线程，多个线程共享内存（数据和全局变量共享）。
+多线程适合 IO 密集型操作 。
+缺点就是，如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确
+当多个线程几乎同时修改某个共享数据的时候，需要进行同步控制。
+某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
+
+如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
+可以添加超时时间等，解决死锁
+
+协程：用户态的轻量级线程，调度有用户控制。
+协程是一种 允许在特定位置暂停或恢复的子程序。
+和生成器 不同的是，协程 可以控制子程序暂停之后代码的走向，而 生成器 仅能被动地将控制权交还给调用者。
+协程看上去像是线程，但是实际使用非线程的方式。
+协程 可以只利用一个线程更加轻便地实现 多任务，将任务切换的开销降至最低。
+和 回调 等其他异步技术相比，
+协程 维持了正常的代码流程，在保证代码可读性的同时最大化地利用了 阻塞 IO 的空闲时间。它的高效与简洁赢得了开发者们的拥戴。
+
+协程实现方式分为
+以gevent，第二种语法上以async和await关键字实现的协程，可读性更好一些。（asyncio）
+具体的说，协程是函数体中包含yield或者yield from 的函数。一个协程可以通常处于四种状态之一('GEN_CREATED',,'GEN_RUNNING','GEN_SUSPENDED','GEN_CLOSED').
+
+协程和线程都区别就是，线程调度看系统，协程你可以自己控制。yield 就可以实现了
+
+很多时候系统瓶颈都在 IO，很多涉及到 IO 特别是网络的程序都需要用到线程 /协程。
+本来线程就复杂，还实现不完整，能用协程就协程
+大部分用于 generator 这个特定场景
+我自己的话有一个场景，每个登录用户定时拉取外部信息的需求，如果每个用户开一个线程开销太大，所以就用协程还是很方便的
+
+模块
+thread模块 是比较底层的模块
+threading模块对thread做了一些包装