Ho impostato un codice Python per eseguire Selenium chromedriver.exe. Alla fine della corsa devo browser.close()chiudere l'istanza. ( browser = webdriver.Chrome()) Credo che dovrebbe essere rilasciato chromedriver.exedalla memoria (sono su Windows 7). Tuttavia, dopo ogni esecuzione, rimane chromedriver.exeun'istanza in memoria. Spero che ci sia un modo in cui posso scrivere qualcosa in Python per uccidere il chromedriver.exeprocesso. Ovviamente browser.close()non fa il lavoro. Grazie.

per l'API Selenium, dovresti davvero chiamare browser.quit()poiché questo metodo chiuderà tutte le finestre e ucciderà il processo. Dovresti comunque usare browser.quit().

Tuttavia : sul mio posto di lavoro, abbiamo notato un enorme problema durante il tentativo di eseguire i test di chromedriver nella piattaforma Java, dove il chromedriver.exe esiste ancora anche dopo l'uso browser.quit(). Per contrastare questo, abbiamo creato un file batch simile a questo di seguito, che forza la chiusura dei processi.

kill_chromedriver.bat

@echo off
rem   just kills stray local chromedriver.exe instances.
rem   useful if you are trying to clean your project, and your ide is complaining.

taskkill /im chromedriver.exe /f

Poiché chromedriver.exe non è un programma enorme e non consuma molta memoria, non dovresti eseguirlo ogni volta, ma solo quando presenta un problema. Ad esempio, quando si esegue Project-> Clean in Eclipse.

browser.close() chiuderà solo la finestra di Chrome corrente.

browser.quit() dovrebbe chiudere tutte le finestre aperte, quindi uscire da webdriver.

Teoricamente, chiamare browser.Quit chiuderà tutte le schede del browser e terminerà il processo.

Tuttavia, nel mio caso non ero in grado di farlo: poiché eseguivo più test in parallelo, non volevo eseguire un test per chiudere le finestre agli altri. Pertanto, quando i miei test finiscono di essere eseguiti, ci sono ancora molti processi "chromedriver.exe" rimasti in esecuzione.

Per ovviare a questo, ho scritto un semplice codice di pulizia (C #):

Process[] chromeDriverProcesses =  Process.GetProcessesByName("chromedriver");

foreach(var chromeDriverProcess in chromeDriverProcesses)
{
     chromeDriverProcess.Kill();
}

Ho avuto successo durante l'utilizzo driver.close()prima driver.quit(). In precedenza stavo solo usando driver.quit().

//Calling close and then quit will kill the driver running process.


driver.close();

driver.quit();

È un po 'strano ma funziona per me. Ho avuto il problema simile, dopo alcuni scavi ho scoperto che c'era ancora un'azione dell'interfaccia utente in corso nel browser (caricamento dell'URL o giù di lì), quando ho premuto WebDriver.Quit().

La soluzione per me (anche se molto sgradevole) è stata quella di aggiungere Sleep()3 secondi prima di chiamare Quit ().

Questa risposta è come smaltire correttamente il driver in C #

Se vuoi usare un meccanismo "appropriato" da usare per "riordinare" dopo l'esecuzione ChromeDriver , dovresti usare IWebDriver.Dispose();

Esegue attività definite dall'applicazione associate alla liberazione, rilascio o ripristino di risorse non gestite. (Ereditato da IDisposable.)

Di solito implemento IDisposablesulla classe che si occupa diIWebDriver

public class WebDriverController : IDisposable
{
    public IWebDriver Driver;

    public void Dispose()
    {
        this.Driver.Dispose();
    }
}

e usalo come:

using (var controller = new WebDriverController())
{
  //code goes here
}

Spero che questo ti faccia risparmiare tempo

Elimina più processi dalla riga di comando La prima cosa che devi fare è aprire un prompt dei comandi, quindi utilizzare il comando taskkill con la seguente sintassi:

taskkill /F /IM <processname.exe> /T

Questi parametri uccideranno forzatamente qualsiasi processo che corrisponda al nome dell'eseguibile specificato. Ad esempio, per uccidere tutti i processi iexplore.exe, useremmo:

taskkill /F /IM iexplore.exe

Codice c #

using System.Diagnostics;

using System.Management;

        public void KillProcessAndChildren(string p_name)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
          ("Select * From Win32_Process Where Name = '"+ p_name +"'");

        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {

            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch (ArgumentException)
            {
                break;
            }
        }

    }

e questa funzione

        public void KillProcessAndChildren(int pid)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
         ("Select * From Win32_Process Where ParentProcessID=" + pid);
        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {

            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch
            {
                break;
            }
        }

        try
        {
            Process proc = Process.GetProcessById(pid);

            proc.Kill();
        }
        catch (ArgumentException)
        {
            // Process already exited.
        }
    }

Chiamando

                try
            {
                 KillProcessAndChildren("chromedriver.exe");
            }
            catch
            {

            }

Ho avuto lo stesso problema durante l'esecuzione in Python e ho dovuto eseguire manualmente il comando "killall" per terminare tutti i processi. Tuttavia, quando ho implementato il driver utilizzando il protocollo di gestione del contesto Python , tutti i processi erano spariti. Sembra che l'interprete Python faccia un ottimo lavoro nel ripulire le cose.

Ecco l'implementazione:

class Browser:
    def __enter__(self):
        self.options = webdriver.ChromeOptions()
        self.options.add_argument('headless')
        self.driver = webdriver.Chrome(chrome_options=self.options)
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.driver.close()
        self.driver.quit()

E l'utilizzo:

with Browser() as browser:
    browser.navigate_to_page()

Quindi, puoi usare quanto segue:

driver.close()

Chiudi il browser (emula la pressione del pulsante di chiusura)

driver.quit()

Esci dal browser (emula selezionando l'opzione esci)

driver.dispose()

Esci dal browser (prova a chiudere ogni scheda, quindi esci)

Tuttavia, se stai ANCORA riscontrando problemi con istanze sospese (come lo ero io), potresti voler uccidere anche l'istanza. Per fare ciò, è necessario il PID dell'istanza di chrome.

import os
import signal 
driver = webdriver.Chrome()
driver.get(('http://stackoverflow.com'))

def get_pid(passdriver):
    chromepid = int(driver.service.process.pid)
    return (chromepid)

def kill_chrome(thepid)
    try:
        os.kill(pid, signal.SIGTERM)
        return 1
    except:
        return 0

print ("Loaded thing, now I'mah kill it!")
try:
    driver.close()
    driver.quit()
    driver.dispose()
except:
    pass

kill_chrome(chromepid)

Se è rimasta un'istanza di Chrome dopo, mi mangio il cappello. :(

Codice Python:

try:
    # do my automated tasks
except:
    pass
finally:
    driver.close()
    driver.quit()

So che questa è una vecchia domanda, ma ho pensato di condividere ciò che ha funzionato per me. Avevo problemi con Eclipse: non avrebbe ucciso i processi, quindi ho avuto un sacco di processi fantasma in giro dopo aver testato il codice usando il runner Eclipse.

La mia soluzione era eseguire Eclipse come amministratore. Questo ha risolto il problema per me. Sembra che Windows non consentisse a Eclipse di chiudere il processo generato.

Ho usato il seguente in nightwatch.js in afterEach hooks.

afterEach: function(browser, done) {
    // performing an async operation
    setTimeout(function() {
        // finished async duties
        done();
        browser.closeWindow();
        browser.end();
    }, 200);
}

.closeWindow () chiude semplicemente la finestra. (Ma non funzionerà per più finestre aperte). Mentre .end () termina tutti i rimanenti processi chrome.

Ho questo problema. Sospetto che sia dovuto alla versione di Serenity BDD e Selenium. Il processo chromedriver non viene rilasciato fino al termine dell'intera suite di test. Ci sono solo 97 test, ma avere 97 processi che consumano la memoria di un server che non ha molte risorse potrebbe avere un effetto sulle prestazioni.

Per affrontare ho fatto 2 cose (questo è specifico per Windows).

1. prima di ogni test (annotato con @Before) ottieni l'id del processo (PID) del processo chromedriver con:

   List<Integer> pids = new ArrayList<Integer>();
   String out;
   Process p = Runtime.getRuntime().exec("tasklist /FI \"IMAGENAME eq chromedriver.exe*\"");
   BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
   while ((out = input.readLine()) != null) {
       String[] items = StringUtils.split(out, " ");
       if (items.length > 1 && StringUtils.isNumeric(items[1])) {
           pids.add(NumberUtils.toInt(items[1]));
       }
   }
   

2. dopo ogni test (annotato con @After) uccidi il PID con:

   Runtime.getRuntime().exec("taskkill /F /PID " + pid);
   

Sono venuto qui inizialmente pensando che sicuramente questo sarebbe stato risolto / risolto ma dopo aver letto tutte le risposte sono rimasto un po 'sorpreso che nessuno abbia provato a chiamare tutti e tre i metodi insieme:

try
{
    blah
}
catch
{
    blah
}
finally
{
    driver.Close(); // Close the chrome window
    driver.Quit(); // Close the console app that was used to kick off the chrome window
    driver.Dispose(); // Close the chromedriver.exe
}

Ero qui solo per cercare risposte e non intendevo fornirne una. Quindi la soluzione di cui sopra si basa solo sulla mia esperienza. Stavo usando il driver chrome in un'app console C # e sono stato in grado di ripulire i processi in sospeso solo dopo aver chiamato tutti e tre i metodi insieme.

Per gli utenti Ubuntu / Linux: - il comando è o pkillo killall. pkillè generalmente raccomandato, poiché su alcuni sistemi, killallin realtà ucciderà tutti i processi.

Sto usando Goniometro con directConnect. La disabilitazione dell'opzione "--no-sandbox" ha risolto il problema per me.

// Capabilities to be passed to the webdriver instance.
capabilities: {
  'directConnect': true,
  'browserName': 'chrome',
  chromeOptions: {
      args: [
        //"--headless",
        //"--hide-scrollbars",
        "--disable-software-rasterizer",
        '--disable-dev-shm-usage',
        //"--no-sandbox",
        "incognito",
        "--disable-gpu",
        "--window-size=1920x1080"]
  }
},

• Assicurati di ottenere l'istanza del driver come Singleton
• quindi applicare alla fine
• driver.close ()
• driver.quit ()

Nota: ora se vediamo il task manager non troverai alcun driver o processo di Chrome ancora sospeso

Ho esaminato tutte le risposte e le ho testate tutte. Li ho praticamente raccolti tutti in uno come una "chiusura di sicurezza". Questo in c #

NOTA è possibile modificare il parametro dall'app IModule a quello del driver effettivo.

 public class WebDriverCleaner
{

    public static void CloseWebDriver(IModule app)
    {
        try
        {
            if (app?.GetDriver() != null)
            {
                app.GetDriver().Close();
                Thread.Sleep(3000); // Gives time for everything to close before quiting
                app.GetDriver().Quit();
                app.GetDriver().Dispose();
                KillProcessAndChildren("chromedriver.exe"); // One more to make sure we get rid of them chromedrivers.
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }

    public static void KillProcessAndChildren(string p_name)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher
            ("Select * From Win32_Process Where Name = '" + p_name + "'");

        ManagementObjectCollection moc = searcher.Get();
        foreach (ManagementObject mo in moc)
        {
            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch (ArgumentException)
            {
                break;
            }
        }

    }


    public static void KillProcessAndChildren(int pid)
    {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_Process Where ParentProcessID=" + pid);
        ManagementObjectCollection moc = searcher.Get();

        foreach (ManagementObject mo in moc)
        {
            try
            {
                KillProcessAndChildren(Convert.ToInt32(mo["ProcessID"]));
            }
            catch
            {
                break;
            }
        }

        try
        {
            Process proc = Process.GetProcessById(pid);
            proc.Kill();
        }
        catch (ArgumentException)
        {
            // Process already exited.
        }
    }

}

Osservato nella versione 3.141.0:

Se inizializzi il tuo ChromeDriver solo con ChromeOptions, quit () non chiuderà chromedriver.exe.

    ChromeOptions chromeOptions = new ChromeOptions();
    ChromeDriver driver = new ChromeDriver(chromeOptions);
    // .. do stuff ..
    driver.quit()

Se crei e passi un ChromeDriverService, quit () chiuderà chromedriver.exe correttamente.

    ChromeDriverService driverService = ChromeDriverService.CreateDefaultService();
    ChromeOptions chromeOptions = new ChromeOptions();
    ChromeDriver driver = new ChromeDriver(driverService, chromeOptions);
    // .. do stuff ..
    driver.quit()

Uso semplicemente in ogni test un metodo tearDown () come segue e non ho alcun problema.

@AfterTest
public void tearDown() {
    driver.quit();
    driver = null;
}

Dopo essere usciti dall'istanza del driver, cancellala dalla cache con driver = null

Spero che la risposta alla domanda

C'è un altro modo che funziona solo per Windows, ma ora è deprecato. funziona per le versioni precedenti di selenio (funziona sulla versione 3.11.0).

import org.openqa.selenium.os.WindowsUtils;

 WindowsUtils.killByName("chromedriver.exe") // any process name you want

Dovresti applicare chiudi prima che smettere

driver.close()
driver.quit()