前置知识：

ref：https://www.osgeo.cn/pillow/reference/ImageFile.html

ref：https://blog.csdn.net/weixin_67510296/article/details/125207042

1.多线程初体验

主线程的id和进程的id是一个

查看进程pid下有多少个线程

ps  -T -p pid

bash 复制代码

(base) D:\code\python_project\python_coroutine>C:/ProgramData/Anaconda3/python.exe d:/code/python_project/python_coroutine/01demo.py
threading.active_count=1
i am producer cnt=1 thread_id1 = 15984 thread_id2 = 15984
threading.active_count=2
i am consumer cnt=0 thread_id1 = 12828 thread_id2 = 12828
threading.active_count=3
i am producer cnt=1 thread_id1 = 15984 thread_id2 = 15984
i am consumer cnt=0 thread_id1 = 12828 thread_id2 = 12828
i am producer cnt=1 thread_id1 = 15984 thread_id2 = 15984

python 复制代码

import threading
import time
cnt = 0
def producer():
    global cnt
    while True:
        cnt += 1
        print("i am producer cnt={} thread_id1 = {} thread_id2 = {}".format(cnt,threading.get_ident(), threading.get_native_id()))
        time.sleep(1) 
    pass
def consumer():
    global cnt
    while True:
        if cnt <= 0:
            continue
        cnt -= 1
        print("i am consumer cnt={} thread_id1 = {} thread_id2 = {}".format(cnt,threading.get_ident(), threading.get_native_id()))
        time.sleep(1)
if __name__ == "__main__":
    print("threading.active_count={}".format(threading.active_count()))
    t1 = threading.Thread(target=producer)
    t2 = threading.Thread(target=consumer)
    t1.start()
    print("threading.active_count={}".format(threading.active_count()))
    t2.start()
    print("threading.active_count={}".format(threading.active_count()))

查看当前程序的活跃线程数量

threading.active_count()

2.单线程下载器

下载模块：从网络上下载图片 I/O密集型

哈希模块：cpu密集

存储模块：I/O密集

单线程的是串行的，先下载，再哈希计算重命名，再存储，都是在主线程完成。

实际上三个功能应该并行起来：主线程负责调度，三个线程分别实现下载，哈希和存储。

2.1 目录结构

modules 下的三个文件是对三个功能的实现，base是定义的抽象方法

const.py 是枚举类。

scheduler.py 是总调度方法

在写 base.py 和其子类的时候，发现子类可以重载父类的方法，也就是参数可以不相同。

另外，base中定义的方法，需要raise 异常，以防 base 类中控制的总实现发现运行中，子类因为拼写错误而没有运行。

2.2 单线程下载器

在实现单线程下载器的时候，顺便完成了整个框架的搭建，可以方便的改成多线程下载器

python 复制代码

import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from const import CaclType
class BaseModule():
    """
    抽象模块
    """
    def __init__(self) -> None:
        self.calc_type = CaclType.SingleThread
    
    def set_calc_type(self, type_):
        self.calc_type = type_
        
    def _process(self):
        raise NotImplementedError
    
    def _process_singlethread(self):
        raise NotImplementedError
    
    def process(self, list_):
        if self.calc_type == CaclType.SingleThread:
            return self._process_singlethread(list_)
        else:
            pass
    ```
    Downloader 下载器实现
    ```python
    import os
import sys

import requests
from PIL import ImageFile
import numpy as np
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from .base import BaseModule

from const import CaclType
class Downloader(BaseModule):
    """下载模块
    """
    def __init__(self) -> None:
        super().__init__()
    
    def _process(self,url):
        print("download url:" + url)
        response = requests.get(url)
        content = response.content
        # 直接从网络上面抓取的数据,没有经过任何解码,所以是一个 bytes类型,其实在硬盘上和在网络上传输的字符串都是 bytes类型,
        parser = ImageFile.Parser()
        parser.feed(content)
        img = parser.close()
        # img.save("./a.jpg")
        # 修改成numpy的格式
        img = np.array(img)
        return img
    
    def _process_singlethread(self,list_):
        response_list = []
        for url in list_:
            img = self._process(url)
            response_list.append(img)
        return response_list
    
    def process(self, list_):
        if self.calc_type == CaclType.SingleThread:
            return self._process_singlethread(list_)
        else:
            pass
    
    
if __name__ == "__main__":
    dl = Downloader()
    list_ = ["https://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2F2023%2F0907%2Fb90e12c7j00s0lqz0000lc000ku00dpm.jpg&thumbnail=660x2147483647&quality=80&type=jpg"]
    aa = dl.process(list_)
    print(aa)

哈希实现：

···python

import os

import sys

from scipy import signal

import requests

from PIL import ImageFile,Image

import numpy as np

import hashlib

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(file ))))

from .base import BaseModule

class Hasher(BaseModule):

"""

哈希模块

"""

def init (self) -> None:

super().init()

def _process(self,item):
    # 卷积
    conv = [[[0.1],[0.05],[0.1]]]
    img = signal.convolve(item,conv)
    img = Image.fromarray(img.astype("uint8")).convert("RGB")
    # 哈希
    md5 = hashlib.md5(str(img).encode("utf-8")).hexdigest()
    return md5

def _process_singlethread(self,list_):
    md5_list = []
    for img in list_:
        md5 = self._process(img)
        md5_list.append(md5)
    return md5_list

···

存储实现

···python

import os

import sys

from scipy import signal

import requests

from PIL import ImageFile,Image

import numpy as np

import hashlib

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(file ))))

from .base import BaseModule

class Storager(BaseModule):

def init (self) -> None:

super().init()

def _process(self,item):
    content,path = item
    print("save path:{}".format(path))
    content = Image.fromarray(content.astype('uint8')).convert("RGB")
    content.save(path)

def _process_singlethread(self,list_):
    # item = (content, path)
    for item in list_:
        self._process(item)

···

总调度实现

python 复制代码

import os
from modules.downloader import Downloader
from modules.hasher import Hasher
from modules.storager import Storager
class Scheduler:
 """调度模块
 """
 def __init__(self) -> None:
     self.downloader = Downloader()
     self.hasher = Hasher()
     self.storager = Storager()
 def _wrap_path(self, md5):
     filename = '{}.jpg'.format(md5)
     STORAGE_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'images')
     path = os.path.join(STORAGE_PATH, filename)
     return path
 def process(self):
     # 1.加载图片url列表
     url_list = ["https://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2F2023%2F0907%2Fb90e12c7j00s0lqz0000lc000ku00dpm.jpg&thumbnail=660x2147483647&quality=80&type=jpg"]
     # 2. 调度下载模块
     content_list = self.downloader.process(url_list)
     # 3. 调度hash模块
     md5_list = self.hasher.process(content_list)
     # 4. 调度存储模块
     item_list = []
     for content, md5 in zip(content_list, md5_list):
         save_path = self._wrap_path(md5)
         item = (content,save_path)
         item_list.append(item) 
     self.storager.process(item_list)


if __name__ == "__main__":
 scheduler = Scheduler()
 scheduler.process()
     
···
枚举实现：
```python
from enum import Enum

class CaclType(Enum):
 SingleThread = 0
 MultiThread = 1
 MultiProcess = 2
 PyCoroutine = 3
 
if __name__ == "__main__":
 print(CaclType.SingleThread.value==0)

10 张图片的耗时：{'network_time': [0.913635], 'cpu_time': [1.68479], 'disk_time': [0.14452]}

-------------------------------------------------------------- 至此，一个单线程的下载器已经完成------

2.3 多线程下载器

{'network_time': [0.920507], 'cpu_time': [1.766117], 'disk_time': [0.146528]}

{'network_time': [0.450087], 'cpu_time': [1.698905], 'disk_time': [0.089213]}

多线程用线程池的方式实现，2个线程，一共url是7-10个，具体忘了

下载：

python 复制代码

    def _process_multithread(self,list_):
        response_list = []
        task_list = []
        for url in list_:
            task = tp.submit(self._process,(url))
            task_list.append(task)
        for task in task_list:
            img = task.result()
            response_list.append(img)
        return response_list

哈希：

python 复制代码

    def _process_multithread(self,list_):
        task_list = []
        md5_list = []
        for img in list_:
            task = tp.submit(self._process,(img))
            task_list.append(task)
        for task in task_list:
            md5 = task.result()
            md5_list.append(md5)
        return md5_list

存储：

python 复制代码

    def _process_multithread(self,list_):
        task_list = []
        for item in list_:
            task = tp.submit(self._process,(item))
            task_list.append(task)
        for task in task_list:
            task.result()
        # 这里仍然需要等待完成的结果，否则计算时间会提前

三者的形式是相同的，都是submit发送task，然后 result等待收结果。

观察可得，下载和存储多线程有效果，而hash多线程没啥效果，甚至会变慢（因为上下文切换的原因），是因为python的多线程是伪多线程，因为GIL的存在，但对i/o操作还是可以加速的。

那么python 为啥不去掉GIL呢，而在操作内存的地方，追加锁，这样会增加和释放很多个锁，有人做过实验，会减慢单线程的操作，使得它的性能下降50%。