Con la ayuda de dos preguntas anteriores, ahora tengo un raspador HTML que funciona que alimenta la información del producto en una base de datos. Lo que ahora estoy tratando de hacer es mejorar eficientemente envolviendo mi cerebro para que mi raspador funcione conpcntl_fork.

Si divido mi script php5-cli en 10 partes separadas, mejoro el tiempo de ejecución total en un factor importante, así que sé que no estoy vinculado a la E / S ni a la CPU, sino que solo estoy limitado por la naturaleza lineal de mis funciones de raspado.

Usando el código que he improvisado desde múltiples fuentes, tengo esta prueba de trabajo:

<?php
libxml_use_internal_errors(true);
ini_set('max_execution_time', 0); 
ini_set('max_input_time', 0); 
set_time_limit(0);

$hrefArray = array("http://slashdot.org", "http://slashdot.org", "http://slashdot.org", "http://slashdot.org");

function doDomStuff($singleHref,$childPid) {
    $html = new DOMDocument();
    $html->loadHtmlFile($singleHref);

    $xPath = new DOMXPath($html);

    $domQuery = '//div[@id="slogan"]/h2';
    $domReturn = $xPath->query($domQuery);

    foreach($domReturn as $return) {
        $slogan = $return->nodeValue;
        echo "Child PID #" . $childPid . " says: " . $slogan . "\n";
    }
}

$pids = array();
foreach ($hrefArray as $singleHref) {
    $pid = pcntl_fork();

    if ($pid == -1) {
        die("Couldn't fork, error!");
    } elseif ($pid > 0) {
        // We are the parent
        $pids[] = $pid;
    } else {
        // We are the child
        $childPid = posix_getpid();
        doDomStuff($singleHref,$childPid);
        exit(0);
    }
}

foreach ($pids as $pid) {
    pcntl_waitpid($pid, $status);
}

// Clear the libxml buffer so it doesn't fill up
libxml_clear_errors();

Lo que plantea las siguientes preguntas:

1) Dado que mi hrefArray contiene 4 urls, si la matriz contuviera, digamos, 1,000 URL de productos, ¿este código generaría 1,000 procesos secundarios? Si es así, ¿cuál es la mejor manera de limitar la cantidad de procesos para decir 10, y nuevamente 1,000 URL como ejemplo dividen la carga de trabajo infantil en 100 productos por niño (10 x 100).

2) Aprendí que pcntl_fork crea una copia del proceso y todas las variables, clases, etc. Lo que me gustaría hacer es reemplazar mi variable hrefArray con una consulta DOMDocument que construya la lista de productos para raspar y luego los alimente fuera de los procesos secundarios para hacer el procesamiento, por lo que se distribuye la carga entre 10 trabajadores menores.

Mi cerebro me dice que necesito hacer algo como lo siguiente (obviamente, esto no funciona, así que no lo ejecutes):

<?php
libxml_use_internal_errors(true);
ini_set('max_execution_time', 0); 
ini_set('max_input_time', 0); 
set_time_limit(0);
$maxChildWorkers = 10;

$html = new DOMDocument();
$html->loadHtmlFile('http://xxxx');
$xPath = new DOMXPath($html);

$domQuery = '//div[@id=productDetail]/a';
$domReturn = $xPath->query($domQuery);

$hrefsArray[] = $domReturn->getAttribute('href');

function doDomStuff($singleHref) {
    // Do stuff here with each product
}

// To figure out: Split href array into $maxChilderWorks # of workArray1, workArray2 ... workArray10. 
$pids = array();
foreach ($workArray(1,2,3 ... 10) as $singleHref) {
    $pid = pcntl_fork();

    if ($pid == -1) {
        die("Couldn't fork, error!");
    } elseif ($pid > 0) {
        // We are the parent
        $pids[] = $pid;
    } else {
        // We are the child
        $childPid = posix_getpid();
        doDomStuff($singleHref);
        exit(0);
    }
}


foreach ($pids as $pid) {
    pcntl_waitpid($pid, $status);
}

// Clear the libxml buffer so it doesn't fill up
libxml_clear_errors();

Pero lo que no puedo entender es cómo construir mi hrefsArray [] solo en el proceso maestro / padre y alimentarlo al proceso hijo. Actualmente, todo lo que he intentado provoca bucles en los procesos secundarios. Es decir. my hrefsArray se integra en el maestro y en cada proceso secundario posterior.

Estoy seguro de que estoy haciendo todo esto totalmente mal, por lo que agradecería mucho solo un empujón general en la dirección correcta.