Add lock

dns_resolver.py

@@ -3,91 +3,97 @@ import urllib.request
 import json
 import time
 import logging
+import threading  # 导入线程库
 
 class DnsManager:
     _instance = None
+    _lock = threading.Lock()  # 类级别的锁，用于保护单例创建
 
     def __new__(cls, *args, **kwargs):
+        # 双重检查锁定，确保单例创建时的线程安全
         if not cls._instance:
-            # 使用 super() 调用 object 的 __new__ 来创建单例内存
-            cls._instance = super(DnsManager, cls).__new__(cls)
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(DnsManager, cls).__new__(cls)
         return cls._instance
 
     def __init__(self, cache_ttl=600):
         if hasattr(self, '_initialized'):
             return
         self.cache_ttl = cache_ttl
-        self.cache = {}  # 缓存: {"hostname": {"ip": "xxx", "expiry": 0}}
+        self.cache = {}
+        self.instance_lock = threading.Lock()  # 实例锁：保护 cache 字典的读写
         self.logger = logging.getLogger("DnsManager")
         self._initialized = True
 
     def _fetch_ip_from_http(self, hostname):
-        """核心：通过 HTTPS (TCP 443) 绕过系统 UDP DNS 限制获取 IP"""
+        """通过 HTTPS 请求获取 IP (DoH)"""
         try:
-            # 注意：这里直接使用 Google DNS 的 API 地址
             url = f"https://dns.google/resolve?name={hostname}&type=A"
             req = urllib.request.Request(url, headers={"Accept": "application/dns-json"})
             with urllib.request.urlopen(req, timeout=5) as response:
                 data = json.loads(response.read().decode())
                 if "Answer" in data:
                     for answer in data['Answer']:
-                        if answer['type'] == 1: # 只要 A 记录 (IPv4)
+                        if answer['type'] == 1:
                             return answer['data']
         except Exception as e:
             self.logger.warning(f"DoH 解析失败 {hostname}: {e}")
         return None
 
     def get_ip(self, hostname):
-        """获取 IP 逻辑：缓存 -> DoH -> 保底"""
-        # 1. 如果是纯 IP 地址，直接返回
+        """线程安全的 IP 获取逻辑"""
         if hostname.replace('.', '').isdigit():
             return hostname
 
-        current_time = time.time()
-        # 2. 检查缓存
-        if hostname in self.cache:
-            if current_time < self.cache[hostname]['expiry']:
-                return self.cache[hostname]['ip']
+        # 使用锁保护缓存读取和更新过程
+        with self.instance_lock:
+            current_time = time.time()
+            
+            # 1. 检查缓存
+            if hostname in self.cache:
+                if current_time < self.cache[hostname]['expiry']:
+                    return self.cache[hostname]['ip']
 
-        # 3. HTTP 解析
-        new_ip = self._fetch_ip_from_http(hostname)
-        if new_ip:
-            self.cache[hostname] = {
-                "ip": new_ip,
-                "expiry": current_time + self.cache_ttl
-            }
-            print(f"🔄 [DNS库] 动态解析成功: {hostname} -> {new_ip}")
-            return new_ip
-        
-        # 4. 保底 IP (Discord)
-        if hostname in self.cache:
-            return self.cache[hostname]['ip']
-        return "162.159.137.232"
+            # 2. 缓存失效或不存在，进行解析
+            # 注意：在锁内部执行网络请求会阻塞其他线程，但在 0.1vCPU 
+            # 下这能防止多个线程同时发起重复的 DoH 请求，保护算力。
+            new_ip = self._fetch_ip_from_http(hostname)
+            
+            if new_ip:
+                self.cache[hostname] = {
+                    "ip": new_ip,
+                    "expiry": current_time + self.cache_ttl
+                }
+                print(f"🔄 [DNS库] 线程 {threading.current_thread().name} 解析成功: {hostname} -> {new_ip}")
+                return new_ip
+            
+            # 3. 失败保底
+            if hostname in self.cache:
+                return self.cache[hostname]['ip']
+            return "162.159.137.232"
 
     def patch_socket(self):
-        """注入补丁：除了 dns.google，全部强行接管"""
+        """注入全局补丁"""
         original_getaddrinfo = socket.getaddrinfo
 
         def patched_getaddrinfo(*args, **kwargs):
             host = args[0]
             port = args[1]
 
-            # 关键排除逻辑：
-            # 如果请求的是 dns.google 本身，必须走原始解析，否则会陷入死循环（无限递归）
+            # 排除 google 以防死循环
             if host == "dns.google":
                 return original_getaddrinfo(*args, **kwargs)
             
-            # 其他所有请求（Discord, MongoDB 等）全部走补丁
             try:
+                # 这里调用 get_ip，内部已经有 instance_lock 保护
                 latest_ip = self.get_ip(host)
-                # 强制返回 IPv4 结构体给系统
                 return [(socket.AF_INET, socket.SOCK_STREAM, 6, '', (latest_ip, port))]
             except Exception:
-                # 最后的最后，如果补丁崩了，尝试退回原始解析
                 return original_getaddrinfo(*args, **kwargs)
 
         socket.getaddrinfo = patched_getaddrinfo
-        print("💉 [DNS库] 全局覆盖模式已加载：除 dns.google 外，所有域名解析已托管至 DoH")
+        print("💉 [DNS库] 安全补丁已加载（多线程就绪）")
 
-# 导出单例实例
+# 导出实例
 dns_manager = DnsManager()