PHP findet Differenzsatz- und große Array-Speicherüberläufe

Bei der PHP-Entwicklung kann es beim Umgang mit großen Arrays leicht zu Speicherproblemen kommen. In diesem Artikel wird erläutert, wie Sie den Array_Diff-Algorithmus verwenden, um die Differenz großer Arrays zu lösen. Darüber hinaus erfahren Sie, wie Sie verschiedene Speicherverwaltungstechniken verwenden, um die Leistung bei der Arbeit mit großen Arrays zu optimieren.

1. Problembeschreibung

Stellen Sie sich ein Szenario vor: Es gibt zwei Arrays, beide sind sehr groß, jedes Array hat 100.000 Elemente. Nun wollen wir den Unterschied zwischen diesen beiden Arrays ermitteln. Einfach ausgedrückt geht es darum, Elemente zu finden, die nur in einem Array vorhanden sind. Das Folgende ist die Code-Implementierung:

<?php
$array1 = array();
$array2 = array();

// 初始化数组1，2，每个数组都有 10 万个元素
for($i=0;$i<1000000;$i++){
    $array1[$i] = $i;
    $array2[$i] = $i+1;
}

// 计算差集
$result = array_diff($array1, $array2);

print_r($result);
?>

Wenn wir den obigen Code ausführen, werden wir feststellen, dass die Seite schnell nicht mehr reagiert, und dann wird ein Fehler gemeldet, der besagt, dass unser PHP-Skript nicht mehr über den zuweisbaren Speicher verfügt. Dies liegt daran, dass das Standardspeicherlimit von PHP 128 MB beträgt, was nicht groß genug ist, um große Arrays zu verarbeiten. Daher müssen Optimierungsalgorithmen oder andere Speicherverwaltungstechniken in Betracht gezogen werden, um dieses Problem zu lösen.

2. Optimierungsalgorithmus

Wenn die Elemente im Array bereits in der richtigen Reihenfolge angeordnet sind, können Sie die Suche mit einem Cursor beschleunigen, was die Laufzeit und den Speicherverbrauch reduzieren kann. Hier ist die Code-Implementierung:

<?php
$array1 = array();
$array2 = array();

// 初始化数组1，2，每个数组都有 10 万个元素
for($i=0;$i<1000000;$i++){
    $array1[$i] = $i;
    $array2[$i] = $i+1;
}

// 排序数组1、2
sort($array1);
sort($array2);

// 初始化游标
$cursor1 = $cursor2 = 0;

// 计算差集
$result = array();
while($cursor1 < count($array1) && $cursor2 < count($array2)){
    if($array1[$cursor1] < $array2[$cursor2]){
        $result[] = $array1[$cursor1];
        $cursor1++;
    }
    elseif($array1[$cursor1] > $array2[$cursor2]){
        $cursor2++;
    }
    else{
        $cursor1++;
        $cursor2++;
    }
}

// 将数组1中剩余的元素添加入结果数组
while($cursor1 < count($array1)){
    $result[] = $array1[$cursor1];
    $cursor1++;
}

print_r($result);
?>

Der obige Code optimiert die Ausführungszeit und macht die Speichernutzung effizienter. Wenn das Array jedoch nicht in Ordnung ist, funktioniert dieser Algorithmus nicht.

3. Verwenden Sie segmentierte Verarbeitungstechnologie

In PHP verbraucht array_diff bei der Verarbeitung großer Arrays sehr viel Speicheraufwand. Der Speichermanager von PHP verwaltet jedoch eine Speicherzuordnungstabelle für jede Speicherzuordnung. Diese Tabelle erkennt die Größe und den Speicherort jeder Speicherzuordnung. Daher können Sie mithilfe der Segmentierungsverarbeitungstechnologie ein großes Array in viele kleine Unterarrays aufteilen und jedes Unterarray separat verarbeiten, um zu vermeiden, dass zu viel Speicherplatz beansprucht wird. Das Folgende ist die Code-Implementierung:

<?php
$array1 = array();
$array2 = array();

// 初始化数组1，2，每个数组都有 10 万个元素
for($i=0;$i<1000000;$i++){
    $array1[$i] = $i;
    $array2[$i] = $i+1;
}

// 分段，每段 10000 个元素
$chunkSize = 10000;
$chunks1 = array_chunk($array1, $chunkSize);
$chunks2 = array_chunk($array2, $chunkSize);

// 计算差集
$result = array();
foreach($chunks1 as $chunk1){
    $temp = array_diff($chunk1, array_merge(...$chunks2));
    $result = array_merge($result,$temp);
}

print_r($result);
?>

Im obigen Code teilen wir das Array in viele Unterarrays der Größe 10000 auf und speichern sie in den Arrays chunks1 und chunks2. Anschließend durchlaufen wir chunks1, berechnen mithilfe von array_diff die Differenz zwischen jedem Subarray und chunks2 und hängen die Ergebnisse an das Ergebnisarray $result an. Schließlich führen wir $result mit dem Endergebnis zusammen.

4. Verwenden Sie Generatoren, um Durchlaufalgorithmen zu simulieren.

Eine andere Möglichkeit, das Speicherproblem großer Arrays zu lösen, besteht darin, den Durchlauf zum Ermitteln der Differenz zwischen zwei Arrays zu simulieren. Mit den Generatoren von PHP können Sie Werte einzeln aus einer Sequenz generieren, anstatt die gesamte Sequenz im Speicher aufzubauen. Das Folgende ist die Code-Implementierung:

<?php
$array1 = array();
$array2 = array();

// 初始化数组1，2，每个数组都有 10 万个元素
for($i=0;$i<1000000;$i++){
    $array1[$i] = $i;
    $array2[$i] = $i+1;
}

// 计算差集
$result = array();
function diff($arr1, $arr2) {
    sort($arr1);
    sort($arr2);
    $i = $j = 0;
    while($i < count($arr1) && $j < count($arr2)) {
        if($arr1[$i] < $arr2[$j]) {
            yield $arr1[$i];
            $i++;
        }
        elseif($arr1[$i] > $arr2[$j]){
            $j++;
        }
        else{
            $i++;
            $j++;
        }
    }
    while($i < count($arr1)) {
        yield $arr1[$i];
        $i++;
    }
}

// 遍历 generator
foreach (diff($array1, $array2) as $value) {
    $result[] = $value;
}

print_r($result);
?>

Im obigen Code definieren wir eine Diff-Funktion, die einen Generator verwendet, um die Durchquerung der Berechnung des Array-Differenzsatzes zu simulieren. Dieser Algorithmus verbraucht weniger Speicher und CPU-Zeit, indem er die Subarrays der Reihe nach sortiert und dann den Cursorvergleich verwendet, um den Unterschied zwischen den beiden Arrays zu ermitteln.

5. Zusammenfassung

Bei der PHP-Entwicklung müssen Sie beim Umgang mit großen Arrays besonders vorsichtig sein, da diese möglicherweise zu viel Speicher beanspruchen und einen Speicherüberlauf verursachen. In diesem Artikel haben wir Techniken wie Algorithmusoptimierung, stückweise Verarbeitungstechniken und Generator-simulierte Traversal-Algorithmen vorgestellt, die zur Verarbeitung großer Arrays verwendet werden können. Welche Methode Sie wählen, hängt von Ihren Anforderungen und Ihrer Umgebung ab. Abhängig von Ihren Anforderungen können Sie unterschiedliche Techniken zur Optimierung Ihres Codes verwenden, um die Codeleistung und Wartbarkeit beim Umgang mit großen Arrays zu verbessern.

Das obige ist der detaillierte Inhalt vonPHP findet Differenzsatz- und große Array-Speicherüberläufe. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!