تسريب الذاكرة عمدًا في Rust
نظرة على تسريبات الذاكرة المتعمدة في Rust: لماذا توجد الدالة leak في المؤشرات الذكية مثل Box ومتى يستحق استخدامها.
في هذه المقالة سننظر في إدارة الذاكرة وفي كيفية سماح Rust لك بـ“تسريب” الذاكرة عمدًا. أنا حديث العهد نسبيًا بمنظومة Rust، وعندما لاحظت أن نوع مؤشر ذكي مثل Box يأتي مع دالة تسمى leak، تساءلت لماذا توجد وما فائدتها. تمس هذه الآليات موضوعات وحالات استخدام كثيرة أخرى، فاجلس مرتاحًا وتابع القراءة. آمل ألا تطول كثيرًا.
Leak ليست تسريبًا فعليًا للذاكرة، أم هي كذلك؟
إذا كنت مثلي لا تأتي من خلفية برمجة الأنظمة، فمن المرجح أنك تربط مصطلح leaking memory بـ JVM أو ببيئات مُدارة أخرى مثل .NET، حيث تحدث التسريبات عادةً بسبب مراجع غير مقصودة تمنع جامع المهملات من استرداد ذاكرة لم تعد مستخدمة.
مع Box::leak في Rust لا يتسرب شيء حقًا؛ فنحن ببساطة نحوّل Box<T> عمدًا إلى مرجع ساكن قابل للتعديل &'static mut T، مما يمنع تحرير ما يديره Box إلى الأبد.
وبما أننا نحوّله إلى مرجع لا يمكن تحريره بعد الآن، فقد سرّبنا الذاكرة بمعنى ما، تمامًا كما في لغات أخرى. والفارق الوحيد هو القصد: فعلنا ذلك عمدًا، بينما تسريبات الذاكرة العادية غير مرغوب فيها لأنها قد تستنزف موارد النظام بلا داع.
أمثلة على استخدام Box::leak
أثناء البحث في الموضوع، صادفت بعض الطرق المثيرة للاهتمام لاستخدام هذه الدالة. تتعلق الأولى بمشاركة بيانات الإعداد في أنحاء تطبيقك.
مثال إعداد عام (Global config)
use once_cell::sync::OnceCell;
static GLOBAL_CONFIG: OnceCell<&'static AppConfig> = OnceCell::new();
#[derive(Debug)]
struct AppConfig {
database_url: String,
app_mode: String,
}
impl AppConfig {
// Simulates loading a configuration
fn load() -> Self {
AppConfig {
database_url: "https://example.com/mydb".to_string(),
app_mode: "production".to_string(),
}
}
}
fn setup_global_config() {
let config = Box::new(AppConfig::load());
let static_ref = Box::leak(config); // Leak the Box to get a static reference
GLOBAL_CONFIG.set(static_ref).expect("Failed to set global configuration");
}
fn main() {
setup_global_config();
// Access the global configuration
if let Some(config) = GLOBAL_CONFIG.get() {
println!("Database URL: {}", config.database_url);
println!("App Mode: {}", config.app_mode);
}
}
افترض أن تطبيقك يجب أن يصل إلى بيانات محفوظة في AppConfig طوال مدة تشغيله. يمكنك تحقيق ذلك بوضع الإعداد على الكومة (heap) باستخدام Box::new المعتادة ثم تسريبه، مما يحوّله إلى مرجع ساكن قابل للتعديل نمرره إلى OnceCell. وتصبح حقول AppConfig عندئذٍ متاحة تمامًا كما في أي نسخة عادية من هذا النوع. وتعمل هذه المقاربة جيدًا بشكل خاص مع البيانات للقراءة فقط التي تُضبط مرة واحدة ثم تُقرأ كثيرًا في أنحاء التطبيق.
ملاحظة حول OnceCell
يأتي النوع OnceCell من الحزمة المساعدة once_cell ويتيح لك إنشاء قيم تُهيَّأ مرة واحدة بالضبط. وبعد الإنشاء لا يمكن تعديله، لكنه يمنحك طريقة آمنة وفعالة للتعامل مع القيم غير القابلة للتغيير وإرجاء التهيئة حتى الحاجة إليها.
يأتي OnceCell بعدة أنواع:
OnceCell<T>: قيمة تُضبط مرة واحدة، عادةً للتهيئة الكسولة (كما في المثال أعلاه).Lazy<T>: غلاف حولOnceCellللقيم التي تُهيَّأ بشكل كسول عند أول وصول إليها.OnceCellموجود بنسختين: متزامنة (sync) وغير متزامنة (unsync).
استخدام OnceCell بالطريقة الكلاسيكية:
use once_cell::unsync::OnceCell;
fn main() {
let cell = OnceCell::new();
// Set the value
cell.set(42).expect("Value has already been set");
// Access the value
if let Some(value) = cell.get() {
println!("The value is: {}", value);
}
// Trying to set the value again will result in an error
assert!(cell.set(100).is_err());
}
مثال مع Lazy:
use once_cell::sync::Lazy;
// Lazily initialize a static value
static CONFIG: Lazy<String> = Lazy::new(|| {
println!("Initializing configuration...");
"Config data".to_string()
});
fn main() {
// The closure is only executed once, on the first access
println!("CONFIG: {}", *CONFIG);
println!("CONFIG: {}", *CONFIG); // The closure will not run again
}
قد تتساءل الآن لماذا يستخدم مثال الإعداد العام لدينا Box::leak بدلًا من Lazy. والفارق بينهما أن Lazy لا يمكن تهيئته إلا بـ closures وقت الترجمة ولا يستطيع التعامل مع الاعتماديات وقت التشغيل. وعندما يبني برنامجك بنية بيانات معقدة أثناء تشغيله وتريد لاحقًا مشاركتها كمتغير ساكن، فأفضل خيار هو تغليفها في Box وتسريبها إلى مرجع ساكن قابل للتعديل.
تهيئة آمنة للخيوط:
use once_cell::sync::OnceCell;
use std::thread;
static GLOBAL_CONFIG: OnceCell<String> = OnceCell::new();
fn main() {
let handle = thread::spawn(|| {
GLOBAL_CONFIG.set("Config set by thread".to_string()).unwrap();
});
handle.join().unwrap();
println!("Global config: {}", GLOBAL_CONFIG.get().unwrap());
}
وبالحديث عن الخيوط، ذكرت سابقًا أن OnceCell موجود بنسختي sync و unsync، لكن تذكّر أن النسخة sync تفيد أثناء التهيئة فقط: فهي تضمن أن الشيفرة في الـ closure المعطى تعمل مرة واحدة بالضبط عند التهيئة، حتى عند مشاركة عدة خيوط. أما Lazy، من جهة أخرى، فلا تفعل شيئًا لتنسيق الوصول المتزامن إلى القيمة المخزنة، لذا في بيئة متعددة الخيوط عليك التعامل مع ذلك بنفسك. وفي مثالنا يسهل إصلاح ذلك باستخدام Mutex، مثلًا:
use once_cell::sync::Lazy;
use std::sync::Mutex;
struct MySingleton {
// Example fields
pub data: String,
}
// Global singleton instance
static SINGLETON: Lazy<Mutex<MySingleton>> = Lazy::new(|| {
Mutex::new(MySingleton {
data: "Initial data".to_string(),
})
});
fn main() {
// Access the singleton
let singleton = SINGLETON.lock().unwrap();
println!("Singleton data: {}", singleton.data);
}
وبما أننا نناقش OnceCell، فمن الجدير الإشارة إلى خيار آخر من std::sync يسمى Once. هو يشبه OnceCell من الناحية المفاهيمية، لكنه، بخلاف OnceCell، لا يحمل قيمة. يتيح لنا Once تشغيل closure معطى مرة واحدة، لكنه لا يعطي وصولًا إلى ما أنتجه. ويمكن بالطبع الالتفاف على هذا القيد بمتغير ساكن قابل للتعديل، مثلًا:
use std::sync::Once;
static INIT: Once = Once::new();
static mut VALUE: Option<String> = None;
fn main() {
unsafe {
INIT.call_once(|| {
VALUE = Some("Hello, world!".to_string());
});
println!("{}", VALUE.as_ref().unwrap());
}
}
وكما يمكنك أن تخمن الآن على الأرجح، فإن Box::leak مفيدة كلما وجب أن يبقى شيء متاحًا طوال تشغيل البرنامج وكنت بحاجة إلى ضمان ألا تُحرَّر البيانات مبكرًا. وهي تناسب بيانات الإعداد التي تُهيَّأ مرة واحدة ثم تُقرأ، لكن يمكنك أيضًا استخدامها للاحتفاظ بقطعة بيانات عامة ستعدلها لاحقًا. وهذا مفيد لأشياء مثل طابور المهام أو نظام التسجيل (logging)، مثلًا:
struct JobQueue {
jobs: Vec<String>,
}
impl JobQueue {
// Creates a new JobQueue
fn new() -> Self {
JobQueue {
jobs: Vec::new(),
}
}
// Adds a job to the JobQueue
fn add_job(&mut self, job: String) {
self.jobs.push(job);
}
// Displays all jobs in the queue
fn display_jobs(&self) {
for job in &self.jobs {
println!("{}", job);
}
}
}
fn initialize_job_queue() -> &'static JobQueue {
let queue = Box::new(JobQueue::new());
Box::leak(queue)
}
fn main() {
let queue = initialize_job_queue();
// Add some jobs to the queue
unsafe {
let queue_mut = queue as *const JobQueue as *mut JobQueue;
(*queue_mut).add_job("Job 1".to_string());
(*queue_mut).add_job("Job 2".to_string());
}
// Display the jobs
queue.display_jobs();
}
وتساعد Box::leak أيضًا عندما تريد بناء آلية callback بسيطة. فبدلًا من تسريب قطعة بيانات واحدة، نسرّب الـ closure بأكمله، كما هو موضح أدناه:
use std::thread;
fn setup_callback<F: FnOnce() + Send + 'static>(f: F) {
thread::spawn(move || {
// Simulate doing some work...
f(); // Execute the callback
});
}
fn main() {
let my_data = Box::new(|| println!("This is a callback!"));
let static_callback = Box::leak(my_data);
setup_callback(*static_callback);
}
تسريب الذاكرة بما يتجاوز Box::leak
إلى جانب Box::leak المألوفة، توفر Rust عدة طرق أخرى لـ“اختراق” (hack) الذاكرة. وهذه الاختراقات (hacks) أيضًا مضبوطة ومتعمدة، وهي في سلوكها وثيقة الصلة بـ Box::leak.
Rc::into_raw و Arc::into_raw
وهاتان أيضًا غير معتادتين إلى حد ما، على الأقل من وجهة نظري. تحوّل الدالتان into_raw المؤشرات ذات عدّ المراجع (reference counted) أو ذات عدّ المراجع الذري (atomic) إلى مؤشرات خام (raw pointers). تعمل المؤشرات الخام مثل المؤشرات في C و C++ وتمنح وصولًا مباشرًا إلى الذاكرة، متجاوزةً قواعد الاستعارة (borrowing) التي تفرضها Rust عادةً. وهذا مفيد عند التعامل مع شيفرة C وتمرير ملكية مثل هذه البنى إليها. وعند الحاجة، يمكنك استعادة الذاكرة صراحةً وتحويل المؤشرات الخام إلى Rc/Arc مرة أخرى، مثلًا:
use std::rc::Rc;
fn main() {
let data: Rc<i32> = Rc::new(123);
let raw: *const i32 = Rc::into_raw(data);
// Later, convert back to an Rc to avoid memory leak
unsafe {
let reconstructed = Rc::from_raw(raw);
println!("{}", *reconstructed);
// Rc is dropped here, and memory is deallocated
}
}
std::mem و std::ptr
وأخيرًا، بما أننا نتحدث عن التعامل مع C، فإن std::mem و std::ptr تستحقان الذكر. تتيح لك هاتان الوحدتان تخصيص الذاكرة وتحريرها وتعديلها كما تشاء، تمامًا كما في C/C++. لكن عليك أن تكون حذرًا جدًا كي لا تسرّب الذاكرة فعليًا عن طريق الخطأ، وأن تنتبه إلى السلوك غير المعرَّف (undefined behavior).
use std::ptr;
fn main() {
unsafe {
let layout = std::alloc::Layout::from_size_align(1024, 1).unwrap();
let buffer = std::alloc::alloc(layout);
ptr::write(buffer, 42u8); // Example write
println!("{}", *buffer);
// Manually deallocate if needed, or "leak" by never deallocating
std::alloc::dealloc(buffer, layout);
}
}
تسريب البيانات الفعلي في Rust
قد تتساءل الآن هل يمكن أن تسبب Box::leak تسريبًا حقيقيًا للذاكرة في Rust، والجواب نعم. ألقِ نظرة على هذا المثال:
use std::thread;
fn main() {
thread::spawn(|| {
let leaked_data: &'static str = Box::leak(Box::new(String::from("I leak!")));
println!("{}", leaked_data);
})
.join()
.unwrap();
}
عند تشغيل هذا، يُخصَّص النص String “I leak!” على الكومة ويُسرَّب إلى الذاكرة الساكنة عبر Box::leak. والمرجع الناتج إلى تلك الذاكرة الساكنة يوجد فقط ما دام الخيط المنشأ من الخيط الرئيسي حيًا، ويصبح غير قابل للوصول بمجرد إسقاط المرجع (عندما ينتهي الخيط عند join). ونتيجة لذلك، تعيش البيانات أطول من الخيط، لكن لم تعد هناك أي طريقة للوصول إليها.
النقطة الأساسية هي أن Box::leak غيّرت فقط من يملك البيانات التي وضعناها على الكومة بـ Box::new. فالبيانات تبقى فعليًا على الكومة، لكن لها الآن عمرًا 'static ولا يمكن استردادها قبل انتهاء البرنامج، مما يعني أن لدينا تسريب ذاكرة حقيقيًا.