[Qusetion]: Why close context or page failed sometime, and there are zombie when i closed browser and playwright.

[210coder]

Please do not submit this issue.

• I understand

[210coder]

package com.netease.mailanti.urlservice.playwright.service.impl;

import com.microsoft.playwright.*;
import com.microsoft.playwright.options.LoadState;
import com.microsoft.playwright.options.ScreenshotType;
import com.microsoft.playwright.options.WaitUntilState;
import com.netease.mailanti.urlservice.api.scrape.ScrapeAttachment;
import com.netease.mailanti.urlservice.api.scrape.UrlScrapeItemResult;
import com.netease.mailanti.urlservice.playwright.config.PlaywrightProperties;
import com.netease.mailanti.urlservice.playwright.num.AttachmentType;
import com.netease.mailanti.urlservice.playwright.util.URLUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

/**

• Playwright-based browser crawler.

• Architecture mirrors {@code url-service-scraper}'s {@code BrowserScrapeService}:

• one {@link BrowserSlot} per proxy (interleaved), each slot owns an independent
• Playwright process + Browser. Per-request {@link BrowserContext} + {@link Page}
• are created and closed to achieve thread-safe isolation.

• Content-type routing

• • {@code image/*} → 1 attachment: raw binary (IMAGE)
  • {@code text/*} → 2 attachments: HTML text (TEXT) + screenshot PNG (IMAGE)
  • other → 1 attachment: raw binary (TEXT)

*/
@slf4j
@service
public class PlaywrightBrowserService {

private static final String USER_AGENT =
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
        "(KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36 Edg/109.0.1518.70";
private static final String ACCEPT_LANGUAGE = "zh-CN,zh;q=0.9,en;q=0.8,or;q=0.7,ja;q=0.6";

/** IPC-level crash signatures that require a full Playwright+Browser rebuild. */
private static final List<String> IPC_CRASH_PATTERNS = Arrays.asList(
        "Failed to read message",
        "Unknown new child",
        "Target page, context or browser has been closed",
        "Playwright connection close",
        "Connection closed"
);

/** Consecutive failures before marking a slot as needing rebuild. */
private static final int FAIL_THRESHOLD = 3;

/** NETWORKIDLE wait timeout in ms (5s fallback, then proceed with current DOM). */
private static final int NETWORK_IDLE_TIMEOUT_MS = 5_000;

private final PlaywrightProperties config;
private volatile boolean available = false;
private List<BrowserSlot> slots = Collections.emptyList();

/** Single-threaded executor for async slot rebuilds — never blocks scrape threads. */
private final ExecutorService rebuildExecutor = Executors.newSingleThreadExecutor(r -> {
    Thread t = new Thread(r, "pw-slot-rebuild");
    t.setDaemon(true);
    return t;
});

@Autowired
public PlaywrightBrowserService(PlaywrightProperties config) {
    this.config = config;
}

// -------------------------------------------------------------------------
// Lifecycle
// -------------------------------------------------------------------------

@PostConstruct
public void init() {
    List<PlaywrightProperties.HttpProxy> proxies = config.getProxies();
    List<BrowserSlot> built = new ArrayList<>();
    try {
        if (proxies == null || proxies.isEmpty()) {
            log.warn("PlaywrightBrowserService: no proxies configured — service disabled");
            return;
        }
        int slotsPerProxy = Math.max(1, config.getBrowserSlotsPerProxy());
        for (int i = 0; i < slotsPerProxy; i++) {
            for (PlaywrightProperties.HttpProxy proxy : proxies) {
                int slotIndex = built.size();
                built.add(new BrowserSlot(slotIndex, proxy));
                log.info("PlaywrightBrowserService: slot [{}] ready - proxy={}:{} [{}/{}]",
                        slotIndex, proxy.getHost(), proxy.getPort(), i + 1, slotsPerProxy);
            }
        }
        slots = Collections.unmodifiableList(built);
        available = true;
        log.info("PlaywrightBrowserService ready - totalSlots={}", slots.size());
    } catch (Exception e) {
        available = false;
        built.forEach(BrowserSlot::close);
        log.error("PlaywrightBrowserService init failed — browser scraping disabled", e);
    }
}

@PreDestroy
public void destroy() {
    available = false;
    rebuildExecutor.shutdownNow();
    slots.forEach(BrowserSlot::close);
    log.info("PlaywrightBrowserService shut down");
}

/** Periodic health check — triggers async rebuild for broken slots. */
@Scheduled(fixedDelay = 60_000)
public void checkAndRebuildSlots() {
    if (!available) return;
    for (BrowserSlot slot : slots) {
        if (slot.needsRebuild()) {
            submitRebuild(slot);
        } else {
            log.info("PlaywrightBrowserService: slot {} ok", slot.label());
        }
    }
}

private void submitRebuild(BrowserSlot slot) {
    rebuildExecutor.submit(() -> {
        log.info("PlaywrightBrowserService: rebuild starting for slot {}", slot.label());
        slot.rebuild();
    });
}

// -------------------------------------------------------------------------
// Public API
// -------------------------------------------------------------------------

/**
 * Scrapes the URL in {@code result} and populates {@code result.attachments}.
 *
 * @param result  scrape result object to populate; url must be set
 */
public void execute(UrlScrapeItemResult result) {
    String url = result.getUrl();
    if (!available) {
        log.warn("PlaywrightBrowserService unavailable - skipping for {}", url);
        return;
    }

    Set<String> triedProxies = new HashSet<>();
    int proxyCount = config.getProxies() == null ? 0 : config.getProxies().size();

    for (BrowserSlot slot : slots) {
        String proxyKey = slot.proxyKey();
        if (triedProxies.contains(proxyKey)) continue;
        if (slot.state != SlotState.RUNNING) continue;

        triedProxies.add(proxyKey);
        try {
            slot.scrape(result, config.getTimeout().toMillis());
        } catch (Exception e) {
            log.error("PlaywrightBrowserService: slot {} failed for {} - {}",
                    proxyKey, url, e.getMessage());
        }

        if (!result.getAttachments().isEmpty()) {
            return;
        }
        if (triedProxies.size() >= proxyCount) break;
    }
}

private enum SlotState {
    RUNNING,   // 正常可用
    CLOSING,   // 正在关闭旧进程
    REBUILDING // 正在启动新进程
}

// -------------------------------------------------------------------------
// BrowserSlot
// -------------------------------------------------------------------------

private class BrowserSlot {

    private final int index;
    private final PlaywrightProperties.HttpProxy proxy;
    private volatile Playwright playwright;
    private volatile Browser browser;
    private volatile SlotState state = SlotState.RUNNING;
    private final AtomicInteger consecutiveFailures = new AtomicInteger(0);

    BrowserSlot(int index, PlaywrightProperties.HttpProxy proxy) {
        this.index = index;
        this.proxy = proxy;
        init();
    }

    private void init() {
        long start = System.currentTimeMillis();
        Map<String, String> env = new HashMap<>();
        env.put("PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD", "1");
        this.playwright = Playwright.create(new Playwright.CreateOptions().setEnv(env));

        BrowserType.LaunchOptions launchOpts = new BrowserType.LaunchOptions()
                .setHeadless(true)
                .setArgs(Arrays.asList(
                        "--no-sandbox",
                        "--disable-gpu",
                        "--disable-dev-shm-usage",
                        "--disable-css",
                        "--disable-extensions",
                        "--disable-background-networking",
                        "--disable-default-apps",
                        "--disable-sync",
                        "--no-first-run",
                        "--memory-model=low"
                ))
                .setProxy(new com.microsoft.playwright.options.Proxy(
                        "http://" + proxy.getHost() + ":" + proxy.getPort()));
        this.browser = playwright.chromium().launch(launchOpts);
        log.info("PlaywrightBrowserService: slot {} ready in {}ms",
                label(), System.currentTimeMillis() - start);
    }

    String label() {
        return "[" + index + "] " + proxy.getHost() + ":" + proxy.getPort();
    }

    String proxyKey() {
        return proxy.getHost() + ":" + proxy.getPort();
    }

    boolean needsRebuild() {
        if (state == SlotState.CLOSING || state == SlotState.REBUILDING) {
            return true;
        }
        if (consecutiveFailures.get() >= FAIL_THRESHOLD) {
            log.warn("PlaywrightBrowserService: slot {} needs rebuild - consecutiveFailures={}",
                    label(), consecutiveFailures.get());
            return true;
        }
        try {
            return !browser.isConnected();
        } catch (Exception e) {
            return true;
        }
    }

    void scrape(UrlScrapeItemResult result, long timeoutMs) {
        Browser.NewContextOptions ctxOpts = new Browser.NewContextOptions()
                .setUserAgent(USER_AGENT)
                .setViewportSize(1920, 1080)
                .setExtraHTTPHeaders(Collections.singletonMap("Accept-Language", ACCEPT_LANGUAGE));

        BrowserContext browserContext = browser.newContext(ctxOpts);
        Page page = browserContext.newPage();
        try {
            String url = result.getUrl();
            int sizeKb = result.getSize();
            page.setDefaultNavigationTimeout(timeoutMs);
            page.setDefaultTimeout(timeoutMs);

            Response finalResponse = page.navigate(url,
                    new Page.NavigateOptions().setWaitUntil(WaitUntilState.DOMCONTENTLOADED));

            if (finalResponse == null) {
                log.warn("PlaywrightBrowserService: null response for {}", url);
                return;
            }

            int statusCode = finalResponse.status();
            Map<String, String> allHeaders = finalResponse.allHeaders();
            String contentType = "text/html";
            if (allHeaders != null) {
                String ct = allHeaders.get("content-type");
                if (StringUtils.isNotBlank(ct)) {
                    contentType = ct;
                }
            }

            log.info("PlaywrightBrowserService: url={}, status={}, content-type={}", url, statusCode, contentType);

            String baseName = URLUtils.extractFileNameFromURL(url);
            if (StringUtils.startsWithIgnoreCase(contentType, "image/")) {
                // --- Image path ---
                byte[] body = finalResponse.body();
                result.getAttachments().add(buildAttachment(baseName, AttachmentType.IMAGE, body, sizeKb));

            } else {
                // --- Web page path: HTML + screenshot ---
                try {
                    page.waitForLoadState(LoadState.NETWORKIDLE,
                            new Page.WaitForLoadStateOptions().setTimeout(NETWORK_IDLE_TIMEOUT_MS));
                } catch (PlaywrightException e) {
                    log.warn("PlaywrightBrowserService: NETWORKIDLE timeout for {}, proceeding with current DOM", url);
                }

                String html = page.content();
                if (StringUtils.isNotBlank(html)) {
                    byte[] htmlBytes = html.getBytes(StandardCharsets.UTF_8);
                    result.getAttachments().add(buildAttachment(baseName, AttachmentType.TEXT, htmlBytes, sizeKb));
                }

                try {
                    byte[] screenshot = page.screenshot(new Page.ScreenshotOptions()
                            .setType(ScreenshotType.PNG));
                    if (screenshot.length > 0) {
                        String screenshotName = baseName + "-screenshot";
                        result.getAttachments().add(buildAttachment(screenshotName, AttachmentType.IMAGE, screenshot, sizeKb));
                    }
                } catch (PlaywrightException e) {
                    log.warn("PlaywrightBrowserService: screenshot failed for {} - {}", url, e.getMessage());
                }
            }

            log.info("PlaywrightBrowserService: done - url={}, attachments={}", url, result.getAttachments().size());





            consecutiveFailures.set(0);
        } catch (PlaywrightException e) {
            String msg = e.getMessage() == null ? "" : e.getMessage();
            boolean isCrash = IPC_CRASH_PATTERNS.stream().anyMatch(msg::contains);
            if (isCrash) {
                consecutiveFailures.incrementAndGet();
            }
            log.warn("PlaywrightBrowserService: scrape warn on slot {} for {} - {}",
                    label(), result.getUrl(), msg);
        } finally {
            try { page.close(); } catch (Exception e) { log.error("Failed to close page", e); }
            try { browserContext.close(); } catch (Exception e) { log.error("Failed to close context", e); }
        }
    }

    synchronized void rebuild() {
        if (state == SlotState.RUNNING) {
            state = SlotState.CLOSING;
        }
        if (state == SlotState.CLOSING) {
            try {
                close();
                state = SlotState.REBUILDING;
            } catch (Exception e) {
                log.error("PlaywrightBrowserService: slot {} close failed, will retry", label(), e);
                return;
            }
        }
        if (state == SlotState.REBUILDING) {
            try {
                init();
                consecutiveFailures.set(0);
                state = SlotState.RUNNING;
                log.info("PlaywrightBrowserService: slot {} rebuilt successfully", label());
            } catch (Exception e) {
                log.error("PlaywrightBrowserService: slot {} init failed, will retry", label(), e);
            }
        }
    }

    void close() {
        try { browser.close(); } catch (Exception e) { log.warn("Failed to close browser on slot {}", label(), e); }
        playwright.close();
    }
}

/** HTML/图片：MD5 在截断前计算，data 按 sizeKb 截断。 */
private static ScrapeAttachment buildAttachment(String name, AttachmentType type,
                                                byte[] data, int sizeKb) {
    if (data == null) data = new byte[0];
    String md5 = DigestUtils.md5Hex(data);
    int maxBytes = sizeKb * 1024;
    if (data.length > maxBytes) {
        data = Arrays.copyOf(data, maxBytes);
    }
    return new ScrapeAttachment(name, md5, type.getValue(), data);
}

}

[210coder]

top - 14:10:48 up 29 days, 17:24, 0 users, load average: 10.24, 14.53, 17.71
Tasks: 12889 total, 2 running, 1075 sleeping, 0 stopped, 11812 zombie
%Cpu(s): 16.1 us, 5.7 sy, 0.0 ni, 77.0 id, 0.1 wa, 0.0 hi, 1.0 si, 0.1 st
MiB Mem : 201313.5 total, 23696.8 free, 126257.8 used, 51358.9 buff/cache
MiB Swap: 6144.0 total, 6135.8 free, 8.2 used. 68947.0 avail Mem

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND                                                                                                                                                                                                              

524886 root 20 0 1392.0g 210096 148080 S 43.9 0.1 0:01.53 chrome-headless
524813 root 20 0 1392.1g 203900 143744 S 43.6 0.1 0:01.57 chrome-headless
524902 root 20 0 1392.0g 172200 121472 S 34.1 0.1 0:01.21 chrome-headless
181100 root 20 0 48.8g 7.8g 284096 S 27.6 4.0 94:44.73 chrome-headless
181081 root 20 0 48.8g 1.4g 359492 R 24.9 0.7 116:02.55 chrome-headless
180591 root 20 0 2263260 914424 50072 S 16.0 0.4 41:42.78 MainThread
181102 root 20 0 48.4g 492808 93892 S 14.2 0.2 59:25.35 chrome-headless
524876 root 20 0 23880 18396 3144 R 9.8 0.0 0:00.91 top
524944 root 20 0 48.2g 50988 42540 S 4.5 0.0 0:00.15 chrome-headless
1 root 20 0 39.2g 6.8g 22896 S 3.6 3.4 200:22.67 java
182 root 20 0 1582880 211232 49812 S 1.2 0.1 9:41.65 MainThread
253 root 20 0 1501256 141600 49896 S 1.2 0.1 7:55.62 MainThread
281 root 20 0 48.5g 209008 103604 S 0.3 0.1 2:48.09 chrome-headless
508119 root 20 0 1391.9g 92036 76592 S 0.3 0.0 0:00.07 chrome-headless
67 root 20 0 0 0 0 Z 0.0 0.0 67:53.95 chrome-headless
69 root 20 0 0 0 0 Z 0.0 0.0 0:00.02 chrome-headless
70 root 20 0 0 0 0 Z 0.0 0.0 1:44.99 chrome-headless
86 root 20 0 0 0 0 Z 0.0 0.0 52:06.93 chrome-headless
111 root 20 0 0 0 0 Z 0.0 0.0 23:11.79 chrome-headless