Python附件释放详细指南从基础到高级技巧帮助开发者安全处理资源避免内存泄漏提升程序稳定性包括实际代码示例和最佳实践

威震华夏关云长

引言

在Python开发中，资源管理和内存释放是构建稳定、高效应用程序的关键因素。不当的资源处理可能导致内存泄漏、性能下降甚至系统崩溃。本文将深入探讨Python中的资源管理机制，从基础概念到高级技巧，帮助开发者掌握安全处理资源的方法，避免内存泄漏，从而提升程序的稳定性和性能。

Python资源管理基础

Python内存管理机制

Python使用自动内存管理系统，主要基于引用计数机制，并辅以垃圾回收器处理循环引用。理解这一机制对于有效管理资源至关重要。

2. # 引用计数示例
3. import sys
5. a = []
6. print(sys.getrefcount(a))  # 输出: 2 (a变量和getrefcount参数各引用一次)
8. b = a
9. print(sys.getrefcount(a))  # 输出: 3 (a、b和getrefcount参数)
11. del b
12. print(sys.getrefcount(a))  # 输出: 2 (a和getrefcount参数)

复制代码

常见资源类型

在Python中，需要特别管理的资源主要包括：

1. 文件资源：打开的文件句柄
2. 网络资源：套接字连接、HTTP连接
3. 数据库资源：数据库连接、游标
4. 系统资源：进程、线程、锁
5. 内存资源：大对象、缓存

基本资源释放方法

最简单的资源释放方法是显式调用关闭或释放方法：

2. # 文件操作的基本资源释放
3. f = open('example.txt', 'r')
4. content = f.read()
5. f.close()  # 显式关闭文件
7. # 数据库连接的基本资源释放
8. import sqlite3
10. conn = sqlite3.connect('example.db')
11. cursor = conn.cursor()
12. cursor.execute("SELECT * FROM users")
13. cursor.close()  # 关闭游标
14. conn.close()    # 关闭连接

复制代码

然而，这种方法在异常情况下可能无法执行，因此需要更健壮的资源管理方式。

上下文管理器与with语句

上下文管理器原理

上下文管理器是Python中管理资源的强大工具，它通过实现__enter__和__exit__方法来定义资源的设置和清理逻辑。

2. class FileContextManager:
3.     def __init__(self, filename, mode):
4.         self.filename = filename
5.         self.mode = mode
6.         self.file = None
7.    
8.     def __enter__(self):
9.         self.file = open(self.filename, self.mode)
10.         return self.file
11.    
12.     def __exit__(self, exc_type, exc_val, exc_tb):
13.         if self.file:
14.             self.file.close()
15.         # 如果返回True，则抑制异常；返回False或None，则传播异常
16.         return False
18. # 使用自定义上下文管理器
19. with FileContextManager('example.txt', 'r') as f:
20.     content = f.read()
21.     # 文件会在with块结束时自动关闭

复制代码

使用with语句管理资源

Python的许多内置类型已经支持上下文管理协议，可以直接使用with语句：

2. # 文件操作
3. with open('example.txt', 'r') as f:
4.     content = f.read()
5.     # 文件会在with块结束时自动关闭，即使发生异常
7. # 线程锁
8. import threading
10. lock = threading.Lock()
11. with lock:
12.     # 临界区代码
13.     # 锁会在with块结束时自动释放
15. # 数据库连接
16. import sqlite3
18. with sqlite3.connect('example.db') as conn:
19.     cursor = conn.cursor()
20.     cursor.execute("SELECT * FROM users")
21.     # 连接会在with块结束时自动关闭

复制代码

自定义上下文管理器

除了类方式，Python还提供了contextlib模块，使用装饰器或生成器函数简化上下文管理器的创建：

2. from contextlib import contextmanager
4. @contextmanager
5. def database_connection(db_url):
6.     conn = create_db_connection(db_url)  # 假设的连接创建函数
7.     try:
8.         yield conn
9.     finally:
10.         conn.close()
12. # 使用自定义上下文管理器
13. with database_connection('postgresql://user:pass@localhost/db') as conn:
14.     cursor = conn.cursor()
15.     cursor.execute("SELECT * FROM users")

复制代码

垃圾回收机制

引用计数

Python的主要内存管理机制是引用计数，每个对象都有一个引用计数器，当计数器降为零时，对象会被立即回收。

2. import sys
4. class MyClass:
5.     def __del__(self):
6.         print("对象被回收")
8. # 创建对象
9. obj = MyClass()
10. print(sys.getrefcount(obj))  # 输出: 2
12. # 增加引用
13. obj_ref = obj
14. print(sys.getrefcount(obj))  # 输出: 3
16. # 减少引用
17. del obj_ref
18. print(sys.getrefcount(obj))  # 输出: 2
20. # 最后一个引用被删除
21. del obj
22. # 输出: 对象被回收

复制代码

分代回收

为了处理循环引用问题，Python实现了分代垃圾回收机制。对象根据存活时间分为三代，新创建的对象在第0代，存活时间越长的对象所在代数越高。

2. import gc
4. # 获取垃圾回收器信息
5. print(gc.get_threshold())  # 输出: (700, 10, 10) - 三代阈值
6. print(gc.get_count())      # 输出各代的计数
8. # 手动触发垃圾回收
9. collected = gc.collect()
10. print(f"回收了 {collected} 个对象")
12. # 调试垃圾回收
13. gc.set_debug(gc.DEBUG_STATS)

复制代码

循环引用处理

循环引用会导致引用计数永远不为零，需要垃圾回收器来处理：

2. import gc
4. class Node:
5.     def __init__(self, name):
6.         self.name = name
7.         self.parent = None
8.         self.children = []
9.    
10.     def add_child(self, child):
11.         self.children.append(child)
12.         child.parent = self
13.    
14.     def __del__(self):
15.         print(f"节点 {self.name} 被回收")
17. # 创建循环引用
18. root = Node("root")
19. child = Node("child")
20. root.add_child(child)
22. # 删除引用
23. del root, child
25. # 手动触发垃圾回收处理循环引用
26. gc.collect()
27. # 输出: 节点 root 被回收
28. # 输出: 节点 child 被回收

复制代码

常见资源类型的释放技巧

文件操作

文件操作是最常见的资源管理场景之一：

2. # 基本文件操作
3. with open('input.txt', 'r') as infile, open('output.txt', 'w') as outfile:
4.     for line in infile:
5.         outfile.write(line.upper())
7. # 处理二进制文件
8. with open('image.jpg', 'rb') as img_file:
9.     data = img_file.read()
10.     # 处理图像数据
12. # 使用临时文件
13. import tempfile
15. with tempfile.NamedTemporaryFile(mode='w+', delete=True) as temp:
16.     temp.write("临时数据")
17.     temp.seek(0)
18.     content = temp.read()
19.     # 临时文件会在with块结束时自动删除

复制代码

数据库连接

数据库连接是有限的资源，需要及时释放：

2. # SQLite示例
3. import sqlite3
5. def query_database(query):
6.     conn = None
7.     try:
8.         conn = sqlite3.connect('example.db')
9.         cursor = conn.cursor()
10.         cursor.execute(query)
11.         return cursor.fetchall()
12.     except sqlite3.Error as e:
13.         print(f"数据库错误: {e}")
14.         return None
15.     finally:
16.         if conn:
17.             conn.close()
19. # 使用上下文管理器管理数据库连接
20. from contextlib import contextmanager
22. @contextmanager
23. def db_connection(db_path):
24.     conn = sqlite3.connect(db_path)
25.     try:
26.         yield conn
27.     finally:
28.         conn.close()
30. # 使用上下文管理器
31. with db_connection('example.db') as conn:
32.     cursor = conn.cursor()
33.     cursor.execute("SELECT * FROM users")
34.     users = cursor.fetchall()

复制代码

网络连接

网络连接也是需要谨慎管理的资源：

2. # HTTP请求
3. import requests
5. def fetch_data(url):
6.     try:
7.         response = requests.get(url, timeout=5)
8.         response.raise_for_status()  # 检查请求是否成功
9.         return response.json()
10.     except requests.RequestException as e:
11.         print(f"请求错误: {e}")
12.         return None
13.     finally:
14.         # requests会自动管理连接，但显式关闭是个好习惯
15.         if 'response' in locals():
16.             response.close()
18. # 使用会话对象
19. def fetch_multiple_data(urls):
20.     with requests.Session() as session:
21.         results = []
22.         for url in urls:
23.             try:
24.                 response = session.get(url, timeout=5)
25.                 response.raise_for_status()
26.                 results.append(response.json())
27.             except requests.RequestException as e:
28.                 print(f"请求 {url} 错误: {e}")
29.         return results

复制代码

线程和进程资源

多线程和多程序资源需要特别小心管理：

2. # 线程管理
3. import threading
4. import time
6. def worker():
7.     print("工作线程开始")
8.     time.sleep(2)
9.     print("工作线程结束")
11. # 创建并启动线程
12. thread = threading.Thread(target=worker)
13. thread.start()
15. # 等待线程完成
16. thread.join()
17. print("主线程继续")
19. # 使用线程池
20. from concurrent.futures import ThreadPoolExecutor
22. def process_data(data):
23.     # 处理数据的函数
24.     time.sleep(1)
25.     return data * 2
27. data_list = [1, 2, 3, 4, 5]
28. results = []
30. with ThreadPoolExecutor(max_workers=3) as executor:
31.     # 提交任务到线程池
32.     future_to_data = {executor.submit(process_data, data): data for data in data_list}
33.    
34.     # 获取结果
35.     for future in concurrent.futures.as_completed(future_to_data):
36.         data = future_to_data[future]
37.         try:
38.             result = future.result()
39.             results.append(result)
40.         except Exception as e:
41.             print(f"处理 {data} 时出错: {e}")
43. print(results)

复制代码

高级资源管理技巧

弱引用

弱引用允许引用对象而不增加其引用计数，对于缓存和观察者模式等场景非常有用：

2. import weakref
4. class MyClass:
5.     def __init__(self, name):
6.         self.name = name
7.    
8.     def __del__(self):
9.         print(f"{self.name} 被回收")
11. # 创建对象
12. obj = MyClass("对象1")
14. # 创建弱引用
15. weak_ref = weakref.ref(obj)
17. # 通过弱引用访问对象
18. print(weak_ref().name)  # 输出: 对象1
20. # 删除原始引用
21. del obj
23. # 弱引用现在返回None
24. print(weak_ref())  # 输出: None
25. # 输出: 对象1 被回收
27. # 使用WeakValueDictionary实现缓存
28. cache = weakref.WeakValueDictionary()
30. def get_data(key):
31.     if key in cache:
32.         print(f"从缓存获取 {key}")
33.         return cache[key]
34.     else:
35.         print(f"计算并缓存 {key}")
36.         value = expensive_computation(key)  # 假设的昂贵计算函数
37.         cache[key] = value
38.         return value

复制代码

终结器(del)

__del__方法在对象被回收时调用，但不应依赖它进行关键资源清理：

2. class ResourceHandler:
3.     def __init__(self, resource):
4.         self.resource = resource
5.         print(f"获取资源: {resource}")
6.    
7.     def __del__(self):
8.         # 注意：__del__方法不保证一定会被调用
9.         # 不应依赖它进行关键资源清理
10.         print(f"释放资源: {self.resource}")
11.         # 实际释放资源的代码
13. # 创建对象
14. handler = ResourceHandler("数据库连接")
16. # 删除引用
17. del handler
18. # 可能会输出: 释放资源: 数据库连接
20. # 更好的方式是使用上下文管理器
21. class SafeResourceHandler:
22.     def __init__(self, resource):
23.         self.resource = resource
24.         print(f"获取资源: {resource}")
25.    
26.     def __enter__(self):
27.         return self
28.    
29.     def __exit__(self, exc_type, exc_val, exc_tb):
30.         print(f"释放资源: {self.resource}")
31.         # 实际释放资源的代码
32.         return False
34. # 使用上下文管理器
35. with SafeResourceHandler("数据库连接"):
36.     print("使用资源")
37. # 确保输出: 释放资源: 数据库连接

复制代码

内存分析工具

使用内存分析工具可以帮助识别内存泄漏和优化资源使用：

2. # 使用tracemalloc跟踪内存分配
3. import tracemalloc
5. def memory_intensive_function():
6.     # 分配大量内存
7.     data = [i for i in range(100000)]
8.     return data
10. # 开始跟踪内存分配
11. tracemalloc.start()
13. # 获取当前内存快照
14. snapshot1 = tracemalloc.take_snapshot()
16. # 执行内存密集型函数
17. result = memory_intensive_function()
19. # 获取执行后的内存快照
20. snapshot2 = tracemalloc.take_snapshot()
22. # 比较两个快照
23. top_stats = snapshot2.compare_to(snapshot1, 'lineno')
25. print("[ 内存使用最多的代码行 ]")
26. for stat in top_stats[:10]:
27.     print(stat)
29. # 使用memory_profiler分析内存使用
30. # 需要先安装: pip install memory_profiler
31. from memory_profiler import profile
33. @profile
34. def memory_profile_example():
35.     a = [1] * (10 ** 6)
36.     b = [2] * (2 * 10 ** 7)
37.     del b
38.     return a
40. # memory_profile_example()

复制代码

最佳实践

设计模式

应用适当的设计模式可以显著改善资源管理：

2. # 单例模式管理数据库连接池
3. class DatabaseConnectionPool:
4.     _instance = None
5.     _pool = None
6.    
7.     def __new__(cls):
8.         if cls._instance is None:
9.             cls._instance = super(DatabaseConnectionPool, cls).__new__(cls)
10.             cls._pool = cls._create_pool()
11.         return cls._instance
12.    
13.     @classmethod
14.     def _create_pool(cls):
15.         # 创建数据库连接池
16.         import sqlite3
17.         pool = []
18.         for _ in range(5):  # 创建5个连接
19.             pool.append(sqlite3.connect('example.db'))
20.         return pool
21.    
22.     def get_connection(self):
23.         if self._pool:
24.             return self._pool.pop()
25.         else:
26.             # 如果池中没有可用连接，创建新连接
27.             import sqlite3
28.             return sqlite3.connect('example.db')
29.    
30.     def return_connection(self, conn):
31.         if len(self._pool) < 10:  # 最多保留10个连接
32.             self._pool.append(conn)
33.         else:
34.             conn.close()
36. # 使用单例连接池
37. pool = DatabaseConnectionPool()
38. conn1 = pool.get_connection()
39. # 使用连接...
40. pool.return_connection(conn1)
42. # 工厂模式创建资源管理器
43. class ResourceManagerFactory:
44.     @staticmethod
45.     def create_manager(resource_type):
46.         if resource_type == "file":
47.             return FileResourceManager()
48.         elif resource_type == "database":
49.             return DatabaseResourceManager()
50.         elif resource_type == "network":
51.             return NetworkResourceManager()
52.         else:
53.             raise ValueError(f"不支持的资源类型: {resource_type}")
55. class FileResourceManager:
56.     def open(self, path, mode='r'):
57.         return open(path, mode)
59. class DatabaseResourceManager:
60.     def connect(self, db_url):
61.         import sqlite3
62.         return sqlite3.connect(db_url)
64. class NetworkResourceManager:
65.     def create_session(self):
66.         import requests
67.         return requests.Session()
69. # 使用工厂模式
70. file_manager = ResourceManagerFactory.create_manager("file")
71. with file_manager.open("example.txt") as f:
72.     content = f.read()

复制代码

代码审查要点

在代码审查过程中，应特别关注以下资源管理方面：

1. 资源释放：确保所有获取的资源都有对应的释放操作
2. 异常处理：确保在异常情况下资源也能正确释放
3. 上下文管理器：推荐使用with语句管理资源
4. 循环引用：检查是否存在可能导致内存泄漏的循环引用

2. # 不好的资源管理示例
3. def bad_resource_management():
4.     f = open('file.txt', 'r')  # 文件可能不会在异常情况下关闭
5.     content = f.read()
6.     # 如果这里发生异常，文件不会关闭
7.     process_data(content)
8.     f.close()  # 如果异常发生，这行不会执行
10. # 改进后的资源管理
11. def good_resource_management():
12.     try:
13.         with open('file.txt', 'r') as f:  # 使用with语句确保文件关闭
14.             content = f.read()
15.             process_data(content)
16.     except IOError as e:
17.         print(f"文件操作错误: {e}")
18.     except Exception as e:
19.         print(f"处理数据时出错: {e}")

复制代码

性能优化策略

通过合理的资源管理策略可以显著提升程序性能：

2. # 使用对象池重用资源
3. class ObjectPool:
4.     def __init__(self, creator, max_size=10):
5.         self.creator = creator
6.         self.max_size = max_size
7.         self.pool = []
8.         self.in_use = set()
9.    
10.     def get(self):
11.         if self.pool:
12.             obj = self.pool.pop()
13.             self.in_use.add(id(obj))
14.             return obj
15.         else:
16.             obj = self.creator()
17.             self.in_use.add(id(obj))
18.             return obj
19.    
20.     def release(self, obj):
21.         obj_id = id(obj)
22.         if obj_id in self.in_use:
23.             self.in_use.remove(obj_id)
24.             if len(self.pool) < self.max_size:
25.                 # 重置对象状态
26.                 if hasattr(obj, 'reset'):
27.                     obj.reset()
28.                 self.pool.append(obj)
29.             else:
30.                 # 超出池大小，直接丢弃
31.                 pass
33. # 使用对象池管理数据库连接
34. def create_db_connection():
35.     import sqlite3
36.     return sqlite3.connect('example.db')
38. connection_pool = ObjectPool(create_db_connection, max_size=5)
40. def query_with_pool(sql):
41.     conn = connection_pool.get()
42.     try:
43.         cursor = conn.cursor()
44.         cursor.execute(sql)
45.         return cursor.fetchall()
46.     finally:
47.         connection_pool.release(conn)
49. # 延迟加载资源
50. class LazyResource:
51.     def __init__(self, resource_factory):
52.         self._resource_factory = resource_factory
53.         self._resource = None
54.    
55.     @property
56.     def resource(self):
57.         if self._resource is None:
58.             self._resource = self._resource_factory()
59.         return self._resource
60.    
61.     def reset(self):
62.         if self._resource is not None:
63.             # 释放资源
64.             if hasattr(self._resource, 'close'):
65.                 self._resource.close()
66.             self._resource = None
68. # 使用延迟加载
69. lazy_db = LazyResource(lambda: sqlite3.connect('example.db'))
71. # 只有在访问resource属性时才会创建连接
72. cursor = lazy_db.resource.cursor()
73. cursor.execute("SELECT * FROM users")

复制代码

案例分析

实际项目中的内存泄漏问题

考虑一个Web爬虫项目，它在长时间运行后内存占用不断增长：

2. # 存在内存泄漏的爬虫实现
3. class LeakyWebCrawler:
4.     def __init__(self):
5.         self.visited_urls = set()
6.         self.session = requests.Session()
7.         self.data_store = []  # 问题：不断增长的数据存储
8.    
9.     def crawl(self, url, max_depth=3, current_depth=0):
10.         if current_depth >= max_depth or url in self.visited_urls:
11.             return
12.         
13.         self.visited_urls.add(url)
14.         
15.         try:
16.             response = self.session.get(url, timeout=10)
17.             if response.status_code == 200:
18.                 # 处理页面内容
19.                 data = self.extract_data(response)
20.                 self.data_store.append(data)  # 问题：数据不断累积
21.                
22.                 # 提取链接并递归爬取
23.                 links = self.extract_links(response)
24.                 for link in links:
25.                     self.crawl(link, max_depth, current_depth + 1)
26.         except Exception as e:
27.             print(f"爬取 {url} 时出错: {e}")
28.    
29.     def extract_data(self, response):
30.         # 提取并返回页面数据
31.         return {"url": response.url, "content": response.text[:100]}
32.    
33.     def extract_links(self, response):
34.         # 提取并返回页面中的链接
35.         # 简化实现
36.         return ["http://example.com/page1", "http://example.com/page2"]
38. # 使用爬虫
39. crawler = LeakyWebCrawler()
40. crawler.crawl("http://example.com")

复制代码

解决方案与效果

针对上述内存泄漏问题，我们可以采取以下措施：

2. # 改进后的爬虫实现
3. class EfficientWebCrawler:
4.     def __init__(self, max_stored_data=1000):
5.         self.visited_urls = set()
6.         self.session = requests.Session()
7.         self.max_stored_data = max_stored_data
8.         self.data_store = []
9.         self.data_callbacks = []  # 数据处理回调函数
10.    
11.     def add_data_callback(self, callback):
12.         """添加数据处理回调函数"""
13.         self.data_callbacks.append(callback)
14.    
15.     def crawl(self, url, max_depth=3, current_depth=0):
16.         if current_depth >= max_depth or url in self.visited_urls:
17.             return
18.         
19.         self.visited_urls.add(url)
20.         
21.         try:
22.             response = self.session.get(url, timeout=10)
23.             if response.status_code == 200:
24.                 # 处理页面内容
25.                 data = self.extract_data(response)
26.                 self._process_data(data)
27.                
28.                 # 提取链接并递归爬取
29.                 links = self.extract_links(response)
30.                 for link in links:
31.                     self.crawl(link, max_depth, current_depth + 1)
32.         except Exception as e:
33.             print(f"爬取 {url} 时出错: {e}")
34.    
35.     def _process_data(self, data):
36.         """处理提取的数据"""
37.         # 调用所有注册的回调函数
38.         for callback in self.data_callbacks:
39.             try:
40.                 callback(data)
41.             except Exception as e:
42.                 print(f"数据处理回调出错: {e}")
43.         
44.         # 限制存储的数据量
45.         self.data_store.append(data)
46.         if len(self.data_store) > self.max_stored_data:
47.             # 移除最旧的数据
48.             self.data_store = self.data_store[-self.max_stored_data:]
49.    
50.     def extract_data(self, response):
51.         """提取并返回页面数据"""
52.         return {"url": response.url, "content": response.text[:100]}
53.    
54.     def extract_links(self, response):
55.         """提取并返回页面中的链接"""
56.         # 简化实现
57.         return ["http://example.com/page1", "http://example.com/page2"]
58.    
59.     def clear_data(self):
60.         """清空存储的数据"""
61.         self.data_store.clear()
62.    
63.     def __del__(self):
64.         """析构函数，确保资源释放"""
65.         if hasattr(self, 'session') and self.session:
66.             self.session.close()
68. # 使用改进后的爬虫
69. def save_to_database(data):
70.     """将数据保存到数据库的回调函数"""
71.     print(f"保存数据到数据库: {data['url']}")
73. def save_to_file(data):
74.     """将数据保存到文件的回调函数"""
75.     print(f"保存数据到文件: {data['url']}")
77. crawler = EfficientWebCrawler(max_stored_data=100)
78. crawler.add_data_callback(save_to_database)
79. crawler.add_data_callback(save_to_file)
81. crawler.crawl("http://example.com")
83. # 定期清理数据
84. crawler.clear_data()

复制代码

改进后的爬虫实现了以下优化：

1. 限制数据存储量：通过max_stored_data参数限制内存中存储的数据量
2. 回调机制：通过回调函数处理数据，避免数据在内存中累积
3. 资源清理：添加了clear_data方法和__del__析构函数，确保资源正确释放
4. 异常处理：在回调函数执行过程中添加了异常处理，避免因回调函数异常导致整个爬虫崩溃

这些改进显著减少了内存使用，并提高了爬虫的稳定性和长时间运行能力。

总结与展望

Python资源管理是构建稳定、高效应用程序的关键。通过本文的介绍，我们了解了从基础的资源释放方法到高级的资源管理技巧，包括上下文管理器、垃圾回收机制、弱引用等概念，并通过实际代码示例展示了如何安全地处理各种资源类型。

最佳实践部分强调了设计模式的应用、代码审查要点和性能优化策略，而案例分析则展示了如何在实际项目中识别和解决内存泄漏问题。

随着Python的发展，资源管理技术也在不断进步。未来，我们可以期待：

1. 更智能的垃圾回收器：更高效的循环引用检测和内存回收算法
2. 异步资源管理：针对异步编程模式的资源管理工具和最佳实践
3. 更丰富的分析工具：更强大的内存分析和性能优化工具
4. 自动化资源管理：基于AI的资源使用优化建议和自动化修复

作为Python开发者，持续学习和应用最新的资源管理技术，将有助于我们构建更加稳定、高效的应用程序，为用户提供更好的体验。

版权声明

1、转载或引用本网站内容(Python附件释放详细指南从基础到高级技巧帮助开发者安全处理资源避免内存泄漏提升程序稳定性包括实际代码示例和最佳实践)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.cc/thread-39409-1-1.html