Shared State Concurrency এবং Mutex, Arc এর ব্যবহার

Shared State Concurrency (শেয়ারড স্টেট কনকারেন্সি)

Shared State Concurrency হল একটি কনকারেন্ট প্রোগ্রামিং মডেল যেখানে একাধিক থ্রেড একসাথে একটি স্টেট বা ভেরিয়েবলের সাথে কাজ করে। সাধারণত, যখন একাধিক থ্রেড একটি শেয়ারড ভেরিয়েবলের মান পরিবর্তন করতে চেষ্টা করে, তখন ডেটা রেস (data race) এবং অন্যান্য সমস্যা হতে পারে। এসব সমস্যা এড়াতে সিঙ্ক্রোনাইজেশন ব্যবস্থার প্রয়োজন হয়, যাতে নিশ্চিত করা যায় যে শুধুমাত্র একটি থ্রেড একবারে শেয়ারড ডেটাতে কাজ করছে।

রাস্টে শেয়ারড স্টেট কনকারেন্সি সাধারণত Mutex এবং Arc ব্যবহার করে করা হয়। এগুলি সঠিকভাবে থ্রেডের মধ্যে শেয়ারড ডেটা সিঙ্ক্রোনাইজ করার জন্য ব্যবহৃত হয়।

Mutex (মিউটেক্স)

Mutex (Mutual Exclusion) একটি সিঙ্ক্রোনাইজেশন প্রাইমিটিভ যা একাধিক থ্রেডের মধ্যে একটি শেয়ারড রিসোর্সের অ্যাক্সেস নিয়ন্ত্রণ করতে ব্যবহৃত হয়। Mutex নিশ্চিত করে যে শুধুমাত্র একটি থ্রেড একবারে শেয়ারড ডেটার সাথে কাজ করতে পারে। যদি এক থ্রেড মিউটেক্স লক করে, অন্য কোনো থ্রেড সেই রিসোর্সে প্রবেশ করতে পারবে না যতক্ষণ না মিউটেক্সটি আনলক হয়।

Mutex ব্যবহার:

রাস্টে Mutex একটি জেনেরিক টাইপ হিসেবে থাকে, এবং এটি std::sync::Mutex মডিউলে থাকে। মিউটেক্স ব্যবহার করার জন্য আপনাকে প্রথমে এটি লক করতে হবে, এবং লক মুক্তির জন্য এটি unlock করার প্রয়োজন নেই, কারণ মিউটেক্সের লকগুলো ব্লকিং হয়ে থাকে যতক্ষণ না তারা বের হয়ে আসে।

উদাহরণ:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0)); // শেয়ারড ডেটা, যা মিউটেক্স দিয়ে রক্ষা করা হবে
    
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);  // Arc ক্লোন করা হচ্ছে, যাতে এটি শেয়ার করা যায়
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // Mutex লক করা হচ্ছে
            *num += 1;  // ডেটা পরিবর্তন করা হচ্ছে
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap()); // মিউটেক্স আনলক করা এবং ফলাফল প্রিন্ট করা
}

এখানে, Mutex ব্যবহৃত হয়েছে counter ভেরিয়েবলকে রক্ষা করতে, যাতে একাধিক থ্রেড একে একে এই ভেরিয়েবলটি পরিবর্তন করতে পারে। Arc (Atomic Reference Counting) ব্যবহার করা হয়েছে কারণ Mutex একক মালিকানায় থাকে, এবং শেয়ারড মালিকানা নিশ্চিত করার জন্য Arc ব্যবহার করা হয়।

Arc (Atomic Reference Counting)

Arc (Atomic Reference Counting) একটি স্মার্ট পয়েন্টার যা শেয়ারড মালিকানার সিস্টেমের জন্য ব্যবহৃত হয়। এটি থ্রেডের মধ্যে ডেটা শেয়ার করতে ব্যবহৃত হয় যেখানে ডেটা একাধিক থ্রেডের মধ্যে নিরাপদভাবে অ্যাক্সেস করা দরকার। Arc গ্যারান্টি দেয় যে যখন পর্যন্ত সমস্ত থ্রেড ডেটার রেফারেন্সের মালিক থাকবে, ডেটা ডিলিট হবে না।

Arc সাধারণত শেয়ারড স্টেট কনকারেন্সির সাথে ব্যবহৃত হয় এবং এটি মিউটেক্স বা অন্য কোনো সিঙ্ক্রোনাইজেশন প্রাইমিটিভের সাথে কাজ করতে পারে।

Arc এর ব্যবহার:

Arc স্মার্ট পয়েন্টার হিসেবে ডেটাকে শেয়ার করে এবং থ্রেডের মধ্যে এটি সুরক্ষিতভাবে একাধিকবার ব্যবহার করা যায়।

উদাহরণ:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0)); // Arc এবং Mutex ব্যবহার করে শেয়ারড ডেটা তৈরি

    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);  // Arc ক্লোন করা হচ্ছে
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap(); // Mutex লক
            *num += 1; // ডেটা পরিবর্তন
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap()); // শেয়ারড ডেটার চূড়ান্ত মান
}

এখানে, Arc ডেটার মালিকানা একাধিক থ্রেডের মধ্যে শেয়ার করে, এবং Mutex থ্রেডের মধ্যে সিঙ্ক্রোনাইজেশন নিশ্চিত করে। Arc এর মাধ্যমে ডেটার মালিকানা একাধিক থ্রেডের মধ্যে ভাগ করা হলেও, এটি এখনও নিরাপদে সিঙ্ক্রোনাইজ করা হয়।

Mutex এবং Arc এর সমন্বয়

রাস্টে, যখন একাধিক থ্রেড একটি শেয়ারড ডেটাতে কাজ করতে পারে, তখন Arc এবং Mutex একসাথে ব্যবহৃত হয়। Arc স্মার্ট পয়েন্টার ডেটাকে শেয়ার করার জন্য ব্যবহৃত হয়, এবং Mutex ডেটাকে একসাথে একমাত্র থ্রেডের মাধ্যমে অ্যাক্সেস করার জন্য সিঙ্ক্রোনাইজেশন করে।

• Arc: শেয়ারড মালিকানা এবং থ্রেডের মধ্যে ডেটা শেয়ার করতে ব্যবহৃত হয়।
• Mutex: শেয়ারড ডেটার উপর একাধিক থ্রেডের অ্যাক্সেস নিয়ন্ত্রণ করতে ব্যবহৃত হয়।

সমন্বয়ের উদাহরণ:

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3])); // Arc এবং Mutex ব্যবহার করে শেয়ারড ডেটা

    let mut handles = vec![];

    for _ in 0..10 {
        let data = Arc::clone(&data);  // Arc ক্লোন
        let handle = thread::spawn(move || {
            let mut data = data.lock().unwrap(); // Mutex লক
            data.push(1); // ডেটা পরিবর্তন
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final data: {:?}", *data.lock().unwrap()); // শেয়ারড ডেটার চূড়ান্ত অবস্থা
}

এখানে Arc এবং Mutex একসাথে ব্যবহৃত হয়েছে, যেখানে শেয়ারড ডেটার উপর একাধিক থ্রেড কাজ করছে এবং প্রতিটি থ্রেড নিশ্চিত করছে যে শুধুমাত্র একটি থ্রেড একবারে ডেটা অ্যাক্সেস করতে পারবে।

সারাংশ

রাস্টে Shared State Concurrency পরিচালনা করার জন্য Mutex এবং Arc একটি শক্তিশালী কনকারেন্ট প্রোগ্রামিং মডেল তৈরি করে। Mutex ব্যবহার করা হয় শেয়ারড ডেটার একযোগ ব্যবহারের জন্য সিঙ্ক্রোনাইজেশন নিশ্চিত করতে, এবং Arc ব্যবহার করা হয় ডেটাকে একাধিক থ্রেডের মধ্যে শেয়ার করার জন্য। একসাথে, এই দুটি প্রাইমিটিভ শেয়ারড স্টেট কনকারেন্সি সুরক্ষিত এবং কার্যকরীভাবে পরিচালনা করতে সহায়তা করে।