сборщик мусора с ограничением памяти php

Лично я бы сказал немного иначе. Вот шаги, которые я бы сделал:

• Откройте соединение PDO, установите PDO в режим исключения
• Получите список файлов, которые я хочу прочитать
• Создайте класс, который может использовать PDO и список файлов и выполнять вставки
• Подготовьте заявление ОДИН РАЗ, используйте его много раз
• Транзакция Chunk PDO фиксируется до 50 (настраиваемых) вставок - это означает, что каждый 50-й раз, когда я вызываю $ stmt-> execute (), я выполняю фиксацию, которая лучше использует жесткий диск, что делает его быстрее
• Прочтите каждый файл построчно
• Разберите строку и проверьте, действительна ли она
• Если да, добавить в MySQL, если нет - сообщить об ошибке

Теперь я создал 2 класса и пример того, как я буду это делать. Я тестировал только часть чтения, так как я не знаю ни структуру вашей БД, ни то, что делает AUX ().

class ImportFiles
{
    protected $pdo;
    protected $statements;
    protected $transaction = false;
    protected $trx_flush_count = 50; // Commit the transaction at every 50 iterations

    public function __construct(PDO $pdo = null)
    {
        $this->pdo = $pdo;

        $this->stmt = $this->pdo->prepare("INSERT INTO table 
                                                (ID,PAR1,PAR2,PARN)
                                            VALUES 
                                                (?,?,?,?) 
                                            ON DUPLICATE KEY UPDATE ID = VALUES(ID), PAR1 = VALUES(PAR1), PAR2 = VALUES(PAR2), PAR3 = VALUES(PAR3), PARN = VALUES(PARN)");
    }

    public function import($file)
    {
        if($this->isReadable($file))
        {
            $file = new FileParser($file);

            $this->insert($file);
        }
        else
        {
            printf("\nSpecified file is not readable: %s", $file);
        }
    }

    protected function isReadable($file)
    {
        return (is_file($file) && is_readable($file));
    }   

    protected function insert(FileParser $file)
    {
        while($file->read())
        {
            //printf("\nLine %d, value: %s", $file->getLineCount(), $file->getLine());

            $this->insertRecord($file);

            $this->flush($file);
        }

        $this->flush(null);
    }

    // Untested method, no idea whether it does its job or not - might fail
    protected function flush(FileParser $file = null)
    {
        if(!($file->getLineCount() % 50) && !is_null($file))
        {
            if($this->pdo->inTransaction())
            {
                $this->pdo->commit();

                $this->pdo->beginTransaction();
            }
        }
        else
        {
            if($this->pdo->inTransaction())
            {
                $this->pdo->commit();
            }
        }
    }   

    protected function insertRecord(FileParser $file)
    {
        $check_value = $file->getParsedLine(25);

        if(!empty($check_value))
        {
            $values = [ 
                $file->getParsedLine[0],
                $file->getParsedLine[1],
                $file->getParsedLine[2],
                $file->getParsedLine[5]
            ];
        }
        else
        {
            $values = [ 
                $file->getParsedLine[10],
                $file->getParsedLine[11],
                $file->getParsedLine[12],
                $file->getParsedLine[15]
            ];      
        }

        $this->stmt->execute($values);
    }
}

class FileParser
{
    protected $fh;
    protected $lineCount = 0;
    protected $line = null;
    protected $aux;

    public function __construct($file)
    {
        $this->fh = fopen($file, 'r');
    }

    public function read()
    {
        $this->line = fgets($this->fh);

        if($this->line !== false) $this->lineCount++;

        return $this->line;
    }

    public function getLineCount()
    {
        return $this->lineCount;
    }

    public function getLine()
    {
        return $this->line;
    }

    public function getParsedLine($index = null)
    {
        $line = $this->line;

        if(!is_null($line))
        {
            $line = utf8_encode($line);
            $array_line = explode("|", $line);

            //set null values where i neeed
            $aux = $this->getAUX();
            $array_line = $aux->null_value($array_line);

            if(sizeof($array_line) > 32)
            {   
                return is_null($index) ? $array_line : isset($array_line[$index]) ? $array_line[$index] : null;
            }
            else
            {
                throw new \Exception(sprintf("Invalid array size, expected > 32 got: %s", sizeof($array_line)));
            }
        }
        else
        {
            return [];
        }
    }

    protected function getAUX()
    {
        if(is_null($this->aux))
        {
            $this->aux = new AUX();
        }

        return $this->aux;
    }
}

Использование:

$dsn = 'mysql:dbname=testdb;host=127.0.0.1';
$user = 'dbuser';
$password = 'dbpass';

try 
{
    $pdo = new PDO($dsn, $user, $password);

    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    $import = new ImportFiles($pdo);

    $files = ['/usr/local/file1.txt', '/usr/local/file2.txt'];

    foreach($files as $file)
    {
        $import->import($file);
    }

} catch (Exception $e) 
{
    printf("\nError: %s", $e->getMessage());
    printf("\nFile: %s", $e->getFile());
    printf("\nLine: %s", $e->getLine());
}

РЕШЕНО:

Я применил этот подход, возможно, он будет полезен тем, у кого есть аналогичная проблема:

Я открыл диспетчер задач и посмотрел на использование памяти процессами apache и mysql в следующих случаях:

• Пытался читать и обрабатывать файлы без вызова процедур MySql (использование памяти было в порядке)
• Пытался читать, обрабатывать и вставлять в db только файлы с расширением один за другим (все .ext1, все .ext2, ....)
• Отлаживал процедуру с большим объемом памяти, изолирующие функции одна за другой находили проблемную.
• Нашел проблему и решил

Проблема заключалась в том, что я вызвал функцию, передав в качестве параметра подготовленное выражение. Я думал, что после подготовки это будет просто «статический» объект для вызова. Что происходит, так это то, что если вы передаете тот же PS в функции, память увеличивается экспоненциально.

Надеюсь, это кому-то поможет.

До свидания!