Python 爬虫实战：Playwright 多浏览器并发与性能优化

这个脚本能帮你快速确认三个浏览器引擎是否都安装正确。如果 Firefox 启动失败，在 Linux 上可能是缺少 libgtk 相关库；WebKit 在部分旧系统上可能需要额外依赖。根据报错信息搜索，通常都能找到解决方案。

为并发优化的启动参数配置

直接使用默认参数启动浏览器进行并发任务，可能会浪费资源或触发限制。我们需要针对爬虫场景进行调优。我的经验是，为不同类型的浏览器配置不同的启动参数，可以显著提升稳定性和效率。

下面这个配置类是我在多个项目中提炼出来的，你可以直接复制使用：

class BrowserConfig:
    """浏览器启动配置模板"""
    
    @staticmethod
    def get_chromium_args():
        """Chromium 优化参数：速度优先，资源适中"""
        return {
            "headless": True,
            "args": [
                "--disable-blink-features=AutomationControlled",  # 隐藏自动化控制标志
                "--disable-dev-shm-usage",                        # 解决 Docker 等环境共享内存问题
                "--no-sandbox",                                   # 非绝对安全环境可考虑，提升稳定性
                "--disable-web-security",                         # 禁用同源策略，便于测试，生产环境慎用
                "--disable-features=IsolateOrigins,site-per-process"  # 减少进程隔离开销
            ],
            "viewport": {"width": 1920, "height": 1080},  # 固定视口，避免响应式布局问题
            "ignore_https_errors": True,
            "timeout": 30000  # 启动超时时间设为 30 秒
        }

    @staticmethod
    def get_firefox_args():
        """Firefox 优化参数：侧重兼容性与稳定性"""
        return {
            "headless": True,
            "firefox_user_prefs": {
                "javascript.enabled": True,
                "dom.webdriver.enabled": False,  # 禁用 WebDriver 标志
                "media.volume_scale": "0.0",     # 静音，避免自动播放声音
                "privacy.trackingprotection.enabled": False  # 关闭跟踪保护，减少干扰
            },
            "viewport": {"width": 1920, "height": 1080},
            "ignore_https_errors": True,
            "timeout": 40000  # Firefox 启动通常稍慢，超时设长一点
        }

    @staticmethod
    def get_webkit_args():
        """WebKit 优化参数：模拟真实 Safari 环境"""
        return {
            "headless": True,
            # WebKit 特有的用户代理字符串，模拟 Mac 上的 Safari
            "user_agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
            "viewport": {"width": 1920, "height": 1080},
            "ignore_https_errors": True,
            "timeout": 35000
        }

# 使用示例
with sync_playwright() as p:
    config = BrowserConfig()
    chromium_browser = p.chromium.launch(**config.get_chromium_args())
    firefox_browser = p.firefox.launch(**config.get_firefox_args())
    webkit_browser = p.webkit.launch(**config.get_webkit_args())

这些参数都是我踩过坑后总结的。比如 --disable-dev-shm-usage 能解决在 Docker 或内存有限环境下 Chromium 崩溃的问题。Firefox 的 dom.webdriver.enabled 偏好设置能进一步降低被检测的风险。WebKit 则重点配置了 macOS Safari 的典型 User-Agent，让它看起来更'真实'。

构建稳健的多浏览器并发框架

有了基础的浏览器实例，下一步就是让它们协同工作。并发不是简单的同时开几个浏览器，而是要管理好它们的生命周期、任务分配和错误处理。我设计了一个基于异步（asyncio）的并发管理器，它包含了连接池、错误重试和资源限制等实用功能。

异步并发核心引擎

同步 API 写起来简单，但在高并发 I/O 密集型任务（如爬虫）中，异步 API 能大幅提升效率，因为它能在等待网络响应时去处理其他任务。下面这个 AsyncBrowserManager 类是我常用的框架核心：

import asyncio
import logging
from typing import List, Dict, Any, Optional
from playwright.async_api import async_playwright, Browser, BrowserType

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class AsyncBrowserManager:
    """异步多浏览器并发管理器"""
    def __init__(self, max_concurrent_per_browser: int = 3):
        """
        初始化管理器
        :param max_concurrent_per_browser: 每种浏览器类型允许的最大并发上下文数
        """
        self.playwright = None
        self.browsers: Dict[str, Browser] = {}  # 存储浏览器实例
        self.semaphores: Dict[str, asyncio.Semaphore] = {}  # 控制每种浏览器的并发量
        self.max_concurrent = max_concurrent_per_browser
        self.config = BrowserConfig()

    async def start(self):
        """启动所有浏览器实例"""
        self.playwright = await async_playwright().start()
        browsers_config = [
            ("chromium", self.config.get_chromium_args()),
            ("firefox", self.config.get_firefox_args()),
            ("webkit", self.config.get_webkit_args())
        ]
        
        for name, args in browsers_config:
            browser_type = getattr(self.playwright, name)
            browser = await browser_type.launch(**args)
            self.browsers[name] = browser
            self.semaphores[name] = asyncio.Semaphore(self.max_concurrent)
            logger.info(f"{name} 启动成功")

    async def run_task(self, url: str, browser_name: str):
        """执行单个页面抓取任务"""
        semaphore = self.semaphores[browser_name]
        async with semaphore:
            try:
                browser = self.browsers[browser_name]
                context = await browser.new_context()
                page = await context.new_page()
                await page.goto(url, wait_until="networkidle")
                content = await page.content()
                await context.close()
                return {"status": "success", "url": url, "browser": browser_name}
            except Exception as e:
                logger.error(f"Task failed on {browser_name}: {e}")
                return {"status": "failed", "url": url, "error": str(e)}

    async def close(self):
        """关闭所有资源"""
        if self.playwright:
            await self.playwright.stop()
            logger.info("所有资源已释放")

这段代码的关键在于 semaphore 的使用。它限制了每种浏览器同时打开的上下文数量，防止瞬间占用过多内存导致系统卡死。run_task 方法封装了基本的页面加载逻辑，你可以根据实际需求替换为具体的数据提取函数。

实战调用示例

最后，怎么把这些串起来跑呢？其实很简单，利用 asyncio.gather 就能轻松实现多任务并发。

async def main():
    manager = AsyncBrowserManager(max_concurrent_per_browser=2)
    await manager.start()
    
    urls = [
        "https://example.com/page1",
        "https://example.com/page2",
        "https://example.com/page3"
    ]
    
    tasks = []
    for url in urls:
        # 随机分配浏览器类型，或者指定特定浏览器
        browser_type = "chromium" if "page1" in url else "firefox"
        tasks.append(manager.run_task(url, browser_type))
    
    results = await asyncio.gather(*tasks)
    for res in results:
        print(res)
    
    await manager.close()

if __name__ == "__main__":
    asyncio.run(main())

这样一套下来，你的爬虫系统就有了基本的容错能力和扩展性。当然，实际生产中还需要加入代理 IP 轮换、Cookie 持久化等高级特性，但这套框架已经足够应对大部分常规需求了。记住，稳定的架构比炫技的代码更重要，尤其是在对抗反爬的时候。