Question

我有一个简单的对象，可以生成相同类型的子项。

此对象具有toHTML方法，其执行类似：

$html  = '<div>' . $this->name . '</div>';
$html .= '<ul>';

foreach($this->children as $child)
  $html .= '<li>' . $child->toHTML() . '</li>';

$html .= '</ul>';

return $html;

问题在于，当对象很复杂时，就像很多带孩子的孩子一样，内存使用率会急剧上升。

如果我只是print_r提供此对象的多维数组，我会得到1 MB的内存使用量，但是在我将数组转换为我的对象并执行print $root->toHtml()之后需要10 MB！

我该如何解决这个问题？

====================================

制作了一个类似于我的真实代码（但更小）的简单类：

class obj{
  protected $name;
  protected $children = array();    
  public function __construct($name){
    $this->name = $name;
  }
  public static function build($name, $array = array()){
    $obj = new self($name);
    if(is_array($array)){
      foreach($array as $k => $v)
        $obj->addChild(self::build($k, $v));
    }  
    return $obj;
  }
  public function addChild(self $child){
    $this->children[] = $child;
  }
  public function toHTML(){
    $html  = '<div>' . $this->name . '</div>';
    $html .= '<ul>';
    foreach($this->children as $child)
      $html .= '<li>' . $child->toHTML() . '</li>';
    $html .= '</ul>';

    return $html;    
  }
}

测试：

$big = array_fill(0, 500, true);
$big[5] = array_fill(0, 200, $big);

print_r($big);
// memory_get_peak_usage() shows 0.61 MB

$root = obj::build('root', $big);
// memory_get_peak_usage() shows 18.5 MB wtf lol

print $root->toHTML();
// memory_get_peak_usage() shows 24.6 MB

Answer 1

问题在于你正在缓冲内存中的所有数据，而实际上你并不需要这样做，因为你只是输出数据，而不是实际处理数据。

而不是缓冲内存中的所有内容，如果您只想输出它，您应该将其输出到任何地方：

public function toHTMLOutput($outputStream){
    fwrite($outputStream, '<div>' . $this->name . '</div>';
    fwrite($outputStream, '<ul>');

    foreach($this->children as $child){
      fwrite($outputStream, '<li>');
      $child->toHTMLOutput($outputStream);
      fwrite($outputStream, '</li>');}
    } 

    fwrite($outputStream, '</ul>');
}

$stdout = fopen('php://stdout', 'w');
print $root->toHTMLOutput($stdout);

或者如果要将输出保存到文件

$stdout = fopen('htmloutput.html', 'w');
print $root->toHTMLOutput($stdout);

显然我只是为toHTML()函数实现了它，但是build函数应该采用相同的原则，这可能会导致你跳过一个单独的toHTML函数。

Answer 2

您的阵列中的元素总数略高于100000。

您的数组的每个元素只是一个字节（布尔值），因此对于超过100000个元素，它需要100000bytes~0.1MB

你的每个对象都是~100个字节，它是100 * 100000 = 100000000字节~10MB

但你有~18MB所以这8个来自哪里？

如果您运行此代码

<?php

$c = 0; //we use this to count object isntances

class obj{
  protected $name;
  protected $children = array();    
  public static $c=0;
  public function __construct($name){
    global $c;
    $c++;
    $this->name = $name;
  }

  public static function build($name, $array = array()){
    global $c;
    $b = memory_get_usage();
    $obj = new self($name);
    $diff = memory_get_usage()-$b;
    echo $c . ' diff ' . $diff . '<br />'; //display change in allocated size
    if(is_array($array)){
      foreach($array as $k => $v)
        $obj->addChild(self::build($k, $v));
    }  
    return $obj;
  }
  public function addChild(self $child){
    $this->children[] = $child;
  }
  public function toHTML(){
    $html  = '<div>' . $this->name . '</div>';
    $html .= '<ul>';
    foreach($this->children as $child)
      $html .= '<li>' . $child->toHTML() . '</li>';
    $html .= '</ul>';

    return $html;    
  }
}
$big = array_fill(0, 500, true);
$big[5] = array_fill(0, 200, $big);

$root = obj::build('root', $big);

您会注意到对于创建为的对象，更改是常量而异常第1024，第2048，第4096 ......

我没有关于它的任何文章或手册页的链接，但我的猜测是php保持对数组中每个创建的对象的引用，初始大小为1024.当你使这个数组完整时，它的大小将加倍为新物体腾出空间。

如果您从例如第2048个对象中获取差异，则减去对象的大小（您在其他行中具有的常量值）并除以2048。您将始终在C中获得32 - 标准大小的指针。

因此，对于100000个对象，此数组的大小增加到131072个元素。 131072 * 32 = 4194304B = 4MB

这个计算只是近似的，但我认为它回答了你的问题需要多少记忆。

回答如何保持低内存 - 避免将对象用于大量数据。

显然，对象很好用，但原始数据类型更快更小。

也许您可以使用包含数据的数组的一个对象。如果没有关于此对象的更多信息以及它们需要哪些方法/接口，很难提出任何替代方案

Answer 3

<强>简介

由于您要输出HTML，因此无需间接消耗内存。

这是一个简单的类：

从多维数组构建菜单
内存有效使用Iterator
可写入Socket，Stream，File，array，Iterator等

示例

$it = new ListBuilder(new RecursiveArrayIterator($big));

// Use Echo
$m = memory_get_peak_usage();
$it->display();
printf("%0.5fMB\n", (memory_get_peak_usage() - $m) / (1024 * 1024));

输出

0.03674MB

其他输出接口

$big = array_fill(0, 500, true);
$big[5] = array_fill(0, 200, $big);

简单比较

// Use Echo
$m = memory_get_peak_usage();
$it->display();
$responce['echo'] = sprintf("%0.5fMB\n", (memory_get_peak_usage() - $m) / (1024 * 1024));

// Output to Stream or File eg ( Socket or HTML file)
$m = memory_get_peak_usage();
$it->display(fopen("php://output", "w"));
$responce['stream'] = sprintf("%0.5fMB\n", (memory_get_peak_usage() - $m) / (1024 * 1024));

// Output to ArrayIterator
$m = memory_get_peak_usage();
$it->display($array = new ArrayIterator());
$responce['iterator'] = sprintf("%0.5fMB\n", (memory_get_peak_usage() - $m) / (1024 * 1024));

// Output to Array
$m = memory_get_peak_usage();
$it->display($array = []);
$responce['array'] = sprintf("%0.5fMB\n", (memory_get_peak_usage() - $m) / (1024 * 1024));

echo "\n\nResults \n";
echo json_encode($responce, 128);

输出

Results
{
    "echo": "0.03684MB\n",
    "stream": "0.00081MB\n",
    "iterator": "32.04364MB\n",
    "array": "0.00253MB\n"
}

使用的课程

class ListBuilder extends RecursiveIteratorIterator {
    protected $pad = "\t";
    protected $o;

    public function beginChildren() {
        $this->output("%s<ul>\n", $this->getPad());
    }

    public function endChildren() {
        $this->output("%s</ul>\n", $this->getPad());
    }

    public function current() {
        $this->output("%s<li>%s</li>\n", $this->getPad(1), parent::current());
        return parent::current();
    }

    public function getPad($n = 0) {
        return str_repeat($this->pad, $this->getDepth() + $n);
    }

    function output() {
        $args = func_get_args();
        $format = array_shift($args);
        $var = vsprintf($format, $args);

        switch (true) {
            case $this->o instanceof ArrayIterator :
                $this->o->append($var);
                break;
            case is_array($this->o) || $this->o instanceof ArrayObject :
                $this->o[] = $var;
                break;
            case is_resource($this->o) && (get_resource_type($this->o) === "file" || get_resource_type($this->o) === "stream") :
                fwrite($this->o, $var);
                break;

            default :
                echo $var;
                break;
        }
    }

    function display($output = null) {
        $this->o = $output;
        $this->output("%s<ul>\n", $this->getPad());
        foreach($this as $v) {
        }
        $this->output("%s</ul>\n", $this->getPad());
    }
}

结论

正如您所看到的，使用迭代器进行循环很快但是迭代器或对象中的存储值可能不是那种内存效率。

Answer 4

可能会抓住你的一件事是，由于递归，你可能正在接近堆栈。在这种情况下，创建一个渲染函数可能是有意义的，该函数处理整个树以呈现而不是依赖递归来为您进行渲染。有关此信息的主题，请参阅尾调用递归和尾调用优化。

坚持使用代码的当前结构并避免许多您可能面临的最简单解决方案的资源问题，可能只需将html字符串作为参考传递，如：

class obj{
  protected $name;
  protected $children = array();    
  public function __construct($name){
    $this->name = $name;
  }
  public static function build($name, $array = array()){
    $obj = new self($name);
    if(is_array($array)){
      foreach($array as $k => $v)
        $obj->addChild(self::build($k, $v));
    }  
    return $obj;
  }
  public function addChild(self $child){
    $this->children[] = $child;
  }
  public function toHTML(&$html = ""){
    $html .= '<div>' . $this->name . '</div>';
    $html .= '<ul>';
    foreach($this->children as $child){
      $html .= '<li>';
      $html .= $child->toHTML($html); 
      $html .= '</li>';
    }
    $html .= '</ul>';
  }
}

这将使您在递归调用解析时不会拖拽一堆重复的部分树渲染。

至于树的实际构建，我认为很多内存使用只是玩大数据的价格，你的选项要么渲染而不是建立一个层次模型来渲染（只是渲染输出）而不是构建一个树），或者使用某种缓存策略来缓存对象树的副本或渲染的html的副本，具体取决于数据在您的站点中的使用方式。如果您可以控制入站数据，则可以将相关的缓存密钥添加到该工作流中，以防止缓存过时。

使用分层对象结构时如何保持低内存

4 个答案: