# tab_pool

**Repository Path**: stupid1t/tab_pool

## Basic Information

- **Project Name**: tab_pool
- **Description**: 基于 DrissionPage 的 tab 池功能
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-08-26
- **Last Updated**: 2025-08-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# DrissionPage Tab Pool

基于 DrissionPage 的 Tab 池管理器，类似线程池的概念，用于管理和复用浏览器标签页，提高并发性能并控制资源使用。

## 特性

- 🚀 **高性能并发**: 复用 Tab 避免频繁创建销毁
- 🔒 **线程安全**: 支持多线程并发访问
- ⏱️ **超时控制**: 获取 Tab 支持超时设置
- 🎯 **资源控制**: 限制最大 Tab 数量，避免资源耗尽
- 🔄 **自动管理**: 支持上下文管理器自动归还 Tab
- 🛠️ **灵活配置**: 支持自定义浏览器选项

## 安装依赖

```bash
pip install DrissionPage
```

## 快速开始

### 基础用法

```python
from tab_pool import TabPool

# 创建 Tab 池（最大 3 个 Tab）
with TabPool(max_tabs=3) as pool:
    # 方式1: 手动获取和归还
    tab = pool.get_tab(timeout=10)
    try:
        tab.get('https://www.baidu.com')
        print(tab.title)
    finally:
        pool.return_tab(tab)
    
    # 方式2: 上下文管理器（推荐）
    with pool.acquire_tab() as tab:
        tab.get('https://www.bing.com')
        print(tab.title)
        # Tab 会自动归还
```

### 多线程并发

```python
import threading
from tab_pool import TabPool

def worker_task(pool, url, task_id):
    with pool.acquire_tab() as tab:
        print(f"任务 {task_id}: 访问 {url}")
        tab.get(url)
        print(f"任务 {task_id}: {tab.title}")

# 创建 Tab 池
with TabPool(max_tabs=2) as pool:
    urls = ['https://www.baidu.com', 'https://www.bing.com', 'https://www.so.com']
    
    threads = []
    for i, url in enumerate(urls):
        thread = threading.Thread(target=worker_task, args=(pool, url, i+1))
        threads.append(thread)
        thread.start()
    
    # 等待所有任务完成
    for thread in threads:
        thread.join()
```

## API 文档

### TabPool 类

#### 构造函数

```python
TabPool(max_tabs=5, browser_options=None)
```

**参数:**
- `max_tabs` (int): 最大 Tab 数量，默认 5
- `browser_options` (ChromiumOptions): 自定义浏览器选项，默认 None

#### 主要方法

##### get_tab(timeout=None)
获取一个可用的 Tab

**参数:**
- `timeout` (float): 超时时间（秒），None 表示无限等待

**返回:** Tab 对象

**异常:**
- `TimeoutError`: 获取超时
- `RuntimeError`: Tab 池已关闭

##### return_tab(tab)
归还 Tab 到池中

**参数:**
- `tab`: 要归还的 Tab 对象

##### acquire_tab(timeout=None)
上下文管理器方式获取 Tab（推荐使用）

**参数:**
- `timeout` (float): 超时时间（秒）

**用法:**
```python
with pool.acquire_tab() as tab:
    # 使用 tab
    pass
# tab 自动归还
```

##### close()
关闭 Tab 池和浏览器

### TabPoolManager 类

增强版管理器，提供更高级的任务管理功能。

#### 构造函数

```python
TabPoolManager(max_tabs=5, browser_options=None)
```

#### 主要方法

##### submit_task(func, *args, **kwargs)
提交任务到 Tab 池

**参数:**
- `func`: 任务函数，第一个参数必须是 tab
- `*args, **kwargs`: 传递给任务函数的参数

**返回:** Thread 对象

##### wait_all_tasks()
等待所有任务完成

##### close()
关闭管理器

## 使用示例

### 示例1: 批量搜索

```python
from tab_pool import TabPool
import threading

def search_keyword(pool, keyword):
    with pool.acquire_tab() as tab:
        tab.get('https://www.baidu.com')
        search_box = tab.ele('#kw')
        search_box.input(keyword)
        tab.ele('#su').click()
        
        results = tab.eles('.t a')
        print(f"'{keyword}' 搜索结果: {len(results)} 条")

# 批量搜索关键词
keywords = ['Python', 'JavaScript', 'Java', 'Go']

with TabPool(max_tabs=2) as pool:
    threads = []
    for keyword in keywords:
        thread = threading.Thread(target=search_keyword, args=(pool, keyword))
        threads.append(thread)
        thread.start()
    
    for thread in threads:
        thread.join()
```

### 示例2: 使用 TabPoolManager

```python
from tab_pool import TabPoolManager

def crawl_page(tab, url, name):
    tab.get(url)
    return f"{name}: {tab.title}"

manager = TabPoolManager(max_tabs=3)

sites = [
    ('https://www.baidu.com', '百度'),
    ('https://www.bing.com', '必应'),
    ('https://www.so.com', '360搜索')
]

# 提交任务
for url, name in sites:
    manager.submit_task(crawl_page, url, name)

# 等待完成
manager.wait_all_tasks()
manager.close()
```

### 示例3: 自定义浏览器选项

```python
from tab_pool import TabPool
from DrissionPage import ChromiumOptions

# 自定义浏览器选项
co = ChromiumOptions()
co.headless()  # 无头模式
co.set_argument('--no-sandbox')
co.set_timeouts(base=10, page_load=60)

with TabPool(max_tabs=2, browser_options=co) as pool:
    with pool.acquire_tab() as tab:
        tab.get('https://www.example.com')
        print(tab.title)
```

## 最佳实践

### 1. 选择合适的 Tab 数量
```python
# 根据任务类型选择合适的并发数
# CPU 密集型任务: 1-2 个 Tab
# IO 密集型任务: 3-5 个 Tab
# 网络爬虫: 2-4 个 Tab（避免被反爬）
```

### 2. 使用上下文管理器
```python
# ✅ 推荐: 自动管理资源
with pool.acquire_tab() as tab:
    # 使用 tab
    pass

# ❌ 不推荐: 手动管理容易忘记归还
tab = pool.get_tab()
# ... 使用 tab
pool.return_tab(tab)  # 容易忘记
```

### 3. 设置合理的超时时间
```python
# 设置超时避免无限等待
with pool.acquire_tab(timeout=30) as tab:
    # 30秒内获取不到 tab 会抛出异常
    pass
```

### 4. 异常处理
```python
try:
    with pool.acquire_tab(timeout=10) as tab:
        tab.get('https://www.example.com')
        # 处理页面
except TimeoutError:
    print("获取 Tab 超时")
except Exception as e:
    print(f"处理出错: {e}")
```

## 注意事项

1. **资源管理**: 使用完毕后记得关闭 Tab 池
2. **并发控制**: 不要设置过多的 Tab 数量，避免浏览器崩溃
3. **异常处理**: 在任务中添加适当的异常处理
4. **网站限制**: 注意目标网站的访问频率限制
5. **内存使用**: 长时间运行时注意内存使用情况

## 运行示例

```bash
python tab_pool.py
```

选择对应的示例查看效果：
- 1: 基础 TabPool 示例
- 2: 高级 TabPool 示例  
- 3: TabPoolManager 示例

## 许可证

MIT License