blocks|key|1138414|text|是的，你绝对可以从PHP获取refcount。不幸的是，refcount不容易获得，因为它没有内置到PHP中的访问器。没关系，因为我们有PREG！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1138415|<?php
function+refcount($var)
{
++++ob_start();
++++debug_zval_dump($var);
++++$dump+=+ob_get_clean();

++++$matches+=+array();
++++preg_match('/refcount\(([0-9]%2B)/',+$dump,+$matches);

++++$count+=+$matches[1];

++++//3+references+are+added,+including+when+calling+debug_zval_dump()
++++return+$count+-+3;
}
?>|code-block|syntax|javascript|1138416|来源：PHP.net|offset|length|1138417|entityMap|0|LINK|mutability|MUTABLE|url|http://us3.php.net/manual/en/language.references.php^0|0|0|3|7|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Yes, you can definitely get the refcount from PHP. Unfortunately, the refcount isn't easily gotten for it doesn't have an accessor built into PHP. That's ok, because we have PREG!

<pre><code>&lt;?php
function refcount($var)
{
 ob_start();
 debug_zval_dump($var);
 $dump = ob_get_clean();

 $matches = array();
 preg_match('/refcount\(([0-9]+)/', $dump, $matches);

 $count = $matches[1];

 //3 references are added, including when calling debug_zval_dump()
 return $count - 3;
}
?&gt;
</code></pre>

Source: <a href="http://us3.php.net/manual/en/language.references.php" rel="nofollow noreferrer">PHP.net</a>

blocks|key|1138485|text|Sean的debug_zval_dump函数看起来会告诉你引用计数，但实际上，从长远来看，引用计数并不能帮到你。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1138486|您应该考虑使用有界数组作为缓存；如下所示：|1138487|<?php
class+object_cache+{
+++var+$objs+=+array();
+++var+$max_objs+=+1024;+//+adjust+to+fit+your+use+case

+++function+add($obj)+{
++++++$key+=+$obj->getKey();
++++++//+remove+it+from+its+old+position
++++++unset($this->objs[$key]);
++++++//+If+the+cache+is+full,+retire+the+eldest+from+the+front
++++++if+(count($this->objs)+>+$this->max_objs)+{
+++++++++$dead+=+array_shift($this->objs);
+++++++++//+commit+any+pending+changes+to+db/disk
+++++++++$dead->flushToStorage();
++++++}
++++++//+(re-)add+this+item+to+the+end
++++++$this->objs[$key]+=+$obj;
+++}

+++function+get($key)+{
++++++if+(isset($this->objs[$key]))+{
++++++++++$obj+=+$this->objs[$key];
++++++++++//+promote+to+most-recently-used
++++++++++unset($this->objs[$key]);
++++++++++$this->objs[$key]+=+$obj;
++++++++++return+$obj;
++++++}
++++++//+Not+cached;+go+and+get+it
++++++$obj+=+$this->loadFromStorage($key);
++++++if+($obj)+{
++++++++++$this->objs[$key]+=+$obj;
++++++}
++++++return+$obj;
+++}
}|code-block|syntax|javascript|1138488|在这里，getKey()为您想要存储的对象返回一些惟一的id。这依赖于PHP记住插入到其哈希表中的顺序；每次添加新元素时，都会将其逻辑附加到数组中。|1138489|get()函数确保您访问的对象保留在数组的末尾，因此数组的前端将是最近最少使用的元素，当我们确定空间不足时，这是我们想要处理的元素；array_shift()为我们做了这件事。|1138490|这种方法也被称为最近使用的缓存，或MRU缓存，因为它缓存最近使用的项目。这样做的想法是，您更有可能访问最近访问过的项目，因此将它们保留在身边。|1138491|你在这里得到的是控制你所保留的对象的最大数量的能力，并且你不必去查看那些故意难以访问的php实现细节。|1138492|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Sean's debug_zval_dump function looks like it will do the job of telling you the refcount, but really, the refcount doesn't help you in the long run.

You should consider using a bounded array to act as a cache; something like this:

<pre><code>&lt;?php
class object_cache {
 var $objs = array();
 var $max_objs = 1024; // adjust to fit your use case

 function add($obj) {
 $key = $obj-&gt;getKey();
 // remove it from its old position
 unset($this-&gt;objs[$key]);
 // If the cache is full, retire the eldest from the front
 if (count($this-&gt;objs) &gt; $this-&gt;max_objs) {
 $dead = array_shift($this-&gt;objs);
 // commit any pending changes to db/disk
 $dead-&gt;flushToStorage();
 }
 // (re-)add this item to the end
 $this-&gt;objs[$key] = $obj;
 }

 function get($key) {
 if (isset($this-&gt;objs[$key])) {
 $obj = $this-&gt;objs[$key];
 // promote to most-recently-used
 unset($this-&gt;objs[$key]);
 $this-&gt;objs[$key] = $obj;
 return $obj;
 }
 // Not cached; go and get it
 $obj = $this-&gt;loadFromStorage($key);
 if ($obj) {
 $this-&gt;objs[$key] = $obj;
 }
 return $obj;
 }
}
</code></pre>

Here, getKey() returns some unique id for the object that you want to store.
This relies on the fact that PHP remembers the order of insertion into its hash tables; each time you add a new element, it is logically appended to the array.

The get() function makes sure that the objects you access are kept at the end of the array, so the front of the array is going to be least recently used element, and this is the one that we want to dispose of when we decide that space is low; array_shift() does this for us.

This approach is also known as a most-recently-used, or MRU cache, because it caches the most recently used items. The idea is that you are more likely to access the items that you have accessed most recently, so you keep them around.

What you get here is the ability to control the maximum number of objects that you keep around, and you don't have to poke around at the php implementation details that are deliberately difficult to access.

blocks|key|1138544|text|似乎最好的答案仍然是获取引用计数，尽管debug_zval_dump和ob_start太难看了，无法包含在我的应用程序中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1138545|相反，我用refcount()函数编写了一个简单的PHP模块，该函数可在：http://github.com/qix/php_refcount上找到|offset|length|1138546|entityMap|0|LINK|mutability|MUTABLE|url|http://github.com/qix/php_refcount^0|0|11|Y|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

It seems like the best answer was still getting the reference count, although debug_zval_dump and ob_start was too ugly a hack to include in my application.

Instead I coded up a simple PHP module with a refcount() function, available at: <a href="http://github.com/qix/php_refcount" rel="noreferrer">http://github.com/qix/php_refcount</a>

blocks|key|924140|text|我知道这是一个非常古老的问题，但它仍然是搜索结果中的首选，所以我想我应该给你这个问题的“正确”答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|924141|不幸的是，正如你所发现的那样，获取引用计数是一个雷区，但实际上你并不需要它来解决99%25可能需要它的问题。|924142|您真正想要使用的是WeakRef类，非常简单，它包含一个对对象的弱引用，如果没有对该对象的其他引用，则该引用将过期，从而允许垃圾回收器清除该对象。它需要通过PECL安装，但它确实是您在每个PHP安装中都需要的东西。|offset|length|924143|您可以这样使用它(请原谅任何拼写错误)：|924144|class+Cache+{
++++private+$max_size;
++++private+$cache+=+[];
++++private+$expired+=+0;

++++public+function+__construct(int+$max_size+=+1024)+{+$this->max_size+=+$max_size;+}

++++public+function+add(int+$id,+object+$value)+{
++++++++unset($this->cache[$id]);
++++++++$this->cache[$id]+=+new+WeakRef($value);

++++++++if+($this->max_size+>+0)+&&+((count($this->cache)+>+$this->max_size))+{
++++++++++++$this->prune();
++++++++++++if+(count($this->cache)+>+$this->max_size)+{
++++++++++++++++array_shift($this->cache);
++++++++++++}
++++++++}
++++}

++++public+function+get(int+$id)+{+//+?object
++++++++if+(isset($this->cache[$id]))+{
++++++++++++$result+=+$this->cache[$id]->get();
++++++++++++if+($result+===+null)+{
++++++++++++++++//+Prune+if+the+cache+gets+too+empty
++++++++++++++++if+(%2B%2B$this->expired+>+count($this->cache)+/+4)+{
++++++++++++++++++++$this->prune();
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++//+Move+to+the+end+so+it+is+culled+last+if+non-empty
++++++++++++++++unset($this->cache[$id]);
++++++++++++++++$this->cache[$id]+=+$result;
++++++++++++}
++++++++++++return+$result;
++++++++}
++++++++return+null;
++++}

++++protected+function+prune()+{
++++++++$this->cache+=+array_filter($this->cache,+function($value)+{
++++++++++++return+$value->valid();
++++++++});
++++}
}|code-block|syntax|javascript|924145|这是overkill版本，它同时使用弱引用和最大大小(将其设置为-1以禁用它)。基本上，如果它变得太满或太多的结果过期，那么它会修剪缓存中的任何空引用以腾出空间，并且只有在必要时才会删除非空引用。|924146|entityMap|0|LINK|mutability|MUTABLE|url|http://php.net/manual/en/class.weakref.php^0|0|0|9|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@$F|11|G|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|15|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

I know this is a very old issue, but it still came up as a top result in a search so I thought I'd give you the "correct" answer to your problem.

Unfortunately getting the reference count as you've found is a minefield, but in reality you don't need it for 99% of problems that might want it.

What you really want to use is the <a href="http://php.net/manual/en/class.weakref.php" rel="nofollow noreferrer">WeakRef</a> class, quite simply it holds a weak reference to an object, which will expire if there are no other references to the object, allowing it to be cleaned up by the garbage collector. It needs to be installed via PECL, but it really is something you want in every PHP installation.

You would use it like so (please forgive any typos):

<pre><code>class Cache {
 private $max_size;
 private $cache = [];
 private $expired = 0;

 public function __construct(int $max_size = 1024) { $this-&gt;max_size = $max_size; }

 public function add(int $id, object $value) {
 unset($this-&gt;cache[$id]);
 $this-&gt;cache[$id] = new WeakRef($value);

 if ($this-&gt;max_size &gt; 0) &amp;&amp; ((count($this-&gt;cache) &gt; $this-&gt;max_size)) {
 $this-&gt;prune();
 if (count($this-&gt;cache) &gt; $this-&gt;max_size) {
 array_shift($this-&gt;cache);
 }
 }
 }

 public function get(int $id) { // ?object
 if (isset($this-&gt;cache[$id])) {
 $result = $this-&gt;cache[$id]-&gt;get();
 if ($result === null) {
 // Prune if the cache gets too empty
 if (++$this-&gt;expired &gt; count($this-&gt;cache) / 4) {
 $this-&gt;prune();
 }
 } else {
 // Move to the end so it is culled last if non-empty
 unset($this-&gt;cache[$id]);
 $this-&gt;cache[$id] = $result;
 }
 return $result;
 }
 return null;
 }

 protected function prune() {
 $this-&gt;cache = array_filter($this-&gt;cache, function($value) {
 return $value-&gt;valid();
 });
 }
}
</code></pre>

This is the overkill version that uses both weak references and a max size (set it to -1 to disable that). Basically if it gets too full or too many results were expired, then it will prune the cache of any empty references to make space, and only drop non-empty references if it has to for sanity.

blocks|key|924210|text|PHP7.4现在有了WeakReference|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|924211|要知道$obj是否被其他东西引用，您可以使用：|style|CODE|924212|//+1:+create+a+weak+reference+to+the+object
$wr+=+WeakReference::create($obj);

//+2:+unset+our+reference
unset($obj);

//+3:+test+if+the+weak+reference+is+still+valid
$res+=+$wr->get();
if+(!is_null($res))+{
++++//+a+handle+to+the+object+is+still+held+somewhere+else+in+addition+to+$obj
++++$obj+=+$res;
++++unset($res);
}|code-block|syntax|javascript|924213|entityMap|0|LINK|mutability|MUTABLE|url|https://www.php.net/manual/en/class.weakreference.php^0|A|D|0|0|3|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@$A|Z|B|10|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

PHP 7.4 now has <a href="https://www.php.net/manual/en/class.weakreference.php" rel="nofollow noreferrer">WeakReference</a>

To know if <code>$obj</code> is referenced by something else or not, you could use:

<pre><code>// 1: create a weak reference to the object
$wr = WeakReference::create($obj);

// 2: unset our reference
unset($obj);

// 3: test if the weak reference is still valid
$res = $wr-&gt;get();
if (!is_null($res)) {
 // a handle to the object is still held somewhere else in addition to $obj
 $obj = $res;
 unset($res);
}
</code></pre>

I realize the knee-jerk response to this question is that "you dont.", but hear me out.

Basically I am running on an active-record system on a SQL, and in order to prevent duplicate objects for the same database row I keep an 'array' in the factory with each currently loaded object (using an autoincrement 'id' as the key).

The problem is that when I try to process 90,000+ rows through this system on the odd occasion, PHP hits memory issues. This would very easily be solved by running a garbage collect every few hundred rows, but unfortunately since the factory stores a copy of each object - PHP's garbage collection won't free any of these nodes.

The only solution I can think of, is to check if the reference count of the objects stored in the factory is equal to one (i.e. nothing is referencing that class), and if so free them. This would solve my issue, however PHP doesn't have a reference count method? (besides debug_zval_dump, but thats barely usable).

Get the reference count of an object in PHP?

数据库

我意识到对这个问题的下意识反应是“你不会”，但请听我说完。基本上，我在SQL上的活动记录系统上运行，为了防止相同数据库行的重复对象，我在工厂中为每个当前加载的对象保留一个“数组”(使用自动增量“id”作为键)。问题是，当我偶尔尝试通过这个系统处理90,000+行时，PHP遇到了内存问题。这很容易通过每几百行运行一次垃圾...

问在PHP中获取对象的引用计数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在PHP中获取对象的引用计数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在PHP中获取对象的引用计数？
EN