【PHP】「Fatal error: Allowed memory size」エラーの原因と解決方法｜メモリ不足を完全解説

この記事でわかること

• エラーメッセージの読み方と意味
• メモリ不足を引き起こす主な原因4パターン
• memory_limit の正しい変更方法（php.ini / .htaccess / ini_set / レンタルサーバー）
• コード最適化によるメモリ削減テクニック（ジェネレータ・ストリーム・チャンク処理）
• WordPress でのメモリ不足対策
• メモリ使用量の調査・プロファイリング方法
• 実務で役立つパターン集（CSV・画像・API・PDF・ログ）

Fatal error: Allowed memory size of 134217728 bytes exhausted (tried to allocate 65536 bytes) in /var/www/html/example.php on line 42

ポイント：バイト数を人間が読みやすい単位に変換する早見表: 134217728 = 128MB、268435456 = 256MB、536870912 = 512MB、1073741824 = 1GB

<?php
// 現在のmemory_limitを確認
echo '現在のmemory_limit: ' . ini_get('memory_limit');
// 出力例: 現在のmemory_limit: 128M

注意：memory_limit = -1 に設定するとメモリ制限が無制限になりますが、本番環境では推奨されません。サーバー全体のメモリを使い切り、他のプロセスに影響を与える可能性があります。

1. PHPスクリプト実行開始
   ↓
2. 変数の宣言、関数の実行ごとにメモリを確保
   ↓
3. 使用メモリが memory_limit に達した
   ↓
4. Fatal error: Allowed memory size exhausted → スクリプト停止

<?php
echo '開始時: ' . memory_get_usage() . " bytes
";

// 1万要素の配列を作成
$array = range(1, 10000);
echo '配列作成後: ' . memory_get_usage() . " bytes
";

// 大きな文字列を作成
$string = str_repeat('A', 1000000);
echo '文字列作成後: ' . memory_get_usage() . " bytes
";

// メモリ解放
unset($array, $string);
echo '解放後: ' . memory_get_usage() . " bytes
";

実行結果

開始時: 393216 bytes
配列作成後: 921600 bytes
文字列作成後: 1921600 bytes
解放後: 393216 bytes

ポイント：例えば100万行のデータを配列に格納すると、1,000,000 × 72 bytes = 約69MBのメモリが必要です。各要素にさらにデータが含まれると、あっという間にメモリ上限に達します。

<?php
// ❌ 500MBのログファイルを一括読み込み → メモリ不足
$content = file_get_contents('/var/log/app/huge-logfile.log');

// ❌ 巨大なJSONファイルを一括読み込み
$json = file_get_contents('large-data.json');
$data = json_decode($json, true);

// ❌ file() も全行を配列に読み込む
$lines = file('/var/log/app/huge-logfile.log');

<?php
// ✅ fopen + fgets で1行ずつ処理
$handle = fopen('/var/log/app/huge-logfile.log', 'r');
if ($handle) {
    while (($line = fgets($handle)) !== false) {
        // 1行ずつ処理（メモリ消費は1行分のみ）
        processLine($line);
    }
    fclose($handle);
}

// ✅ SplFileObject を使う方法
$file = new SplFileObject('/var/log/app/huge-logfile.log');
while (!$file->eof()) {
    $line = $file->fgets();
    processLine($line);
}

<?php
// ❌ 100万レコードを一括取得 → メモリ不足
$pdo = new PDO('mysql:host=localhost;dbname=mydb', 'user', 'pass');
$stmt = $pdo->query('SELECT * FROM huge_table');
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);

foreach ($rows as $row) {
    processRow($row);
}

<?php
// ✅ fetchAll() ではなく fetch() で1行ずつ処理
$pdo = new PDO('mysql:host=localhost;dbname=mydb', 'user', 'pass');

// バッファリングを無効化して省メモリ
$pdo->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);

$stmt = $pdo->query('SELECT * FROM huge_table');
while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    processRow($row);
    // メモリ消費は常に1行分のみ
}

<?php
// ❌ CSVを全行読み込んで配列に格納
$rows = [];
$csv = file('huge-data.csv');
foreach ($csv as $line) {
    $rows[] = str_getcsv($line);
}

// ✅ fgetcsv で1行ずつ処理
$handle = fopen('huge-data.csv', 'r');
$header = fgetcsv($handle); // ヘッダー行

while (($row = fgetcsv($handle)) !== false) {
    // 1行ずつ処理
    $data = array_combine($header, $row);
    insertToDatabase($data);
}
fclose($handle);

<?php
// ❌ 例1: カウンタを増加させ忘れ → 無限ループ
$i = 0;
$results = [];
while ($i < 100) {
    $results[] = fetchData($i);
    // $i++ を忘れている！ → $results が無限に増加
}

// ❌ 例2: 条件が常にtrueになるバグ
$page = 1;
$allData = [];
while ($page > 0) {  // > 0 は常にtrue（$pageは増え続ける）
    $data = fetchPage($page);
    $allData = array_merge($allData, $data);
    $page++;
}

<?php
// ✅ 例1: カウンタを正しく増加
$results = [];
for ($i = 0; $i < 100; $i++) {
    $results[] = fetchData($i);
}

// ✅ 例2: API ページネーションの正しい実装
$page = 1;
$maxPages = 100; // 安全のための上限
$allData = [];
while ($page <= $maxPages) {
    $data = fetchPage($page);
    if (empty($data)) break; // データがなければ終了
    $allData = array_merge($allData, $data);
    $page++;
}

<?php
// ❌ 終了条件が不適切な再帰
function factorial($n) {
    return $n * factorial($n - 1);
    // $n が0以下になっても止まらない
}

// ✅ 正しい終了条件
function factorialSafe($n) {
    if ($n <= 1) return 1;
    return $n * factorialSafe($n - 1);
}

// ✅ 深さ制限付きツリー構築
function buildTree($parentId, $depth = 0, $maxDepth = 10) {
    if ($depth >= $maxDepth) return [];

    $children = getChildren($parentId);
    $tree = [];
    foreach ($children as $child) {
        $child['children'] = buildTree($child['id'], $depth + 1, $maxDepth);
        $tree[] = $child;
    }
    return $tree;
}

// ✅ 再帰をループに書き換え
function factorialIterative($n) {
    $result = 1;
    for ($i = 2; $i <= $n; $i++) {
        $result *= $i;
    }
    return $result;
}

<?php
// ❌ 循環参照の発生
class Node {
    public $children = [];
    public $parent = null;
}

$parent = new Node();
$child = new Node();
$parent->children[] = $child;
$child->parent = $parent;  // 循環参照！

// ✅ 対策1: WeakReference を使う（PHP 7.4+）
class SafeNode {
    public array $children = [];
    public ?WeakReference $parent = null;

    public function setParent(SafeNode $parent): void {
        $this->parent = WeakReference::create($parent);
    }
}

// ✅ 対策2: 手動でガベージコレクションを実行
for ($i = 0; $i < 100000; $i++) {
    // ... 循環参照を含む処理 ...
    if ($i % 1000 === 0) {
        gc_collect_cycles();
    }
}

画像のメモリ使用量の計算式

画像のメモリ使用量 = 幅 × 高さ × チャンネル数（通常4: RGBA）× 係数（約1.7）
例: 4000×3000ピクセルの画像 = 4000 × 3000 × 4 × 1.7 ≒ 約78MB
JPEGのファイルサイズが2MBでも、メモリ上では78MBになります。

<?php
// ✅ 処理前にメモリ必要量をチェック
function checkImageMemory($imagePath) {
    $info = getimagesize($imagePath);
    if (!$info) return false;

    $width = $info[0];
    $height = $info[1];
    $channels = $info['channels'] ?? 4;
    $bits = $info['bits'] ?? 8;

    // 必要メモリ（1.7倍の安全マージン）
    $required = $width * $height * $channels * ($bits / 8) * 1.7;

    $limit = returnBytes(ini_get('memory_limit'));
    $available = $limit - memory_get_usage(true);

    return $required < $available;
}

function returnBytes($val) {
    $val = trim($val);
    $last = strtolower($val[strlen($val) - 1]);
    $val = (int)$val;
    switch ($last) {
        case 'g': $val *= 1024;
        case 'm': $val *= 1024;
        case 'k': $val *= 1024;
    }
    return $val;
}

// 使用例
if (checkImageMemory('huge-photo.jpg')) {
    $image = imagecreatefromjpeg('huge-photo.jpg');
    $resized = imagescale($image, 800, 600);
    imagejpeg($resized, 'resized.jpg');
    imagedestroy($image);
    imagedestroy($resized);
} else {
    echo '画像が大きすぎます。メモリが不足しています。';
}

注意：リサイズ処理では、元画像とリサイズ後の画像の両方がメモリに存在します。上記の約2倍のメモリが必要です。

<?php
// ✅ Imagick拡張を使う
$imagick = new Imagick('huge-photo.jpg');
$imagick->thumbnailImage(800, 600, true);
$imagick->writeImage('resized.jpg');
$imagick->clear();
$imagick->destroy();

// ✅ exec でコマンドライン実行（PHPのメモリを使わない）
$input = escapeshellarg('huge-photo.jpg');
$output = escapeshellarg('resized.jpg');
exec("convert {$input} -resize 800x600 {$output}");

<?php
// ❌ ループ内で配列に追加し続ける
$allResults = [];
for ($page = 1; $page <= 1000; $page++) {
    $data = fetchPageData($page);
    $allResults = array_merge($allResults, $data);
    // $allResults がどんどん大きくなる
}

// ✅ 各ページを処理してすぐ出力/保存
for ($page = 1; $page <= 1000; $page++) {
    $data = fetchPageData($page);
    processAndSave($data);
    // $data はループの次の反復で上書きされる
}

// ✅ array_merge の代わりに [] を使う（メモリ効率が良い）
$results = [];
foreach ($items as $item) {
    // ❌ array_merge は毎回配列全体をコピー
    // $results = array_merge($results, $item);

    // ✅ 直接追加（コピーなし）
    $results[] = $item;
}

<?php
// ❌ 使い終わった巨大データをそのまま保持
$rawData = file_get_contents('data.json');  // 50MB
$parsed = json_decode($rawData, true);       // さらに50MB以上
// $rawData はもう不要だがメモリに残っている
$filtered = filterData($parsed);            // さらにメモリ消費

// ✅ 不要になったらすぐ解放
$rawData = file_get_contents('data.json');
$parsed = json_decode($rawData, true);
unset($rawData);  // 50MB 解放！

$filtered = filterData($parsed);
unset($parsed);   // さらに解放

<?php
// ❌ グローバル変数にデータを蓄積
$GLOBALS['log'] = [];
function addLog($message) {
    $GLOBALS['log'][] = date('Y-m-d H:i:s') . ' ' . $message;
    // ログが際限なく増加
}

// ❌ 静的変数にキャッシュを蓄積
function getCachedData($key) {
    static $cache = [];
    if (!isset($cache[$key])) {
        $cache[$key] = expensiveComputation($key);
    }
    return $cache[$key];
    // キーが多いとキャッシュが膨大に
}

// ✅ キャッシュに上限を設ける
function getCachedDataSafe($key, $maxCacheSize = 1000) {
    static $cache = [];
    if (!isset($cache[$key])) {
        if (count($cache) >= $maxCacheSize) {
            array_shift($cache); // 古いキャッシュを削除
        }
        $cache[$key] = expensiveComputation($key);
    }
    return $cache[$key];
}

; デフォルト値
; memory_limit = 128M

; 256MBに増やす
memory_limit = 256M

; 512MBに増やす
; memory_limit = 512M

# php.ini のパスを確認
$ php --ini
Configuration File (php.ini) Path: /etc/php/8.2/cli
Loaded Configuration File: /etc/php/8.2/cli/php.ini

# または phpinfo() で確認
$ php -i | grep memory_limit
memory_limit => 128M => 128M

ポイント：php.ini を変更した後は、Webサーバー（Apache/Nginx）の再起動が必要です。sudo systemctl restart apache2 または sudo systemctl restart php8.2-fpm

# memory_limit を 256MB に設定
php_value memory_limit 256M

# 特定のディレクトリだけ増やす場合
# そのディレクトリの .htaccess に記述

注意：.htaccess での設定は Apache + mod_php の環境でのみ有効です。PHP-FPM を使用している場合は効きません。

<?php
// スクリプトの先頭で設定
ini_set('memory_limit', '256M');

// 変更が反映されたか確認
echo ini_get('memory_limit'); // 256M

// 一時的に増やして元に戻す
$originalLimit = ini_get('memory_limit');
ini_set('memory_limit', '512M');

// 重い処理を実行
heavyProcess();

// 元に戻す
ini_set('memory_limit', $originalLimit);

注意：共用レンタルサーバーでは ini_set() による memory_limit の変更が禁止されている場合があります。その場合はサーバーの管理パネルから設定します。

1. サーバーパネルにログイン
2. 「php.ini設定」をクリック
3. 対象ドメインを選択
4. 「php.ini設定変更」タブを開く
5. 「memory_limit」の値を変更（例: 256M → 512M）
6. 「確認画面へ進む」→「変更する」

<?php
// ❌ 配列で全データを返す → メモリを大量消費
function getAllRecords(): array {
    $records = [];
    $stmt = $pdo->query('SELECT * FROM users');
    while ($row = $stmt->fetch()) {
        $records[] = $row;
    }
    return $records; // 全レコードがメモリに
}

// ✅ ジェネレータで1件ずつ返す → メモリ一定
function getAllRecordsGenerator(): Generator {
    $stmt = $pdo->query('SELECT * FROM users');
    while ($row = $stmt->fetch()) {
        yield $row; // 1件返して一時停止
    }
}

// 使い方は同じ
foreach (getAllRecordsGenerator() as $record) {
    processRecord($record);
}

<?php
// ✅ CSVをジェネレータで読み込み
function readCsv($filePath): Generator {
    $handle = fopen($filePath, 'r');
    $header = fgetcsv($handle);

    while (($row = fgetcsv($handle)) !== false) {
        yield array_combine($header, $row);
    }

    fclose($handle);
}

// 100万行のCSVでもメモリ消費は一定
foreach (readCsv('million-rows.csv') as $row) {
    insertToDatabase($row);
}

// ✅ ジェネレータの連鎖（パイプライン）
function filterActive(Generator $rows): Generator {
    foreach ($rows as $row) {
        if ($row['status'] === 'active') {
            yield $row;
        }
    }
}

function transformRow(Generator $rows): Generator {
    foreach ($rows as $row) {
        $row['name'] = mb_strtoupper($row['name']);
        yield $row;
    }
}

// パイプラインで連結
$csv = readCsv('users.csv');
$active = filterActive($csv);
$transformed = transformRow($active);

foreach ($transformed as $row) {
    saveToDatabase($row);
}

<?php
// ✅ SplFileObject でオブジェクト指向的にCSV処理
$file = new SplFileObject('huge-data.csv');
$file->setFlags(
    SplFileObject::READ_CSV |
    SplFileObject::SKIP_EMPTY |
    SplFileObject::READ_AHEAD
);

$header = $file->current();
$file->next();

foreach ($file as $row) {
    if (count($row) === count($header)) {
        $data = array_combine($header, $row);
        processRow($data);
    }
}

// ✅ 巨大JSONをストリームパーサーで処理
// JsonMachine ライブラリを使用（composer require halaxa/json-machine）
use JsonMachineItems;

$users = Items::fromFile('huge-data.json', ['pointer' => '/users']);
foreach ($users as $user) {
    // 1件ずつ処理（メモリ消費一定）
    processUser($user);
}

<?php
// ❌ 全件取得 → メモリ不足
$users = User::all();

// ✅ chunk() で1000件ずつ処理
User::chunk(1000, function ($users) {
    foreach ($users as $user) {
        $user->sendNotification();
    }
});

// ✅ lazy() でジェネレータベースの処理（Laravel 8+）
User::lazy()->each(function ($user) {
    $user->sendNotification();
});

// ✅ cursor() で1件ずつフェッチ
foreach (User::cursor() as $user) {
    $user->sendNotification();
}

// ✅ chunkById() でページネーション処理（IDが大きい場合に効率的）
User::chunkById(1000, function ($users) {
    foreach ($users as $user) {
        $user->update(['processed' => true]);
    }
});

<?php
// ✅ 大きなデータを処理したら即座に解放
function processLargeFile($path) {
    $content = file_get_contents($path);
    $data = json_decode($content, true);
    unset($content); // 生データを解放

    $result = transform($data);
    unset($data);    // 変換前データを解放

    return $result;
}

// ✅ ループ内での解放
$files = glob('data/*.json');
foreach ($files as $file) {
    $data = json_decode(file_get_contents($file), true);
    processData($data);
    unset($data); // 各ファイル処理後に解放
}

unset() の注意点

• unset() は変数を削除するだけで、すぐにメモリが解放されるとは限りません（GCのタイミングによる）
• 参照カウントが0になったとき初めてメモリが解放されます
• $var = null; も同様の効果がありますが、unset() の方が意図が明確です

<?php
// ✅ LIMIT/OFFSET で分割取得
$batchSize = 1000;
$offset = 0;

do {
    $stmt = $pdo->prepare('SELECT * FROM orders LIMIT :limit OFFSET :offset');
    $stmt->bindValue(':limit', $batchSize, PDO::PARAM_INT);
    $stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
    $stmt->execute();

    $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
    $count = count($rows);

    foreach ($rows as $row) {
        processOrder($row);
    }

    unset($rows); // バッチ処理後に解放
    $offset += $batchSize;
} while ($count === $batchSize);

注意：OFFSET が大きくなるとパフォーマンスが低下します（MySQLは OFFSET 分のレコードを読み飛ばすため）。大量データの場合は「カーソルベースのページネーション」を使いましょう。

<?php
// ✅ IDベースのカーソルページネーション（高速）
$batchSize = 1000;
$lastId = 0;

do {
    $stmt = $pdo->prepare(
        'SELECT * FROM orders WHERE id > :lastId ORDER BY id ASC LIMIT :limit'
    );
    $stmt->bindValue(':lastId', $lastId, PDO::PARAM_INT);
    $stmt->bindValue(':limit', $batchSize, PDO::PARAM_INT);
    $stmt->execute();

    $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
    $count = count($rows);

    foreach ($rows as $row) {
        processOrder($row);
        $lastId = $row['id'];
    }

    unset($rows);
} while ($count === $batchSize);

<?php
// ❌ SELECT * で全カラム取得（TEXT/BLOBカラムを含むと大量メモリ消費）
$stmt = $pdo->query('SELECT * FROM articles');

// ✅ 必要なカラムだけ取得
$stmt = $pdo->query('SELECT id, title, status FROM articles');

// Laravel の場合
// ❌
$articles = Article::all();

// ✅
$articles = Article::select('id', 'title', 'status')->get();

<?php
// フロントエンド（サイト表示）のメモリ上限
define('WP_MEMORY_LIMIT', '256M');

// 管理画面のメモリ上限（より大きく設定）
define('WP_MAX_MEMORY_LIMIT', '512M');

// ※ これらは wp-settings.php の前に記述すること
// require_once ABSPATH . 'wp-settings.php'; より上

注意：WP_MEMORY_LIMIT は php.ini の memory_limit を超えることはできません。例えば php.ini が 128M なら、WP_MEMORY_LIMIT = '256M' としても 128M のままです。必ず php.ini 側も変更してください。

メモリ消費が大きいプラグインの特定方法:

1. 全プラグインを無効化
2. 1つずつ有効化してメモリ使用量を確認
3. メモリ消費が大きいプラグインを特定

確認方法:
- Query Monitor プラグインを使う
- wp-config.php に以下を追加:
  define('SAVEQUERIES', true);
- フッターにメモリ使用量を表示:
  echo 'メモリ: ' . round(memory_get_peak_usage() / 1024 / 1024, 2) . 'MB';

<?php
// functions.php に追加
add_action('wp_footer', function() {
    if (current_user_can('manage_options')) {
        $mem = round(memory_get_peak_usage() / 1024 / 1024, 2);
        $limit = ini_get('memory_limit');
        $queries = get_num_queries();
        $time = timer_stop(0, 3);
        echo "<!-- Memory: {$mem}MB / {$limit} | Queries: {$queries} | Time: {$time}s -->";
    }
});

<?php
// wp-config.php に追加

// メモリ上限を引き上げ
define('WP_MEMORY_LIMIT', '256M');
define('WP_MAX_MEMORY_LIMIT', '512M');

// 画像編集時のメモリ制限を緩和
// (WordPress は画像アップロード時にサムネイルを自動生成する)

<?php
// 不要なサムネイルサイズを削除（メモリ節約）
add_action('init', function() {
    remove_image_size('1536x1536');
    remove_image_size('2048x2048');
});

// アップロード時の最大画像サイズを制限
add_filter('big_image_size_threshold', function() {
    return 2560; // 最大2560pxにリサイズ
});

<?php
// memory_get_usage() - 現在のメモリ使用量
echo '現在: ' . memory_get_usage() . " bytes
";

// memory_get_usage(true) - OSから割り当てられた実メモリ量
echo '実メモリ: ' . memory_get_usage(true) . " bytes
";

// memory_get_peak_usage() - ピーク（最大）メモリ使用量
echo 'ピーク: ' . memory_get_peak_usage() . " bytes
";

// 人間が読みやすい形式で表示するヘルパー
function formatBytes($bytes, $precision = 2) {
    $units = ['B', 'KB', 'MB', 'GB'];
    $bytes = max($bytes, 0);
    $pow = floor(($bytes ? log($bytes) : 0) / log(1024));
    $pow = min($pow, count($units) - 1);
    return round($bytes / pow(1024, $pow), $precision) . ' ' . $units[$pow];
}

echo formatBytes(memory_get_usage()); // 例: 2.34 MB
echo formatBytes(memory_get_peak_usage()); // 例: 15.67 MB

<?php
class MemoryProfiler {
    private array $checkpoints = [];

    public function checkpoint(string $label): void {
        $this->checkpoints[] = [
            'label' => $label,
            'memory' => memory_get_usage(),
            'peak' => memory_get_peak_usage(),
            'time' => microtime(true),
        ];
    }

    public function report(): void {
        echo str_pad('チェックポイント', 30) . ' | メモリ     | 増減      | ピーク' . "
";
        echo str_repeat('-', 75) . "
";

        $prev = null;
        foreach ($this->checkpoints as $cp) {
            $diff = $prev ? $cp['memory'] - $prev['memory'] : 0;
            $sign = $diff >= 0 ? '+' : '';
            printf(
                '%-30s | %-10s | %s%-8s | %s' . "
",
                $cp['label'],
                $this->format($cp['memory']),
                $sign,
                $this->format($diff),
                $this->format($cp['peak'])
            );
            $prev = $cp;
        }
    }

    private function format($bytes): string {
        return round($bytes / 1024 / 1024, 2) . 'MB';
    }
}

// 使用例
$profiler = new MemoryProfiler();
$profiler->checkpoint('開始');

$data = file_get_contents('large-file.json');
$profiler->checkpoint('ファイル読み込み後');

$parsed = json_decode($data, true);
$profiler->checkpoint('JSONデコード後');

unset($data);
$profiler->checkpoint('生データ解放後');

$profiler->report();

実行結果

チェックポイント                | メモリ     | 増減      | ピーク
---------------------------------------------------------------------------
開始                           | 0.39MB     | +0MB      | 0.39MB
ファイル読み込み後              | 10.39MB    | +10MB     | 10.39MB
JSONデコード後                  | 25.67MB    | +15.28MB  | 25.67MB
生データ解放後                  | 15.67MB    | -10MB     | 25.67MB

; Xdebug 3.x の設定
xdebug.mode = profile
xdebug.output_dir = /tmp/xdebug
xdebug.profiler_output_name = cachegrind.out.%p

; トリガーで有効化（常時有効にしない）
xdebug.start_with_request = trigger
; ブラウザに ?XDEBUG_PROFILE=1 を付けてアクセス

プロファイリング結果の確認ツール:

1. KCacheGrind（Linux）/ QCacheGrind（Windows/Mac）
   - cachegrind.out.* ファイルを開いて視覚的に分析

2. Webgrind（Webブラウザベース）
   - https://github.com/jokkedk/webgrind
   - PHPのWebサーバーで動作

3. Blackfire.io（SaaS）
   - より高度なプロファイリング
   - 本番環境でも使用可能

<?php
// メモリ使用量が上限の80%を超えたら警告
function checkMemoryWarning($threshold = 0.8): void {
    $limit = returnBytes(ini_get('memory_limit'));
    if ($limit === -1) return; // 無制限

    $usage = memory_get_usage(true);
    $ratio = $usage / $limit;

    if ($ratio >= $threshold) {
        $usageMB = round($usage / 1024 / 1024, 1);
        $limitMB = round($limit / 1024 / 1024, 1);
        $pct = round($ratio * 100, 1);
        error_log("WARNING: Memory usage {$usageMB}MB / {$limitMB}MB ({$pct}%)");
    }
}

// ループ内で定期チェック
foreach ($largeDataset as $i => $item) {
    processItem($item);
    if ($i % 100 === 0) {
        checkMemoryWarning();
    }
}

<?php
// ✅ ストリーミングCSVエクスポート
function exportCsvStream(PDO $pdo, string $filename): void {
    // ヘッダーを送信
    header('Content-Type: text/csv; charset=UTF-8');
    header("Content-Disposition: attachment; filename="{$filename}"");
    header('Cache-Control: no-cache');

    // php://output に直接書き込み
    $output = fopen('php://output', 'w');

    // BOM（Excelで文字化けしないように）
    fwrite($output, "xEFxBBxBF");

    // ヘッダー行
    fputcsv($output, ['ID', '名前', 'メール', '登録日']);

    // バッファリング無効化で1行ずつ送信
    $pdo->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
    $stmt = $pdo->query('SELECT id, name, email, created_at FROM users ORDER BY id');

    while ($row = $stmt->fetch(PDO::FETCH_NUM)) {
        fputcsv($output, $row);
    }

    fclose($output);
}

// 使用例（100万行でもメモリ数MBで完了）
exportCsvStream($pdo, 'users-export.csv');

<?php
function batchResizeImages(string $dir, int $maxWidth = 1920): void {
    $files = glob($dir . '/*.{jpg,jpeg,png}', GLOB_BRACE);
    $total = count($files);

    foreach ($files as $i => $file) {
        echo "[" . ($i + 1) . "/{$total}] " . basename($file) . "...";

        // メモリチェック
        if (!checkImageMemory($file)) {
            echo ' SKIPPED (メモリ不足)' . "
";
            continue;
        }

        $info = getimagesize($file);
        if ($info[0] <= $maxWidth) {
            echo ' SKIPPED (既に小さい)' . "
";
            continue;
        }

        // リサイズ実行
        $image = imagecreatefromstring(file_get_contents($file));
        $resized = imagescale($image, $maxWidth);

        // 保存
        $ext = strtolower(pathinfo($file, PATHINFO_EXTENSION));
        if ($ext === 'png') {
            imagepng($resized, $file);
        } else {
            imagejpeg($resized, $file, 85);
        }

        // 即座にメモリ解放
        imagedestroy($image);
        imagedestroy($resized);

        $mem = round(memory_get_usage() / 1024 / 1024, 1);
        echo " DONE (Mem: {$mem}MB)
";
    }
}

<?php
// ✅ APIデータをジェネレータで取得
function fetchAllFromApi(string $baseUrl): Generator {
    $page = 1;
    $maxPages = 1000; // 安全制限

    while ($page <= $maxPages) {
        $url = "{$baseUrl}?page={$page}&per_page=100";
        $response = file_get_contents($url);
        $data = json_decode($response, true);
        unset($response); // 生レスポンスを即解放

        if (empty($data['items'])) break;

        foreach ($data['items'] as $item) {
            yield $item;
        }

        $page++;
        unset($data);
    }
}

// 使用例
foreach (fetchAllFromApi('https://api.example.com/users') as $user) {
    saveUser($user);
}

<?php
// ❌ 全ページを一括生成 → メモリ不足
$mpdf = new MpdfMpdf();
foreach ($allData as $item) {
    $mpdf->WriteHTML(renderTemplate($item));
}

// ✅ テンポラリファイルを使ってページ分割
$mpdf = new MpdfMpdf([
    'tempDir' => '/tmp/mpdf',
]);

// メモリ効率の良い設定
ini_set('memory_limit', '512M');

// チャンクでHTML生成
$chunkSize = 100;
$offset = 0;
$stmt = $pdo->prepare('SELECT * FROM invoices LIMIT :limit OFFSET :offset');

do {
    $stmt->execute([':limit' => $chunkSize, ':offset' => $offset]);
    $rows = $stmt->fetchAll();
    $count = count($rows);

    $html = '';
    foreach ($rows as $row) {
        $html .= renderInvoice($row);
    }
    $mpdf->WriteHTML($html);
    unset($html, $rows);

    $offset += $chunkSize;
} while ($count === $chunkSize);

$mpdf->Output('invoices.pdf', 'D');

<?php
// ✅ ストリーム処理でログ解析
function analyzeLog(string $logPath): array {
    $stats = [
        'total_lines' => 0,
        'errors' => 0,
        'warnings' => 0,
        'error_types' => [],
    ];

    $handle = fopen($logPath, 'r');

    while (($line = fgets($handle)) !== false) {
        $stats['total_lines']++;

        if (strpos($line, 'ERROR') !== false) {
            $stats['errors']++;
            // エラータイプを集計
            if (preg_match('/ERRORs+(w+)/', $line, $m)) {
                $type = $m[1];
                $stats['error_types'][$type] = ($stats['error_types'][$type] ?? 0) + 1;
            }
        } elseif (strpos($line, 'WARNING') !== false) {
            $stats['warnings']++;
        }
    }

    fclose($handle);
    arsort($stats['error_types']);

    return $stats;
}

// 5GBのログファイルでもメモリ数MBで解析可能
$result = analyzeLog('/var/log/app/production.log');
print_r($result);

<?php
use PhpOfficePhpSpreadsheetIOFactory;
use PhpOfficePhpSpreadsheetSettings;
use PhpOfficePhpSpreadsheetCellStringValueBinder;

// ✅ メモリキャッシュを使用（デフォルトはインメモリ）
$cache = new PhpOfficePhpSpreadsheetCollectionMemorySimpleCache3();
Settings::setCache($cache);

// ✅ 読み込みフィルターで必要なセルだけ読む
class ColumnFilter implements PhpOfficePhpSpreadsheetReaderIReadFilter {
    public function readCell($column, $row, $worksheetName = ''): bool {
        // A〜E列のみ読み込み
        return in_array($column, ['A', 'B', 'C', 'D', 'E']);
    }
}

$reader = IOFactory::createReaderForFile('huge-data.xlsx');
$reader->setReadFilter(new ColumnFilter());
$reader->setReadDataOnly(true); // 書式を読まない

$spreadsheet = $reader->load('huge-data.xlsx');

メモリ不足 原因チェックリスト

• 大量データの読み込み: file_get_contents / file() / fetchAll() で巨大データを一括読み込みしていないか？
• 無限ループ: while/for の終了条件は正しいか？カウンタを正しくインクリメントしているか？
• 再帰の深さ: 再帰関数に終了条件はあるか？深さ制限を設けているか？
• 循環参照: オブジェクト同士が互いを参照していないか？
• 画像処理: 大きな画像をGDで直接処理していないか？メモリ見積もりをしているか？
• 配列の肥大化: ループ内で配列にデータを追加し続けていないか？
• 不要な変数: 使い終わった大きなデータを unset() しているか？
• プラグイン（WordPress）: 不要なプラグインを無効化しているか？

Fatal error: Allowed memory size exhausted 発生
│
├─ まず「tried to allocate Y bytes」を確認
│  ├─ Y が小さい（数KB〜数MB）→ 徐々にメモリが増えた → ループ/配列肥大化を疑う
│  └─ Y が大きい（数十MB〜）→ 一発でメモリを食った → 画像処理/巨大ファイル読み込みを疑う
│
├─ 応急処置: memory_limit を増やす
│  ├─ php.ini / .htaccess / ini_set()
│  └─ WordPress: wp-config.php の WP_MEMORY_LIMIT
│
├─ 根本対策: コードを最適化
│  ├─ ファイル読み込み → ストリーム処理（fgets / SplFileObject）
│  ├─ DB大量取得 → fetch() / LIMIT+OFFSET / カーソル
│  ├─ 配列肥大化 → ジェネレータ（yield） / unset()
│  ├─ 画像処理 → メモリ見積もり / Imagick / exec
│  └─ Laravel → chunk() / lazy() / cursor()
│
└─ 調査: memory_get_usage() でボトルネックを特定

この記事のまとめ

• Fatal error: Allowed memory size exhausted は PHPの memory_limit を超えると発生する
• 主な原因は「大量データの一括読み込み」「無限ループ」「画像処理」「配列の肥大化」
• 応急処置として memory_limit を増やせるが、根本的にはコードの最適化が必要
• ジェネレータ（yield）とストリーム処理を活用すれば、データ量に依存しない省メモリなコードが書ける
• WordPressでは WP_MEMORY_LIMIT と WP_MAX_MEMORY_LIMIT を wp-config.php で設定
• memory_get_usage() で計測し、ボトルネックを特定してから対策する