English
English
In PHP development, using the fetch_object function to retrieve result sets from a database in object form is a very common operation. It allows developers to handle data in an object-oriented way, resulting in cleaner code structure. However, in high-concurrency or long-running scripts, if the object resources returned by fetch_object are not properly managed, it can lead to memory leaks, which can eventually affect system performance or even cause crashes.
This article will explore the working principle of fetch_object, analyze the causes of memory leaks, and provide practical memory management tips to help you write more robust and efficient PHP code.
fetch_object is one of the methods of the mysqli_result class in PHP, used to convert a record from the result set into an object, as shown in the example below:
$mysqli = new mysqli("m66.net", "user", "password", "database");
$result = $mysqli->query("SELECT * FROM users");
<p>while ($obj = $result->fetch_object()) {<br>
echo $obj->username . "<br>";<br>
}<br>
In this case, every time fetch_object is called, it returns a new object instance that holds the data for the current row.
Failure to Release Result Set Resources in Time
If the query result is not released for a long time, mysqli_result will consume a large amount of memory. While PHP will automatically clean up at the end of the script, in long scripts or daemon processes, manual release is necessary.
Creating a Large Number of Objects in Loops Without Timely Destruction
As fetch_object continuously creates new objects, if these objects are referenced externally or stored in arrays without being cleared, memory usage will keep growing.
Complex Object References Preventing Memory from Being Freed
When the objects fetched contain properties that reference other large resources, or when objects reference each other, PHP's garbage collection mechanism may not be able to collect them in time, leading to memory accumulation.
After the query ends, promptly call $result->free() to release the resources and avoid prolonged memory consumption:
$result = $mysqli->query("SELECT * FROM users");
while ($obj = $result->fetch_object()) {
// Process the data
}
$result->free();
If you store the results of fetch_object in an array, explicitly clear the array after processing:
$objects = [];
while ($obj = $result->fetch_object()) {
$objects[] = $obj;
}
// After processing all objects, unset the array
unset($objects);
$result->free();
This can help PHP reclaim memory more quickly.
If you do not need to keep objects long-term, try to release references after processing them within the loop to prevent objects from accumulating.
If memory usage is a concern, consider using fetch_assoc() instead, which returns an array rather than an object, reducing memory usage:
while ($row = $result->fetch_assoc()) {
// Access data via array
}
Although the coding style is different, it is more memory-efficient.
<?php
$mysqli = new mysqli("m66.net", "user", "password", "database");
<p>if ($mysqli->connect_error) {<br>
die("Connection failed: " . $mysqli->connect_error);<br>
}</p>
<p>$result = $mysqli->query("SELECT * FROM users");<br>
if ($result) {<br>
while ($obj = $result->fetch_object()) {<br>
echo "Username: " . $obj->username . "<br>";<br>
// After processing, if you don't store it, release the variable<br>
unset($obj);<br>
}<br>
// Free the result set<br>
$result->free();<br>
} else {<br>
echo "Query failed: " . $mysqli->error;<br>
}</p>
<p>$mysqli->close();<br>
?><br>
fetch_object is very convenient for data operations, but creating a large number of objects can put pressure on memory.
It is important to develop the habit of releasing result sets and destroying objects to prevent memory leaks.
By combining fetch_assoc with appropriate memory management strategies, you can effectively control memory usage in PHP scripts.
For long-running scripts, it is crucial to monitor and manage memory usage carefully.
Mastering these techniques will allow your PHP programs to handle large datasets more efficiently and avoid performance bottlenecks caused by memory leaks.
