Atomic Classes এবং তাদের ব্যবহার

অ্যাটমিক্স (Atomics) - Web Development

302

Atomics API মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে atomic operations সম্পাদন করতে ব্যবহৃত হয়। এই অপারেশনগুলো thread-safe এবং indivisible, যা একাধিক থ্রেড দ্বারা একই সময়ে একসঙ্গে shared memory পরিচালনা করার সময় ডেটার সঠিকতা বজায় রাখে। JavaScript-এ Atomics API সরাসরি ব্যবহার করা হয়, এবং এটি বিভিন্ন atomic classes (যেমন, Atomics.add(), Atomics.load(), ইত্যাদি) সরবরাহ করে, যা বিশেষভাবে SharedArrayBuffer এবং TypedArray এর উপর কাজ করে।

Atomic Classes এবং তাদের ভূমিকা

Atomic Classes

Atomics API-এর বিভিন্ন ফাংশন বা ক্লাসের মাধ্যমে atomic operations সম্পন্ন করা যায়। প্রতিটি ক্লাস নির্দিষ্ট একটি কাজের জন্য ব্যবহৃত হয়। নিচে এই ক্লাসগুলো এবং তাদের কাজ তুলে ধরা হলো:

১. `Atomics.add()`

একটি নির্দিষ্ট ভ্যালুকে যোগ করার জন্য ব্যবহৃত হয় এবং পুরোনো মানটি রিটার্ন করে।
Signature: Atomics.add(typedArray, index, value)

উদাহরণ:

const sharedBuffer = new SharedArrayBuffer(1024);
const typedArray = new Int32Array(sharedBuffer);

Atomics.store(typedArray, 0, 10); // Index 0 এ 10 সেট
const oldValue = Atomics.add(typedArray, 0, 5); // 5 যোগ
console.log(oldValue); // আউটপুট: 10 (পুরোনো মান)
console.log(Atomics.load(typedArray, 0)); // আউটপুট: 15

২. `Atomics.sub()`

নির্দিষ্ট ভ্যালু বিয়োগ করার জন্য ব্যবহৃত হয় এবং পুরোনো মানটি রিটার্ন করে।
Signature: Atomics.sub(typedArray, index, value)

উদাহরণ:

const oldValue = Atomics.sub(typedArray, 0, 3); // 3 বিয়োগ
console.log(oldValue); // আউটপুট: 15
console.log(Atomics.load(typedArray, 0)); // আউটপুট: 12

৩. `Atomics.load()`

নির্দিষ্ট ইনডেক্স থেকে একটি ভ্যালু পড়ার জন্য ব্যবহৃত হয়।
Signature: Atomics.load(typedArray, index)

উদাহরণ:

const value = Atomics.load(typedArray, 0); // মান পড়া
console.log(value); // আউটপুট: 12

৪. `Atomics.store()`

নির্দিষ্ট ইনডেক্সে একটি ভ্যালু সংরক্ষণ করার জন্য ব্যবহৃত হয়।
Signature: Atomics.store(typedArray, index, value)

উদাহরণ:

Atomics.store(typedArray, 1, 20); // Index 1 এ 20 সংরক্ষণ
console.log(Atomics.load(typedArray, 1)); // আউটপুট: 20

৫. `Atomics.exchange()`

পুরোনো মানটি রিটার্ন করে এবং নির্দিষ্ট ইনডেক্সে একটি নতুন ভ্যালু সেট করে।
Signature: Atomics.exchange(typedArray, index, value)

উদাহরণ:

const oldValue = Atomics.exchange(typedArray, 1, 30);
console.log(oldValue); // আউটপুট: 20 (পুরোনো মান)
console.log(Atomics.load(typedArray, 1)); // আউটপুট: 30

৬. `Atomics.compareExchange()`

যদি নির্দিষ্ট ইনডেক্সের মান expectedValue এর সমান হয়, তাহলে নতুন মান দিয়ে সেট করে।
Signature: Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)

উদাহরণ:

const oldValue = Atomics.compareExchange(typedArray, 1, 30, 50);
console.log(oldValue); // আউটপুট: 30 (পুরোনো মান)
console.log(Atomics.load(typedArray, 1)); // আউটপুট: 50

৭. `Atomics.wait()`

একটি নির্দিষ্ট ভ্যালু পরিবর্তনের জন্য থ্রেডকে অপেক্ষা করায়।
Signature: Atomics.wait(typedArray, index, value, timeout)

উদাহরণ:

const waitStatus = Atomics.wait(typedArray, 0, 12, 1000); // ১২ এর জন্য অপেক্ষা (১ সেকেন্ড)
console.log(waitStatus); // আউটপুট: "ok" বা "timed-out"

৮. `Atomics.notify()`

একটি নির্দিষ্ট সংখ্যক থ্রেডকে জাগিয়ে তোলে।
Signature: Atomics.notify(typedArray, index, count)

উদাহরণ:

const notifyCount = Atomics.notify(typedArray, 0, 1); // ১ থ্রেডকে নোটিফাই
console.log(notifyCount); // আউটপুট: ১

Atomic Classes এর ব্যবহার ক্ষেত্র

১. Thread Synchronization

Atomics API ব্যবহার করে threads এর মধ্যে synchronization বজায় রাখা যায়। উদাহরণস্বরূপ, একাধিক থ্রেড একটি শেয়ার করা মেমোরির উপর কাজ করার সময় Atomics.wait() এবং Atomics.notify() ব্যবহার করা হয়।

২. Shared Memory Management

Atomics API বিশেষভাবে SharedArrayBuffer এর সাথে কাজ করে। এটি একাধিক থ্রেডের মধ্যে ডেটা শেয়ার এবং সমন্বয় সহজ করে।

৩. Low-Level Concurrency Control

Atomics ব্যবহার করে লক-মুক্ত (lock-free) সমান্তরাল প্রোগ্রামিং করা সম্ভব, যা ডেটার সঠিকতা নিশ্চিত করে।

৪. Avoiding Race Conditions

Atomics এর atomic operations Race Condition প্রতিরোধ করে, যেখানে একাধিক থ্রেড ডেটা ম্যানিপুলেট করার সময় ডেটা দুর্নীতি (data corruption) এড়ানো যায়।

উপসংহার

Atomics API এবং তার Atomic Classes মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের ক্ষেত্রে ডেটার নিরাপত্তা এবং নির্ভুলতা নিশ্চিত করে। এটি বিশেষ করে low-level programming এবং parallel computing এর জন্য উপযুক্ত। Atomics এর মাধ্যমে thread-safe এবং indivisible অপারেশন সহজেই সম্পাদন করা যায়।

Content added By

SATT Academy

AtomicInteger:

328

Atomics এবং AtomicInteger মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে atomic operations পরিচালনা করার জন্য ব্যবহৃত হয়। Atomics হল JavaScript-এর একটি API, যা SharedArrayBuffer এবং typed arrays এর উপর কাজ করে। অন্যদিকে, AtomicInteger একটি জাভা (Java) ক্লাস, যা java.util.concurrent.atomic প্যাকেজের অংশ এবং এটি বিশেষভাবে atomic integer operations পরিচালনা করার জন্য ব্যবহৃত হয়।

AtomicInteger কী?

AtomicInteger হল Java-এর একটি ক্লাস যা একটি পূর্ণসংখ্যা (integer) এর মান পরিচালনা করতে atomic অপারেশন প্রদান করে। এটি থ্রেড-সেফ অপারেশন নিশ্চিত করে, অর্থাৎ, একাধিক থ্রেড একই AtomicInteger অবজেক্টের উপর একসঙ্গে কাজ করলেও কোনো ডেটা দুর্নীতি হবে না। এটি মূলত লক-মুক্ত (lock-free) synchronization প্রদান করে।

AtomicInteger এর বৈশিষ্ট্য

Thread-safe Increment/Decrement: ভ্যারিয়েবলের মান বাড়ানো বা কমানোর জন্য থ্রেড-সেফ অপারেশন।
Lock-free: কোনো লক বা মিউটেক্স ছাড়াই ডেটা পরিবর্তন নিশ্চিত করে।
Non-blocking Operations: থ্রেডগুলো একসঙ্গে কাজ করলেও এটি কার্যকরভাবে কাজ করে।
Atomicity: সমস্ত অপারেশন বিভক্ত বা বিভ্রান্ত হয় না, অর্থাৎ প্রতিটি অপারেশন সম্পূর্ণ বা একেবারেই হয় না।

AtomicInteger কনস্ট্রাকশন

AtomicInteger তৈরি করার জন্য নিচের কনস্ট্রাকটর ব্যবহার করা হয়:

AtomicInteger atomicInteger = new AtomicInteger(); // ডিফল্ট মান 0
AtomicInteger atomicIntegerWithInitialValue = new AtomicInteger(10); // প্রাথমিক মান 10

AtomicInteger এর প্রধান মেথডসমূহ

get():
বর্তমান মান রিটার্ন করে।
```
int value = atomicInteger.get();
```
set(int newValue):
একটি নতুন মান সেট করে।
```
atomicInteger.set(20);
```
getAndIncrement():
বর্তমান মান রিটার্ন করে এবং ১ যোগ করে।
```
int value = atomicInteger.getAndIncrement(); // রিটার্ন: পুরানো মান
```
incrementAndGet():
১ যোগ করে এবং নতুন মান রিটার্ন করে।
```
int value = atomicInteger.incrementAndGet(); // রিটার্ন: নতুন মান
```
compareAndSet(int expectedValue, int newValue):
যদি বর্তমান মান expectedValue এর সমান হয়, তবে এটি newValue এ পরিবর্তিত হয়।
```
boolean success = atomicInteger.compareAndSet(10, 15);
```
addAndGet(int delta):
নির্দিষ্ট মান যোগ করে এবং নতুন মান রিটার্ন করে।
```
int value = atomicInteger.addAndGet(5); // রিটার্ন: নতুন মান
```
getAndAdd(int delta):
নির্দিষ্ট মান যোগ করার আগে বর্তমান মান রিটার্ন করে।
```
int value = atomicInteger.getAndAdd(3); // রিটার্ন: পুরানো মান
```

AtomicInteger উদাহরণ

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(10);

        // Get the current value
        System.out.println("Initial Value: " + atomicInteger.get());

        // Increment the value
        System.out.println("After Increment: " + atomicInteger.incrementAndGet());

        // Add 5 and get the new value
        System.out.println("After Adding 5: " + atomicInteger.addAndGet(5));

        // Compare and set
        boolean isUpdated = atomicInteger.compareAndSet(16, 20);
        System.out.println("Compare and Set Success: " + isUpdated);
        System.out.println("Final Value: " + atomicInteger.get());
    }
}

আউটপুট:

Initial Value: 10  
After Increment: 11  
After Adding 5: 16  
Compare and Set Success: true  
Final Value: 20

JavaScript-এর Atomics এবং Java-এর AtomicInteger এর মধ্যে পার্থক্য

বৈশিষ্ট্য	Atomics (JavaScript)	AtomicInteger (Java)
ব্যবহার ক্ষেত্র	SharedArrayBuffer এর ডেটা ম্যানেজমেন্ট।	মাল্টি-থ্রেডেড প্রোগ্রামে atomic integers।
লক প্রয়োজন	লক-মুক্ত synchronization।	লক-মুক্ত synchronization।
ডেটা টাইপ	Typed Arrays (ইনটিজার, ফ্লোট ইত্যাদি)।	শুধুমাত্র integer।
অপারেশন সমর্থন	`add`, `sub`, `or`, `and`, `load`, `store`, ইত্যাদি।	`get`, `set`, `incrementAndGet`, ইত্যাদি।

সারসংক্ষেপ

AtomicInteger জাভা মাল্টি-থ্রেডিংয়ে atomic operations পরিচালনা করার জন্য একটি অত্যন্ত গুরুত্বপূর্ণ ক্লাস।
এটি থ্রেড-সেফ এবং লক-মুক্ত synchronization নিশ্চিত করে।
JavaScript-এর Atomics API একই কাজ করে, তবে এটি শুধুমাত্র SharedArrayBuffer এবং typed arrays এর উপর কাজ করে।
মাল্টি-থ্রেডিংয়ে ডেটা সঠিকতা বজায় রাখতে এবং পারফরম্যান্স বাড়াতে AtomicInteger এবং Atomics উভয়ই গুরুত্বপূর্ণ।

Content added By

SATT Academy

Introduction

305

AtomicInteger হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা atomic operations সাপোর্ট করে। এটি মাল্টি-থ্রেডেড পরিবেশে integer values পরিচালনা করার জন্য ব্যবহৃত হয়, যেখানে একাধিক থ্রেড একই ডেটার উপর কাজ করছে। AtomicInteger এর মাধ্যমে ডেটা সঠিকতা (consistency) নিশ্চিত করা হয়, এবং এটি thread-safe।

AtomicInteger এর বৈশিষ্ট্য

Atomicity: প্রতিটি অপারেশন সম্পূর্ণভাবে "atomic", অর্থাৎ এটি বিভক্ত হয় না।
Thread-Safety: একাধিক থ্রেড একই সময়ে ডেটার উপর কাজ করলেও এটি সঠিকভাবে পরিচালিত হয়।
Lock-Free Mechanism: লক ব্যবহার না করেই ডেটা হস্তান্তর করা হয়, যা পারফরম্যান্স বাড়ায়।
Non-blocking Operations: থ্রেডগুলো ব্লক না হয়েও ডেটা আপডেট করতে পারে।

AtomicInteger কেন প্রয়োজন?

১. Race Condition এড়ানো

মাল্টি-থ্রেডেড পরিবেশে একাধিক থ্রেড যখন একটি সাধারণ integer ভেরিয়েবল ব্যবহার করে, তখন Race Condition হতে পারে। AtomicInteger এই সমস্যা প্রতিরোধ করে।

২. Thread-Safe Increment/Decrement

int বা long ডেটা টাইপের ভেরিয়েবল ম্যানিপুলেশনের সময় সিঙ্ক্রোনাইজেশন প্রয়োজন হয়। কিন্তু AtomicInteger এই অপারেশনগুলো synchronized blocks ছাড়াই নিরাপদে সম্পন্ন করতে পারে।

৩. Performance Optimization

AtomicInteger লক-মুক্ত পদ্ধতি ব্যবহার করে কাজ করায় এটি অনেক দ্রুত কাজ সম্পন্ন করতে পারে।

AtomicInteger ক্লাসের সাধারণ মেথডসমূহ

get()
বর্তমান মান রিটার্ন করে।
set(int newValue)
নতুন মান সেট করে।
getAndSet(int newValue)
পুরোনো মান রিটার্ন করে এবং নতুন মান সেট করে।
incrementAndGet()
মান ১ দ্বারা বৃদ্ধি করে এবং নতুন মান রিটার্ন করে।
getAndIncrement()
বর্তমান মান রিটার্ন করে এবং পরে ১ দ্বারা বৃদ্ধি করে।
decrementAndGet()
মান ১ দ্বারা কমায় এবং নতুন মান রিটার্ন করে।
getAndDecrement()
বর্তমান মান রিটার্ন করে এবং পরে ১ দ্বারা কমায়।
addAndGet(int delta)
নির্দিষ্ট মান যোগ করে এবং নতুন মান রিটার্ন করে।
compareAndSet(int expect, int update)
যদি বর্তমান মান expect এর সমান হয়, তবে এটি update দ্বারা প্রতিস্থাপিত হয়।

উদাহরণ: AtomicInteger ব্যবহার

মাল্টি-থ্রেডিংয়ে সাধারণ integer ভেরিয়েবল ব্যবহার করলে Race Condition

public class RaceConditionExample {
    private static int counter = 0;

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter++; // Race Condition হতে পারে
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter Value: " + counter); // সঠিক মান নাও আসতে পারে
    }
}

AtomicInteger দিয়ে Race Condition সমাধান

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet(); // Thread-safe increment
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter Value: " + counter.get()); // সঠিক মান
    }
}

AtomicInteger ব্যবহার করার সুবিধা

Thread Safety: কোনো সিঙ্ক্রোনাইজেশন প্রয়োজন হয় না।
High Performance: লক-মুক্ত (lock-free) অপারেশন দ্বারা দ্রুত কাজ সম্পন্ন হয়।
Concurrency Control: একাধিক থ্রেডের মধ্যে ডেটার সঠিকতা নিশ্চিত করে।
Flexibility: বিভিন্ন মেথডের মাধ্যমে ডেটা ম্যানিপুলেশন সহজ হয়।

AtomicInteger এবং Synchronized এর তুলনা

ফিচার	AtomicInteger	Synchronized
Thread Safety	নিশ্চিত	নিশ্চিত
Performance	উচ্চ, কারণ লক-মুক্ত	তুলনামূলক ধীর, কারণ লক ব্যবহৃত হয়
Complexity	সহজ এবং ব্যবহারযোগ্য	কোড জটিল হতে পারে
Usage Scope	শুধুমাত্র integer বা numeric ডেটার জন্য	সব ধরনের ডেটার জন্য

AtomicInteger হল মাল্টি-থ্রেডিং পরিবেশে integer ভেরিয়েবল পরিচালনার জন্য একটি কার্যকর পদ্ধতি। এটি লক-মুক্ত, দ্রুত এবং সহজে ব্যবহারযোগ্য, যা ডেটার সঠিকতা এবং পারফরম্যান্স নিশ্চিত করে।

Content added By

SATT Academy

Methods: get(), set(), getAndIncrement(), incrementAndGet(), compareAndSet(), ইত্যাদি

333

Atomics API JavaScript-এ থ্রেড-সেফ অপারেশন করার জন্য বিভিন্ন methods প্রদান করে, যা SharedArrayBuffer এবং typed arrays-এ কাজ করে। Atomics এর এই মেথডগুলো atomic (অখণ্ড) অপারেশন পরিচালনা করতে ব্যবহৃত হয়। এখানে গুরুত্বপূর্ণ কিছু মেথডের বিস্তারিত আলোচনা করা হলো।

Atomics এর গুরুত্বপূর্ণ মেথডসমূহ

১. `Atomics.get(typedArray, index)`

নির্দিষ্ট index থেকে একটি ডেটা রিড করে।
এটি থ্রেড-সেফভাবে কাজ করে, অর্থাৎ, কোনো থ্রেড এর মান পরিবর্তন করার আগে এটি ডেটা রিড করতে পারে।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

typedArray[0] = 42;
const value = Atomics.get(typedArray, 0); // ডেটা রিড
console.log(value); // আউটপুট: 42

২. `Atomics.set(typedArray, index, value)`

নির্দিষ্ট index এ একটি মান সেট করে।
এটি থ্রেড-সেফ পদ্ধতিতে ডেটা আপডেট করতে ব্যবহৃত হয়।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 100); // ডেটা সেট
console.log(typedArray[0]); // আউটপুট: 100

৩. `Atomics.add(typedArray, index, value)`

নির্দিষ্ট index এ একটি মান যোগ করে এবং পুরানো মানটি রিটার্ন করে।
এটি সাধারণত increment বা accumulation করার জন্য ব্যবহৃত হয়।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 10); // প্রাথমিক মান
const oldValue = Atomics.add(typedArray, 0, 5); // 5 যোগ করা
console.log(oldValue); // আউটপুট: 10
console.log(typedArray[0]); // আউটপুট: 15

৪. `Atomics.sub(typedArray, index, value)`

নির্দিষ্ট index থেকে একটি মান বিয়োগ করে এবং পুরানো মানটি রিটার্ন করে।
এটি decrement করার জন্য ব্যবহার করা হয়।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 20);
const oldValue = Atomics.sub(typedArray, 0, 5); // 5 বিয়োগ করা
console.log(oldValue); // আউটপুট: 20
console.log(typedArray[0]); // আউটপুট: 15

৫. `Atomics.increment(typedArray, index)`

নির্দিষ্ট index এ মান ১ দ্বারা বৃদ্ধি করে এবং পুরানো মানটি রিটার্ন করে।
এটি মূলত একটি বিশেষায়িত add() অপারেশন।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 5);
const oldValue = Atomics.add(typedArray, 0, 1); // increment
console.log(oldValue); // আউটপুট: 5
console.log(typedArray[0]); // আউটপুট: 6

৬. `Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)`

যদি নির্দিষ্ট index এর মান expectedValue এর সমান হয়, তবে এটি replacementValue দিয়ে আপডেট করে।
এটি conditional update করতে ব্যবহৃত হয়।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 10);

const oldValue = Atomics.compareExchange(typedArray, 0, 10, 20);
console.log(oldValue); // আউটপুট: 10
console.log(typedArray[0]); // আউটপুট: 20

৭. `Atomics.exchange(typedArray, index, value)`

নির্দিষ্ট index এর পুরানো মানটি রিটার্ন করে এবং নতুন মান দিয়ে আপডেট করে।
এটি ডেটা প্রতিস্থাপনের জন্য ব্যবহার করা হয়।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 50);

const oldValue = Atomics.exchange(typedArray, 0, 100);
console.log(oldValue); // আউটপুট: 50
console.log(typedArray[0]); // আউটপুট: 100

৮. `Atomics.wait(typedArray, index, value, timeout)`

একটি থ্রেডকে অপেক্ষা করায় যতক্ষণ না নির্দিষ্ট index এর মান পরিবর্তিত হয় বা একটি নির্দিষ্ট সময় পেরিয়ে যায়।
এটি synchronization এর জন্য গুরুত্বপূর্ণ।

উদাহরণ:

const buffer = new SharedArrayBuffer(16);
const typedArray = new Int32Array(buffer);

Atomics.set(typedArray, 0, 0);

setTimeout(() => {
    Atomics.store(typedArray, 0, 1);
    Atomics.notify(typedArray, 0); // অপেক্ষা করা থ্রেডকে জাগানো
}, 1000);

Atomics.wait(typedArray, 0, 0); // থ্রেড অপেক্ষা করবে যতক্ষণ না মান পরিবর্তন হয়
console.log("Value updated!");

৯. `Atomics.notify(typedArray, index, count)`

একটি বা একাধিক থ্রেডকে জাগিয়ে তোলে, যারা wait() অবস্থায় রয়েছে।

উপসংহার

Atomics API-র এই মেথডগুলো multithreaded programming-এ shared memory ব্যবস্থাপনার জন্য অপরিহার্য। এগুলো thread-safe operations, synchronization, এবং data consistency নিশ্চিত করতে ব্যবহার করা হয়। বিশেষ করে, add(), compareExchange(), এবং wait() মেথডগুলো মাল্টি-থ্রেডিংয়ে খুব কার্যকর।

Content added By

SATT Academy

AtomicLong:

283

Atomics এবং AtomicLong দুটি পৃথক কনসেপ্ট হলেও তাদের মূল উদ্দেশ্য এক: thread-safe operations নিশ্চিত করা। Atomics সাধারণত JavaScript-এ ব্যবহৃত হয়, যেখানে AtomicLong হল Java এর একটি ক্লাস, যা থ্রেড-সেফ ভাবে লং (long) ডেটা টাইপ পরিচালনা করতে ব্যবহৃত হয়।

AtomicLong কী?

AtomicLong Java এর একটি ক্লাস, যা java.util.concurrent.atomic প্যাকেজে অন্তর্ভুক্ত। এটি লং টাইপের ভ্যারিয়েবলের উপর atomic operations করতে দেয়, যেমন ইনক্রিমেন্ট, ডিক্রিমেন্ট, অথবা ভ্যালু আপডেট।
এটি মাল্টি-থ্রেডেড পরিবেশে race condition এবং data inconsistency এড়াতে ব্যবহার করা হয়।

AtomicLong এর বৈশিষ্ট্য

Thread-safe Operations: মাল্টি-থ্রেডেড এনভায়রনমেন্টে কাজ করার সময় ডেটা সঠিক রাখে।
Non-blocking Algorithms: এটি লক ব্যবহার না করেই ডেটা আপডেট করে।
Performance Optimization: লক-মুক্ত ডেটা ম্যানেজমেন্টের জন্য কার্যকর।
Atomic Methods: ইনক্রিমেন্ট, ডিক্রিমেন্ট, ভ্যালু আপডেট, এবং তুলনা অপারেশন সরবরাহ করে।

AtomicLong এর সাধারণ মেথড

get()
ভ্যালু পড়ার জন্য ব্যবহার করা হয়।

AtomicLong atomicLong = new AtomicLong(0);
System.out.println(atomicLong.get()); // আউটপুট: 0

set(long newValue)
নির্দিষ্ট মান সেট করার জন্য ব্যবহার করা হয়।
```
atomicLong.set(100);
System.out.println(atomicLong.get()); // আউটপুট: 100
```
incrementAndGet()
বর্তমান মান ১ দ্বারা বাড়িয়ে নতুন মান রিটার্ন করে।
```
System.out.println(atomicLong.incrementAndGet()); // আউটপুট: 101
```
getAndIncrement()
বর্তমান মান রিটার্ন করে এবং তারপর সেটি ১ দ্বারা বাড়ায়।
```
System.out.println(atomicLong.getAndIncrement()); // আউটপুট: 101
System.out.println(atomicLong.get()); // আউটপুট: 102
```
addAndGet(long delta)
একটি নির্দিষ্ট মান যোগ করে নতুন মান রিটার্ন করে।
```
System.out.println(atomicLong.addAndGet(10)); // আউটপুট: 112
```
compareAndSet(long expect, long update)
যদি বর্তমান মান expect এর সমান হয়, তবে সেটি update দিয়ে প্রতিস্থাপন করে।
```
if (atomicLong.compareAndSet(112, 200)) {
    System.out.println("Updated successfully!");
}
System.out.println(atomicLong.get()); // আউটপুট: 200
```
getAndSet(long newValue)
বর্তমান মান রিটার্ন করে এবং একটি নতুন মান সেট করে।
```
System.out.println(atomicLong.getAndSet(500)); // আউটপুট: 200
System.out.println(atomicLong.get()); // আউটপুট: 500
```

AtomicLong এর ব্যবহার উদাহরণ

উদাহরণ ১: মাল্টি-থ্রেডেড পরিবেশে AtomicLong ব্যবহার

import java.util.concurrent.atomic.AtomicLong;

public class AtomicLongExample {
    public static void main(String[] args) {
        AtomicLong counter = new AtomicLong(0);

        Runnable incrementTask = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.incrementAndGet();
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter Value: " + counter.get()); // আউটপুট: 2000
    }
}

এই উদাহরণে, AtomicLong ব্যবহার করা হয়েছে counter ভ্যারিয়েবল ম্যানেজ করতে, যা দুইটি থ্রেড একসঙ্গে আপডেট করছে।

AtomicLong এর সুবিধা

Thread-safety: একাধিক থ্রেডের মধ্যে ডেটা ম্যানেজ করার সময় সঠিকতা নিশ্চিত করে।
High Performance: এটি লক-মুক্ত পদ্ধতি ব্যবহার করে ডেটা আপডেট করে।
Simple API: সহজ মেথডের মাধ্যমে কমপ্লেক্স অপারেশন করা যায়।
Race Condition প্রতিরোধ: মাল্টি-থ্রেডিংয়ে ডেটা কনসিস্টেন্সি বজায় রাখে।

AtomicLong এর সীমাবদ্ধতা

Complexity in Large Operations: বড় স্কেলের ডেটা ম্যানেজমেন্টে এটি জটিল হয়ে উঠতে পারে।
Limited Use Cases: শুধুমাত্র লং টাইপের ভ্যারিয়েবলের জন্য কার্যকর।
Memory Overhead: বড় ডেটাসেটের জন্য অতিরিক্ত মেমোরি ব্যবহারের প্রয়োজন হতে পারে।

Atomics বনাম AtomicLong

Atomics (JavaScript)	AtomicLong (Java)
JavaScript এর জন্য ডিজাইন।	Java এর জন্য ব্যবহৃত।
SharedArrayBuffer এবং TypedArray ব্যবহার করে।	লং টাইপ ডেটা ম্যানেজ করে।
Multithreading নয়, Web Workers ব্যবহৃত।	Multithreaded programming।
Low-level API।	High-level abstraction।

AtomicLong মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করার একটি গুরুত্বপূর্ণ টুল। এটি Java-তে ডেটা আপডেটিং এবং ডেটা রেস (race conditions) প্রতিরোধ করতে কার্যকরী।

Content added By

SATT Academy

Introduction

300

AtomicLong হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা atomic operations এর মাধ্যমে একটি long টাইপের ভ্যালুতে কাজ করে। এটি Thread-safe এবং non-blocking অপারেশন করতে পারে, যার মানে হল একাধিক থ্রেড একই সময়ে কাজ করলেও ডেটার সঠিকতা (Consistency) বজায় থাকে।

AtomicLong এর বৈশিষ্ট্য

Atomicity (অখণ্ডতা): AtomicLong এর অপারেশনগুলো atomic হয়, অর্থাৎ অপারেশনটি বিভক্ত হয় না বা অংশত সম্পন্ন হয় না।
Thread-Safe: একাধিক থ্রেড যখন একযোগে AtomicLong অবজেক্টে কাজ করে, তখন এটি কোনো synchronization block বা lock ছাড়াই ডেটার সঠিকতা নিশ্চিত করে।
Non-blocking: এটি লক-ভিত্তিক মেকানিজমের পরিবর্তে CAS (Compare-And-Swap) ব্যবহার করে, যা Deadlock এবং Livelock এর ঝুঁকি কমায়।
High Performance: Traditional synchronization method এর চেয়ে দ্রুত।

AtomicLong কেন প্রয়োজন?

মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে, একাধিক থ্রেড একসঙ্গে একটি ভ্যারিয়েবল ম্যানিপুলেট করতে চায়। যেমন একটি counter বাড়ানো বা কমানো। সাধারণ long ভ্যারিয়েবলে কাজ করার সময় Race Condition হতে পারে, যা inconsistent result দেয়।

AtomicLong ব্যবহার করে এই সমস্যার সমাধান করা যায়, কারণ এটি atomic operations সরবরাহ করে, যেমন:

incrementAndGet()
getAndIncrement()
compareAndSet()
addAndGet()

AtomicLong কিভাবে কাজ করে?

AtomicLong মূলত Compare-And-Swap (CAS) মেকানিজম ব্যবহার করে। এটি তিনটি ধাপ অনুসরণ করে:

বর্তমান মান পড়া।
নতুন মান গণনা করা।
বর্তমান মানটি প্রত্যাশিত মানের সাথে মিললে নতুন মান সেট করা।

যদি মানটি প্রত্যাশিত না হয়, তবে অপারেশনটি পুনরাবৃত্তি হয় যতক্ষণ না এটি সফল হয়।

AtomicLong ক্লাসের গুরুত্বপূর্ণ মেথড

get(): বর্তমান মান রিটার্ন করে।
set(long newValue): একটি নতুন মান সেট করে।
incrementAndGet(): মান ১ বাড়িয়ে নতুন মান রিটার্ন করে।
getAndIncrement(): বর্তমান মান রিটার্ন করে এবং তারপর ১ বাড়ায়।
compareAndSet(long expectedValue, long newValue): যদি বর্তমান মান expectedValue হয়, তবে এটি newValue এ আপডেট হয় এবং সফল হলে true রিটার্ন করে।
addAndGet(long delta): নির্দিষ্ট মান delta যোগ করে নতুন মান রিটার্ন করে।

উদাহরণ: AtomicLong এর ব্যবহার

import java.util.concurrent.atomic.AtomicLong;

public class AtomicLongExample {
    public static void main(String[] args) {
        // AtomicLong অবজেক্ট তৈরি
        AtomicLong atomicLong = new AtomicLong(100);

        // বর্তমান মান রিড
        System.out.println("Initial Value: " + atomicLong.get()); // আউটপুট: 100

        // মান ১ বাড়ানো
        long incrementedValue = atomicLong.incrementAndGet();
        System.out.println("After Increment: " + incrementedValue); // আউটপুট: 101

        // নির্দিষ্ট মান যোগ করা
        long addedValue = atomicLong.addAndGet(50);
        System.out.println("After Adding 50: " + addedValue); // আউটপুট: 151

        // Compare-And-Set
        boolean isUpdated = atomicLong.compareAndSet(151, 200);
        System.out.println("Compare-And-Set Success: " + isUpdated); // আউটপুট: true
        System.out.println("Updated Value: " + atomicLong.get()); // আউটপুট: 200
    }
}

AtomicLong এর সুবিধা

Concurrency Management: মাল্টি-থ্রেডেড অ্যাপ্লিকেশন ডেভেলপমেন্টে ডেটা সঠিকতা বজায় রাখে।
High Performance: Traditional locking mechanisms এর চেয়ে দ্রুত কাজ করে।
Simpler Code: Synchronization block বা lock ব্যবহারের প্রয়োজন হয় না।
Safe Operations: Race condition এবং inconsistent data এড়ানো যায়।

AtomicLong এর সীমাবদ্ধতা

CAS Overhead: Compare-And-Swap অপারেশন পুনরাবৃত্তি করলে পারফরম্যান্স কিছুটা প্রভাবিত হতে পারে।
Complex Scenarios: জটিল লজিকের জন্য অতিরিক্ত synchronization প্রয়োজন হতে পারে।
Single Variable Scope: এটি শুধুমাত্র একক long টাইপের ডেটার উপর কাজ করতে পারে।

AtomicLong হল মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে Thread-safe increment/decrement counters এবং অন্যান্য atomic operations পরিচালনার জন্য একটি আদর্শ সমাধান। এটি বিশেষ করে উচ্চ-পারফরম্যান্স অ্যাপ্লিকেশন, যেমন logging systems, counters, এবং multi-threaded utilities তৈরিতে ব্যবহৃত হয়।

Content added By

SATT Academy

Methods: addAndGet(), getAndAdd(), getAndDecrement(), ইত্যাদি

353

AtomicLong হল Java এর একটি ক্লাস, যা java.util.concurrent.atomic প্যাকেজের অন্তর্গত। এটি একটি thread-safe mutable long ভ্যালু প্রদান করে এবং atomic operations (অখণ্ড অপারেশন) সম্পাদনের জন্য ব্যবহৃত হয়। অর্থাৎ, একাধিক থ্রেড একসঙ্গে এই ক্লাসের মেথড ব্যবহার করলেও ডেটার সঠিকতা নিশ্চিত থাকে।

AtomicLong এর সাধারণ মেথডসমূহ

addAndGet(long delta)

বর্ণনা:
delta মানটি বর্তমান মানের সাথে যোগ করে এবং নতুন মানটি রিটার্ন করে।
ব্যবহার: এটি এমন ক্ষেত্রে ব্যবহার করা হয় যেখানে ভ্যালু আপডেট করার পরে তার বর্তমান মান জানতে হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
long result = atomicLong.addAndGet(5); // 10 + 5 = 15
System.out.println(result); // আউটপুট: 15

getAndAdd(long delta)

বর্ণনা:
এটি বর্তমান মানটি রিটার্ন করে এবং তারপর delta মানটি বর্তমান মানে যোগ করে।
ব্যবহার: যেখানে আগের মানের প্রয়োজন হয় এবং তারপরে মান পরিবর্তন করতে হয়, সেক্ষেত্রে এটি কার্যকর।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
long result = atomicLong.getAndAdd(5); // আগের মান রিটার্ন করবে: 10
System.out.println(result); // আউটপুট: 10
System.out.println(atomicLong.get()); // নতুন মান: 15

getAndDecrement()

বর্ণনা:
বর্তমান মানটি রিটার্ন করে এবং তারপর এক (1) বিয়োগ করে।
ব্যবহার: ভ্যালু কমানোর সময় পূর্বের মানের অ্যাক্সেস প্রয়োজন হলে এটি ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
long result = atomicLong.getAndDecrement(); // আগের মান রিটার্ন: 10
System.out.println(result); // আউটপুট: 10
System.out.println(atomicLong.get()); // নতুন মান: 9

decrementAndGet()

বর্ণনা:
এটি প্রথমে বর্তমান মান থেকে এক (1) বিয়োগ করে এবং তারপর নতুন মানটি রিটার্ন করে।
ব্যবহার: যেখানে পরিবর্তনের পরে নতুন মান প্রয়োজন, সেখানে এটি ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
long result = atomicLong.decrementAndGet(); // নতুন মান: 9
System.out.println(result); // আউটপুট: 9

get()

বর্ণনা:
এটি বর্তমান মানটি রিটার্ন করে।
ব্যবহার:
বর্তমান মান অ্যাক্সেস করতে ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
System.out.println(atomicLong.get()); // আউটপুট: 10

set(long newValue)

বর্ণনা:
এটি বর্তমান মানকে একটি নির্দিষ্ট মান দিয়ে সেট করে।
ব্যবহার:
বর্তমান মানকে রিসেট করতে ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
atomicLong.set(20);
System.out.println(atomicLong.get()); // আউটপুট: 20

compareAndSet(long expect, long update)

বর্ণনা:
যদি বর্তমান মানটি expect এর সমান হয়, তবে এটি update মান দিয়ে সেট করে এবং true রিটার্ন করে। অন্যথায়, কিছুই পরিবর্তন করে না এবং false রিটার্ন করে।
ব্যবহার:
ডেটার উপর নির্দিষ্ট শর্ত আরোপ করে তা আপডেট করতে ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
boolean success = atomicLong.compareAndSet(10, 20); // বর্তমান মান 10 হলে 20 সেট করবে
System.out.println(success); // আউটপুট: true
System.out.println(atomicLong.get()); // আউটপুট: 20

getAndSet(long newValue)

বর্ণনা:
এটি বর্তমান মানটি রিটার্ন করে এবং নতুন মান সেট করে।
ব্যবহার:
পূর্বের মান ধরে রেখে নতুন মান আপডেট করতে ব্যবহৃত হয়।

উদাহরণ:

AtomicLong atomicLong = new AtomicLong(10);
long oldValue = atomicLong.getAndSet(30); // আগের মান: 10
System.out.println(oldValue); // আউটপুট: 10
System.out.println(atomicLong.get()); // নতুন মান: 30

AtomicLong ব্যবহার করার সুবিধা

Thread Safety: একাধিক থ্রেড ডেটা পরিবর্তন করলেও ডেটার সঠিকতা বজায় থাকে।
Atomic Operations: প্রতিটি অপারেশন অবিভাজ্য (indivisible) এবং বাধাহীন (non-blocking)।
Concurrency Optimization: সিঙ্ক্রোনাইজেশন (synchronization) ছাড়াই ডেটা পরিচালনা করতে সাহায্য করে।

উপসংহার

AtomicLong এমন একটি ক্লাস যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটা আপডেট করার সময় ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করে। এর মেথডগুলো ডেটা ম্যানিপুলেশনের ক্ষেত্রে লক-মুক্ত অপারেশন সরবরাহ করে, যা পারফরম্যান্স অপটিমাইজেশনে সহায়ক।

Content added By

SATT Academy

AtomicBoolean:

310

AtomicBoolean হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা boolean ডেটার উপর atomic (অখণ্ড) অপারেশন পরিচালনা করতে ব্যবহৃত হয়। এটি একাধিক থ্রেডের মধ্যে boolean ডেটা শেয়ার করার সময় thread safety নিশ্চিত করে।

এই ক্লাসটি ব্যবহার করে boolean ভ্যালু পড়া, লেখা, এবং আপডেট করা যায়, যেখানে প্রতিটি অপারেশন atomic হয়। অর্থাৎ, একটি অপারেশন চলাকালীন অন্য কোনো থ্রেড সেটির উপর কাজ করতে পারে না।

AtomicBoolean এর মূল ধারণা

Thread Safety: একাধিক থ্রেড যখন একই boolean ভ্যারিয়েবলে কাজ করে, তখন AtomicBoolean ডেটার সঠিকতা এবং নিরাপত্তা বজায় রাখে।
Atomic Operations: প্রতিটি অপারেশন indivisible হয়। যেমন, get(), set(), এবং compareAndSet() অপারেশনগুলো একসাথে সম্পন্ন হয়।
Non-blocking: এটি লক বা মিউটেক্স (mutex) ছাড়াই কাজ করে, যা উচ্চ পারফরম্যান্স নিশ্চিত করে।

AtomicBoolean এর সাধারণ মেথডসমূহ

১. `get()`

বর্তমান boolean ভ্যালু রিটার্ন করে।

২. `set(boolean newValue)`

নতুন boolean মান সেট করে।

৩. `compareAndSet(boolean expected, boolean newValue)`

যদি বর্তমান মানটি expected এর সমান হয়, তবে এটি newValue দিয়ে আপডেট করে। এটি একটি atomic check-and-set অপারেশন।

৪. `getAndSet(boolean newValue)`

বর্তমান মানটি রিটার্ন করে এবং একটি নতুন মান সেট করে।

উদাহরণ: AtomicBoolean ব্যবহার

import java.util.concurrent.atomic.AtomicBoolean;

public class AtomicBooleanExample {
    public static void main(String[] args) {
        AtomicBoolean atomicBoolean = new AtomicBoolean(false);

        // Initial Value
        System.out.println("Initial Value: " + atomicBoolean.get()); // Output: false

        // Update Value
        atomicBoolean.set(true);
        System.out.println("Updated Value: " + atomicBoolean.get()); // Output: true

        // Compare and Set
        boolean wasUpdated = atomicBoolean.compareAndSet(true, false);
        System.out.println("Was Updated: " + wasUpdated); // Output: true
        System.out.println("Current Value: " + atomicBoolean.get()); // Output: false

        // Get and Set
        boolean oldValue = atomicBoolean.getAndSet(true);
        System.out.println("Old Value: " + oldValue); // Output: false
        System.out.println("New Value: " + atomicBoolean.get()); // Output: true
    }
}

AtomicBoolean এর সুবিধা

Thread Safety: একাধিক থ্রেড থেকে boolean ভ্যালু ম্যানিপুলেট করলেও ডেটা নিরাপদ থাকে।
Race Condition প্রতিরোধ: একাধিক থ্রেড একই সময়ে কাজ করলেও ডেটার সঠিকতা নষ্ট হয় না।
Non-blocking Performance: লক ছাড়া কাজ সম্পন্ন হওয়ার কারণে পারফরম্যান্স উন্নত হয়।
Atomic Operations: প্রতিটি অপারেশন indivisible, তাই concurrency ইস্যু তৈরি হয় না।

AtomicBoolean এর সীমাবদ্ধতা

Single Boolean Value: এটি শুধুমাত্র একটি boolean ডেটা পরিচালনা করতে পারে, জটিল ডেটা স্ট্রাকচারের জন্য নয়।
Concurrency Overhead: মাল্টি-থ্রেড অপ্টিমাইজেশনের ক্ষেত্রে অপ্রয়োজনীয় ব্যবহারে পারফরম্যান্স হ্রাস পেতে পারে।
Limited Use Case: শুধুমাত্র তখনই কার্যকর, যখন থ্রেড সেফ boolean মান ব্যবস্থাপনা প্রয়োজন।

কেন AtomicBoolean প্রয়োজন?

যখন একাধিক থ্রেড একটি boolean ভ্যারিয়েবলে কাজ করে এবং ডেটার সঠিকতা নিশ্চিত করতে হয়।
Lock-free concurrency বজায় রেখে দ্রুত এবং কার্যকর থ্রেড ম্যানেজমেন্ট।
থ্রেডের মধ্যে state management পরিচালনা করতে, যেমন একটি ফ্ল্যাগ যা একাধিক থ্রেড দ্বারা পড়া বা আপডেট করা হয়।

AtomicBoolean হল একটি কার্যকর টুল যা মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলিতে boolean state পরিচালনার জন্য ব্যবহার করা হয়। এটি থ্রেডগুলোর মধ্যে synchronization বজায় রেখে ডেটার নিরাপত্তা এবং সঠিকতা নিশ্চিত করে।

Content added By

SATT Academy

Introduction

281

AtomicBoolean হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা boolean ডেটা টাইপের উপর atomic operations সম্পাদন করতে ব্যবহৃত হয়। এটি মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলিতে boolean ভ্যারিয়েবলকে থ্রেড-সেফভাবে পরিচালনা করতে সাহায্য করে এবং race conditions প্রতিরোধে সহায়ক।

AtomicBoolean ক্লাসটি atomic operations সরবরাহ করে, যার মাধ্যমে boolean মানটি একাধিক থ্রেডের দ্বারা নিরাপদভাবে পরিবর্তিত হতে পারে, অর্থাৎ কোনো থ্রেড অন্যথায় হস্তক্ষেপ করতে পারে না যতক্ষণ না অপারেশনটি সম্পন্ন হয়। এটি মূলত thread synchronization নিশ্চিত করতে ব্যবহৃত হয় যেখানে একাধিক থ্রেড একই ভ্যারিয়েবলকে অ্যাক্সেস বা পরিবর্তন করতে পারে।

AtomicBoolean এর মূল ধারণা

Atomic Operations: AtomicBoolean এর মাধ্যমে boolean ভ্যালুর উপরে এমন অপারেশন করা হয় যা indivisible (অখণ্ড)। একাধিক থ্রেড একযোগে boolean মান পরিবর্তন করতে চেষ্টা করলেও সেগুলি সঠিকভাবে কাজ করবে।
Thread Safety: একাধিক থ্রেড যখন একই boolean ভ্যারিয়েবলে কাজ করে, তখন AtomicBoolean এটি সঠিকভাবে পরিচালনা করে এবং thread safety নিশ্চিত করে।
Non-blocking: AtomicBoolean ক্লাসটি লক ছাড়া boolean ভ্যালুর মান পরিবর্তন করে, যার ফলে পারফরম্যান্সে কোনো ব্যাঘাত সৃষ্টি হয় না। এটি lock-free (লক-মুক্ত) অপারেশন সরবরাহ করে।
State Management: এটি সাধারণত একটি flag বা state indicator হিসেবে ব্যবহৃত হয়, যেখানে একাধিক থ্রেড একটি boolean ভ্যারিয়েবলের মাধ্যমে একটি নির্দিষ্ট অবস্থা চেক বা পরিবর্তন করতে পারে।

AtomicBoolean এর মেথডসমূহ

১. get()

বর্তমান boolean মান রিটার্ন করে।

boolean currentValue = atomicBoolean.get();

২. set(boolean newValue)

নতুন boolean মান সেট করে।

atomicBoolean.set(true);

৩. compareAndSet(boolean expected, boolean newValue)

যদি বর্তমান মান expected এর সমান হয়, তবে সেটি newValue দিয়ে আপডেট করে। এটি atomic check-and-set অপারেশন।

boolean updated = atomicBoolean.compareAndSet(false, true);

৪. getAndSet(boolean newValue)

বর্তমান মানটি রিটার্ন করে এবং একটি নতুন boolean মান সেট করে।

boolean oldValue = atomicBoolean.getAndSet(true);

AtomicBoolean এর ব্যবহার

AtomicBoolean ক্লাসটি বিভিন্ন ধরনের মাল্টি-থ্রেডেড অ্যাপ্লিকেশনে ব্যবহৃত হয়, যেখানে একটি boolean মানের উপর atomic অপারেশন করা প্রয়োজন। এটি সাধারনত flag বা state ট্র্যাক করতে ব্যবহৃত হয়, যেমন একটি lock চেক বা termination condition।

উদাহরণ: AtomicBoolean ব্যবহার

import java.util.concurrent.atomic.AtomicBoolean;

public class AtomicBooleanExample {
    public static void main(String[] args) {
        AtomicBoolean atomicFlag = new AtomicBoolean(false);

        // get() ব্যবহার করে মান পড়া
        System.out.println("Initial Value: " + atomicFlag.get()); // Output: false

        // set() ব্যবহার করে মান সেট করা
        atomicFlag.set(true);
        System.out.println("Updated Value: " + atomicFlag.get()); // Output: true

        // compareAndSet() ব্যবহার করে atomic update করা
        boolean updated = atomicFlag.compareAndSet(true, false);
        System.out.println("Was updated: " + updated); // Output: true
        System.out.println("Final Value: " + atomicFlag.get()); // Output: false
    }
}

AtomicBoolean এর সুবিধা

Thread-Safe: একাধিক থ্রেড একযোগে boolean মান পরিবর্তন করতে পারলেও এটি নিরাপদ থাকে।
Performance Optimization: lock-free অপারেশন থাকার কারণে পারফরম্যান্স উন্নত হয়, বিশেষ করে যখন boolean মানের পরিবর্তন দ্রুত করতে হয়।
Race Condition প্রতিরোধ: Atomic অপারেশন ব্যবহার করার কারণে race condition এড়ানো যায়।
Simpler Code: লক ব্যবহারের প্রয়োজন ছাড়াই থ্রেড সিঙ্ক্রোনাইজেশন সহজে করা যায়।

AtomicBoolean এর সীমাবদ্ধতা

Boolean Value Only: AtomicBoolean শুধুমাত্র boolean টাইপের ডেটার জন্য কাজ করে। এটি reference types বা primitive types এর জন্য কাজ করে না।
Limited Operations: এটি কেবলমাত্র boolean মানের পরিবর্তন এবং চেক করার জন্য ব্যবহৃত হয়, সুতরাং এটি কমplex data manipulation বা আরো জটিল অপারেশনের জন্য উপযোগী নয়।

AtomicBoolean এর প্রয়োগ ক্ষেত্রে

Flags and States: AtomicBoolean সাধারণত থ্রেডের মধ্যে state management বা flags পরিচালনার জন্য ব্যবহৃত হয়। যেমন, থ্রেডকে একটি নির্দিষ্ট অবস্থায় কাজ করা বা থ্রেডের কাজ বন্ধ করার জন্য একটি সিগন্যাল।
Termination Conditions: একাধিক থ্রেডের মধ্যে কাজের সমাপ্তি বা termination চেক করার জন্য AtomicBoolean ব্যবহার করা হয়।
Synchronization in Multi-threaded Programs: AtomicBoolean ব্যবহৃত হয় যেখানে একাধিক থ্রেড একযোগে একটি boolean মান চেক বা পরিবর্তন করে এবং সেখানে সঠিক synchronization নিশ্চিত করা প্রয়োজন।

AtomicBoolean হল একটি কার্যকর ক্লাস যা boolean মানের atomic operations পরিচালনার জন্য ব্যবহৃত হয়। এটি মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে thread safety নিশ্চিত করতে সহায়ক এবং performance অপটিমাইজেশনের জন্য উপকারী। এর সাহায্যে race condition প্রতিরোধ করা যায় এবং non-blocking পারফরম্যান্স নিশ্চিত করা যায়।

Content added || updated By

SATT Academy

Methods: addAndGet(), getAndAdd(), getAndDecrement(), ইত্যাদি

247

AtomicBoolean হল JavaScript বা Java প্রোগ্রামিং ল্যাঙ্গুয়েজে একটি ক্লাস (বা API), যা atomic operations সম্পাদনের জন্য ব্যবহার করা হয়। এটি boolean টাইপের ডেটার উপর থ্রেড-সেফ অপারেশন নিশ্চিত করে।

যদিও Java তে এটি একটি বিল্ট-ইন ক্লাস, JavaScript-এ এই ধরনের কার্যকারিতা সাধারণত Atomics API ব্যবহার করে করা হয়। এখানে Java এর দৃষ্টিকোণ থেকে AtomicBoolean এবং এর উল্লেখযোগ্য মেথডগুলোর ব্যাখ্যা দেওয়া হলো।

AtomicBoolean এর মূল ধারণা

AtomicBoolean ক্লাস একটি boolean value ধারণ করে এবং এর উপর atomic (indivisible) অপারেশন করার সুযোগ দেয়। এটি multi-threaded environment-এ ডেটা কনসিস্টেন্সি এবং থ্রেড সেফটি নিশ্চিত করে।

Constructor:

AtomicBoolean atomicBoolean = new AtomicBoolean(); // Default value: false
AtomicBoolean atomicBoolean = new AtomicBoolean(true); // Initial value: true

AtomicBoolean Methods

addAndGet()

যদিও addAndGet() সাধারণত সংখ্যাসূচক (numeric) ডেটার জন্য ব্যবহৃত হয়, AtomicBoolean এ এটি নেই কারণ boolean ডেটায় যোগ-বিয়োগের প্রয়োজন নেই।
তবে boolean এর জন্য নিম্নলিখিত মেথডগুলো গুরুত্বপূর্ণ:

get()

get() মেথড বর্তমান boolean মান পড়ে।

AtomicBoolean atomicBoolean = new AtomicBoolean(true);
System.out.println(atomicBoolean.get()); // Output: true

set()

set() মেথড boolean মান নির্ধারণ করে।

AtomicBoolean atomicBoolean = new AtomicBoolean();
atomicBoolean.set(true);
System.out.println(atomicBoolean.get()); // Output: true

compareAndSet(expectedValue, newValue)

এই মেথড নিশ্চিত করে যে, যদি বর্তমান মান expectedValue এর সমান হয়, তাহলে এটি newValue দিয়ে আপডেট হবে। এটি একটি atomic operation।

AtomicBoolean atomicBoolean = new AtomicBoolean(false);

boolean success = atomicBoolean.compareAndSet(false, true);
System.out.println(success); // Output: true
System.out.println(atomicBoolean.get()); // Output: true

getAndSet(newValue)

এই মেথড বর্তমান মানটি রিটার্ন করে এবং একই সময়ে নতুন মান সেট করে।

AtomicBoolean atomicBoolean = new AtomicBoolean(true);

boolean previousValue = atomicBoolean.getAndSet(false);
System.out.println(previousValue); // Output: true
System.out.println(atomicBoolean.get()); // Output: false

lazySet(newValue)

lazySet() মেথডটি নতুন মান সেট করে, তবে এটি অন্য মেথডের মতো সাথে সাথে দৃশ্যমান নয়। এটি performance optimization এর জন্য ব্যবহৃত হয়।

AtomicBoolean atomicBoolean = new AtomicBoolean();
atomicBoolean.lazySet(true);
System.out.println(atomicBoolean.get()); // Output: true

AtomicBoolean ব্যবহার করার প্রয়োজনীয়তা

Thread-Safe Operations: মাল্টি-থ্রেডেড প্রোগ্রামে boolean ডেটার সঠিকতা বজায় রাখে।
Race Condition প্রতিরোধ: একাধিক থ্রেড boolean ডেটায় পরিবর্তন করার সময় কনসিস্টেন্সি নিশ্চিত করে।
Atomicity: প্রতিটি অপারেশন atomic বা অবিভাজ্য হয়, যা ডেটা সুরক্ষা নিশ্চিত করে।
Lock-Free Mechanism: লক বা মিউটেক্স ছাড়াই কাজ করা যায়।

উদাহরণ: Thread-Safe Boolean Operations

AtomicBoolean isProcessing = new AtomicBoolean(false);

Thread t1 = new Thread(() -> {
    if (isProcessing.compareAndSet(false, true)) {
        System.out.println("Thread 1: Processing...");
        isProcessing.set(false); // Reset value
    }
});

Thread t2 = new Thread(() -> {
    if (isProcessing.compareAndSet(false, true)) {
        System.out.println("Thread 2: Processing...");
        isProcessing.set(false); // Reset value
    }
});

t1.start();
t2.start();

সারাংশ

AtomicBoolean একটি গুরুত্বপূর্ণ ক্লাস যা boolean ডেটার উপর থ্রেড-সেফ এবং atomic operations নিশ্চিত করে। এর compareAndSet(), getAndSet(), এবং lazySet() এর মতো মেথডগুলো মাল্টি-থ্রেডেড প্রোগ্রামে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করে। এটি ডেটা ইন্টিগ্রিটি বজায় রেখে concurrency management সহজ করে তোলে।

Content added By

SATT Academy

AtomicReference:

353

AtomicReference হল Java এবং অনুরূপ মাল্টি-থ্রেডেড প্রোগ্রামিং ভাষায় ব্যবহৃত একটি বিশেষ শ্রেণি (class) যা একটি অবজেক্টকে থ্রেড-সেফ (thread-safe) পদ্ধতিতে অ্যাক্সেস ও আপডেট করতে দেয়। এটি মূলত atomic operations এর মাধ্যমে ডেটার স্থিতিশীলতা (consistency) বজায় রাখে এবং মাল্টি-থ্রেডিংয়ের সময় race condition প্রতিরোধ করে।

AtomicReference কেন ব্যবহার করা হয়?

একাধিক থ্রেড যখন একই অবজেক্টে কাজ করে এবং সেই অবজেক্টের মান (value) আপডেট করতে চায়, তখন synchronization ছাড়া এই পরিবর্তন করা ঝুঁকিপূর্ণ। AtomicReference ব্যবহার করলে নিম্নলিখিত সুবিধাগুলো পাওয়া যায়:

Thread-Safe Operations: একাধিক থ্রেড একসাথে কাজ করলেও ডেটা সঠিক থাকে।
Non-blocking Mechanism: লক বা মিউটেক্স (mutex) ব্যবহার ছাড়াই কাজ সম্পন্ন হয়।
CAS (Compare-And-Swap): একটি নির্দিষ্ট মানের উপর ভিত্তি করে ডেটা আপডেট করা হয়।

AtomicReference কীভাবে কাজ করে?

AtomicReference একটি অবজেক্টের রেফারেন্স ধরে রাখে এবং এর মান থ্রেড-সেফ উপায়ে পড়া ও পরিবর্তন করার জন্য বিভিন্ন পদ্ধতি প্রদান করে। এটি মূলত Compare-And-Swap (CAS) অ্যালগরিদমের উপর ভিত্তি করে কাজ করে।

CAS-এর ধারণা:

একটি current value এবং একটি expected value এর তুলনা করা হয়।
যদি current value expected value এর সমান হয়, তবে একটি নতুন মান সেট করা হয়।
যদি সমান না হয়, তবে অপারেশন বাতিল করা হয়।

AtomicReference এর প্রধান মেথড

get()
বর্তমান রেফারেন্স রিটার্ন করে।
উদাহরণ:

AtomicReference<String> ref = new AtomicReference<>("Initial Value");
System.out.println(ref.get()); // আউটপুট: Initial Value

set(newValue)
নতুন মান দিয়ে রেফারেন্স আপডেট করে।
উদাহরণ:
```
ref.set("Updated Value");
System.out.println(ref.get()); // আউটপুট: Updated Value
```
compareAndSet(expectedValue, newValue)
রেফারেন্সের বর্তমান মান যদি expectedValue এর সমান হয়, তবে এটি newValue দিয়ে আপডেট হয়।
উদাহরণ:
```
boolean updated = ref.compareAndSet("Initial Value", "New Value");
System.out.println(updated); // আউটপুট: false (কারণ মানটি Initial Value নয়)
```

getAndSet(newValue)
নতুন মান সেট করার আগে পুরানো মান রিটার্ন করে।
উদাহরণ:

String oldValue = ref.getAndSet("Final Value");
System.out.println(oldValue); // আউটপুট: Updated Value
System.out.println(ref.get()); // আউটপুট: Final Value

weakCompareAndSet(expectedValue, newValue)
compareAndSet এর মতোই কাজ করে, তবে এটি দুর্বল গ্যারান্টি (weaker guarantees) প্রদান করে এবং পুনরায় চেষ্টা করে না।

AtomicReference উদাহরণ

১. Basic Example

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> ref = new AtomicReference<>("Hello");

        // মান পড়া
        System.out.println("Initial Value: " + ref.get());

        // মান আপডেট করা
        ref.set("World");
        System.out.println("Updated Value: " + ref.get());

        // Compare-And-Swap (CAS) ব্যবহার
        boolean isUpdated = ref.compareAndSet("Hello", "Atomic");
        System.out.println("CAS Result: " + isUpdated); // false

        // পুনরায় CAS ব্যবহার
        isUpdated = ref.compareAndSet("World", "Atomic");
        System.out.println("CAS Result: " + isUpdated); // true
        System.out.println("Final Value: " + ref.get());
    }
}

২. মাল্টি-থ্রেডিং এর ক্ষেত্রে AtomicReference

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceThreadSafe {
    public static void main(String[] args) {
        AtomicReference<Integer> counter = new AtomicReference<>(0);

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.updateAndGet(value -> value + 1); // Atomic increment
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter Value: " + counter.get()); // 2000
    }
}

AtomicReference এর সুবিধা

Thread-safe Object Handling: একই অবজেক্টে একাধিক থ্রেড কাজ করতে পারে।
Non-blocking: লক ছাড়া কার্যকর অপারেশন সম্ভব।
CAS অ্যালগরিদম ব্যবহার: ডেটা আপডেটের সময় সঠিকতা বজায় থাকে।
Simple API: জটিল সিঙ্ক্রোনাইজেশন কোডের পরিবর্তে সহজ মেথড প্রদান করে।

AtomicReference এর সীমাবদ্ধতা

Complexity in Nested Structures: গভীর বা নেস্টেড অবজেক্টের জন্য এটি কম কার্যকর।
CAS Overhead: বারবার তুলনা করার কারণে পারফরম্যান্স কমতে পারে।
Memory Consumption: অতিরিক্ত রেফারেন্স মেমোরি খরচ করে।

উপসংহার

AtomicReference হল মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের জন্য একটি গুরুত্বপূর্ণ টুল যা থ্রেড-সেফ উপায়ে ডেটা ম্যানিপুলেট করতে সাহায্য করে। এটি মূলত non-blocking operations এবং CAS mechanism এর মাধ্যমে ডেটা কনসিস্টেন্সি বজায় রাখে, যা জটিল মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলোর কার্যকারিতা বৃদ্ধি করে।

Content added By

SATT Academy

Introduction

262

AtomicReference হল Java-এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস যা reference types এর উপর atomic operations সম্পাদন করতে ব্যবহৃত হয়। এটি একাধিক থ্রেডের মধ্যে reference variables (যেমন, objects, arrays, etc.) নিরাপদভাবে পরিচালনা করতে সাহায্য করে এবং thread safety নিশ্চিত করে।

এটি একটি generic class যা ডেটা টাইপের উপর কাজ করতে সক্ষম, এবং একই সময়ে একাধিক থ্রেড দ্বারা অ্যাক্সেস বা পরিবর্তন করা হলে ডেটার সঠিকতা এবং নিরাপত্তা বজায় রাখে।

AtomicReference এর মূল ধারণা

Atomic Operations: AtomicReference প্রতিটি অপারেশনকে atomic বা indivisible (অখণ্ড) বানায়, অর্থাৎ কোনো অপারেশন চলাকালীন অন্য কোনো থ্রেড তার মধ্যে হস্তক্ষেপ করতে পারে না।
Thread Safety: একাধিক থ্রেড একই reference variable অ্যাক্সেস বা পরিবর্তন করলেও ডেটা সঠিক থাকে।
Generics Support: AtomicReference যেকোনো object reference টাইপের জন্য ব্যবহৃত হতে পারে, যেমন String, Custom Classes, Lists, Maps, ইত্যাদি।

AtomicReference এর বৈশিষ্ট্য

Thread-Safe Reference Management: একাধিক থ্রেড যখন একই রেফারেন্স ভ্যারিয়েবলে কাজ করে, তখন এটি ডেটা সুরক্ষিত রাখে।
Atomicity: এটি atomic operations সরবরাহ করে, যা অপারেশন চলাকালীন থ্রেডের মধ্যে হস্তক্ষেপ রোধ করে।
Non-blocking: লক (lock) বা মিউটেক্স (mutex) ছাড়া কাজ করা যায়, যার ফলে পারফরম্যান্স উন্নত হয়।
Compare-and-Set (CAS): এটি atomic compare-and-set অপারেশন সরবরাহ করে, যেখানে একটি থ্রেড একটি রেফারেন্স ভ্যালুকে নতুন ভ্যালু দিয়ে প্রতিস্থাপন করতে পারে, যদি সেটি একটি প্রত্যাশিত মানের সমান হয়।

AtomicReference এর মেথডসমূহ

১. get()

এটি বর্তমান রেফারেন্স ভ্যালু রিটার্ন করে।

T currentValue = atomicReference.get();

২. set(T newValue)

এটি নতুন মান সেট করে।

atomicReference.set(newValue);

৩. compareAndSet(T expected, T newValue)

যদি বর্তমান মান expected এর সমান হয়, তবে এটি newValue দিয়ে আপডেট করে। এটি একটি atomic check-and-set অপারেশন।

boolean isUpdated = atomicReference.compareAndSet(expected, newValue);

৪. getAndSet(T newValue)

এটি বর্তমান মানটি রিটার্ন করে এবং নতুন মান সেট করে।

T oldValue = atomicReference.getAndSet(newValue);

৫. weakCompareAndSet(T expected, T newValue)

compareAndSet এর মতো, তবে এটি একটি অস্থায়ী (weak) সিঙ্ক্রোনাইজেশন ব্যবস্থার মাধ্যমে কাজ করে। এটি পারফরম্যান্সের জন্য উপকারী হতে পারে।

AtomicReference এর ব্যবহার

১. স্টেট পরিবর্তন ট্র্যাকিং (State Change Tracking)

ধরা যাক, একটি অ্যাপ্লিকেশনে একটি নির্দিষ্ট অবস্থা ট্র্যাক করতে হবে যা একাধিক থ্রেড দ্বারা পরিবর্তিত হতে পারে। AtomicReference ব্যবহার করে এই ধরনের স্টেট ম্যানেজমেন্ট করা যায়।

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> reference = new AtomicReference<>("Initial Value");

        // get() ব্যবহার করে মান পড়া
        System.out.println("Current Value: " + reference.get()); // Output: Initial Value

        // set() ব্যবহার করে নতুন মান সেট করা
        reference.set("Updated Value");
        System.out.println("Updated Value: " + reference.get()); // Output: Updated Value

        // compareAndSet() ব্যবহার করে atomic update করা
        boolean wasUpdated = reference.compareAndSet("Updated Value", "New Value");
        System.out.println("Was updated: " + wasUpdated); // Output: true
        System.out.println("Final Value: " + reference.get()); // Output: New Value
    }
}

২. থ্রেড সিঙ্ক্রোনাইজেশন

একাধিক থ্রেড একযোগে একই রেফারেন্স মান পরিবর্তন করার সময়, AtomicReference ব্যবহার করা হলে race condition এড়ানো সম্ভব হয় এবং ডেটার সঠিকতা নিশ্চিত হয়।

import java.util.concurrent.atomic.AtomicReference;

public class ThreadSafetyExample {
    private static final AtomicReference<Integer> counter = new AtomicReference<>(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> increment());
        Thread t2 = new Thread(() -> increment());

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final Counter: " + counter.get());
    }

    private static void increment() {
        int currentValue;
        do {
            currentValue = counter.get();
        } while (!counter.compareAndSet(currentValue, currentValue + 1));
    }
}

AtomicReference এর সুবিধা

Thread Safety: একাধিক থ্রেড ডেটা অ্যাক্সেস করার সময় ডেটা সঠিক থাকে।
High Performance: লক-মুক্ত (lock-free) অপারেশন পারফরম্যান্স বাড়ায়।
Atomic Operations: প্রতিটি অপারেশন indivisible হওয়ায় race condition প্রতিরোধ করা যায়।
Generics Support: এটি যেকোনো object reference টাইপের জন্য ব্যবহৃত হতে পারে, যেমন String, Integer, Custom Objects, ইত্যাদি।

AtomicReference এর সীমাবদ্ধতা

Reference Types Only: এটি শুধুমাত্র reference types এর জন্য কাজ করে, প্রিমিটিভ টাইপের জন্য নয়।
Atomicity of Reference: এটি কেবলমাত্র রেফারেন্স (object) এর মান পরিবর্তন নিশ্চিত করে, কিন্তু deep equality বা shallow copy এর মধ্যে পার্থক্য করতে পারে না।
Limited Scope: যখন খুব বেশি সংখ্যক থ্রেড একসঙ্গে একে অপরের সাথে কাজ করছে, তখন AtomicReference এর কর্মক্ষমতা প্রভাবিত হতে পারে।

উপসংহার

AtomicReference হল একটি অত্যন্ত কার্যকর টুল যা thread-safe reference type ডেটা পরিচালনা করার জন্য ব্যবহৃত হয়। এটি atomic অপারেশন সরবরাহ করে, যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করতে সহায়ক। এটি Generics এর সমর্থন দিয়ে ডেভেলপারদের আরো নমনীয়তা প্রদান করে, বিশেষ করে যখন custom objects বা complex data structures ব্যবহৃত হয়।

Content added || updated By

SATT Academy

Generics এবং Object References

345

AtomicReference হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা একটি অবিভাজ্য (atomic) এবং থ্রেড-সেফ উপায়ে Object References পরিচালনা করতে ব্যবহৃত হয়। এটি জেনেরিক্স (Generics) সমর্থন করে, যার ফলে বিভিন্ন ধরণের অবজেক্ট রেফারেন্সের উপর কাজ করা যায়।

AtomicReference বিশেষত মাল্টি-থ্রেডেড অ্যাপ্লিকেশনে ব্যবহৃত হয়, যেখানে একাধিক থ্রেড একটি শেয়ার করা অবজেক্টকে atomic ভাবে আপডেট করতে পারে।

AtomicReference কীভাবে কাজ করে?

Object Reference Management:
AtomicReference একটি অবজেক্ট রেফারেন্সকে পরিচালনা করে। এটি CAS (Compare-and-Swap) মেকানিজম ব্যবহার করে রেফারেন্স আপডেট করে।
Generics Support:
এটি জেনেরিক্স সমর্থন করে, যার ফলে এটি যেকোনো ধরণের অবজেক্টের জন্য ব্যবহার করা যায়। যেমন AtomicReference<String>, AtomicReference<MyClass>।
Thread Safety:
থ্রেডগুলোর মধ্যে অবজেক্ট রেফারেন্স আপডেট করার সময় race condition প্রতিরোধ করে।

AtomicReference এর প্রধান মেথডসমূহ

১. get():

রেফারেন্সকৃত অবজেক্টটি রিটার্ন করে।
থ্রেড-সেফ পদ্ধতিতে রেফারেন্স পড়ার জন্য ব্যবহৃত হয়।

২. set(T newValue):

একটি নতুন অবজেক্ট রেফারেন্স সেট করে।
এটি থ্রেড-সেফ নয়, তবে এটি সরল উপায়ে রেফারেন্স আপডেট করতে পারে।

৩. compareAndSet(T expectedValue, T newValue):

যদি বর্তমান রেফারেন্সটি expectedValue এর সমান হয়, তবে এটি newValue দিয়ে আপডেট হয়।
এটি একটি atomic অপারেশন এবং race condition এড়াতে কার্যকর।

৪. getAndSet(T newValue):

রেফারেন্সটি একটি নতুন মান দিয়ে আপডেট করে এবং পুরোনো মানটি রিটার্ন করে।

৫. weakCompareAndSet(T expectedValue, T newValue):

compareAndSet এর মতো কাজ করে, তবে এটি guarantee দেয় না যে অপারেশনটি সব সময় সফল হবে।

Generics এর সাথে AtomicReference ব্যবহার

AtomicReference জেনেরিক্স ব্যবহার করে যেকোনো ধরনের অবজেক্ট পরিচালনা করতে পারে। উদাহরণস্বরূপ, আপনি String, Integer, বা কোনো Custom Class এর রেফারেন্স রাখতে পারেন।

উদাহরণ: String রেফারেন্স ম্যানেজমেন্ট

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    public static void main(String[] args) {
        AtomicReference<String> atomicString = new AtomicReference<>("Initial Value");

        // Get the current value
        System.out.println("Current Value: " + atomicString.get());

        // Set a new value
        atomicString.set("Updated Value");
        System.out.println("Updated Value: " + atomicString.get());

        // Compare and set
        boolean success = atomicString.compareAndSet("Updated Value", "Final Value");
        System.out.println("Compare-And-Set Success: " + success);
        System.out.println("Final Value: " + atomicString.get());
    }
}

আউটপুট:

Current Value: Initial Value
Updated Value: Updated Value
Compare-And-Set Success: true
Final Value: Final Value

Object References এর সাথে ব্যবহার

উদাহরণ: Custom Object ব্যবহার

import java.util.concurrent.atomic.AtomicReference;

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        AtomicReference<Person> atomicPerson = new AtomicReference<>(new Person("Alice"));

        // Get the current object
        System.out.println("Current Person: " + atomicPerson.get());

        // Update the reference
        atomicPerson.set(new Person("Bob"));
        System.out.println("Updated Person: " + atomicPerson.get());

        // Compare and Set
        boolean success = atomicPerson.compareAndSet(new Person("Bob"), new Person("Charlie"));
        System.out.println("Compare-And-Set Success: " + success); // false, because "Bob" is a different instance

        success = atomicPerson.compareAndSet(atomicPerson.get(), new Person("Charlie"));
        System.out.println("Compare-And-Set Success: " + success);
        System.out.println("Final Person: " + atomicPerson.get());
    }
}

আউটপুট:

Current Person: Person{name='Alice'}
Updated Person: Person{name='Bob'}
Compare-And-Set Success: false
Compare-And-Set Success: true
Final Person: Person{name='Charlie'}

AtomicReference এর সুবিধা

Thread Safety: এটি থ্রেড-সেফ উপায়ে অবজেক্ট রেফারেন্স ম্যানেজ করতে পারে।
Race Condition প্রতিরোধ: একাধিক থ্রেডের মধ্যে ডেটা আপডেট করার সময় সমস্যা এড়ানো।
Generics Support: এটি যেকোনো ধরণের অবজেক্ট রেফারেন্স পরিচালনা করতে পারে।
Non-blocking Mechanism: লক ছাড়াই atomicity নিশ্চিত করে।

AtomicReference এর সীমাবদ্ধতা

CAS Overhead: compareAndSet এর বারবার ব্যর্থ অপারেশন কিছু ক্ষেত্রে পারফরম্যান্স সমস্যা সৃষ্টি করতে পারে।
Complex Logic: অনেক বড় অবজেক্ট বা জটিল লজিক পরিচালনা করা তুলনামূলক কঠিন।
Immutable References: রেফারেন্সে Immutable ডেটা ব্যবহার করাই উত্তম; Mutable ডেটা ব্যবহারে সমস্যা বাড়তে পারে।

AtomicReference এর ব্যবহার ক্ষেত্র

Immutable Data Management: Immutable অবজেক্টের রেফারেন্স থ্রেড-সেফ উপায়ে পরিচালনা করা।
Shared Resource Coordination: মাল্টি-থ্রেডিংয়ে শেয়ার করা রিসোর্স পরিচালনা।
Non-blocking Algorithms: ব্লকিং ছাড়াই থ্রেডের মধ্যে সমন্বয় বজায় রাখা।
Custom Lock Implementation: লাইটওয়েট লক মেকানিজম তৈরি।

উপসংহার

AtomicReference একটি কার্যকর টুল যা multithreaded programming-এ শেয়ার করা অবজেক্টের রেফারেন্স ম্যানেজ করার জন্য ব্যবহৃত হয়। এটি থ্রেড-সেফ, জেনেরিক্স সমর্থিত এবং লক-মুক্ত হওয়ার কারণে মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলোতে ডেটা আপডেট এবং সিঙ্ক্রোনাইজেশনে গুরুত্বপূর্ণ ভূমিকা পালন করে।

Content added By

SATT Academy

Methods: get(), set(), compareAndSet(), ইত্যাদি

353

AtomicReference হল Java বা মাল্টি-থ্রেডিং পরিবেশে ব্যবহৃত একটি ক্লাস, যা reference object এর মান atomic (অখণ্ড) অপারেশনের মাধ্যমে আপডেট করতে দেয়। এটি মূলত CAS (Compare-And-Swap) মেকানিজমের উপর ভিত্তি করে কাজ করে। AtomicReference একাধিক থ্রেডের মধ্যে ডেটার সঠিকতা এবং সিঙ্ক্রোনাইজেশন নিশ্চিত করতে ব্যবহৃত হয়।

AtomicReference এর কাজ

Atomicity: সমস্ত অপারেশন (যেমন: রিড, রাইট, আপডেট) একত্রে বা indivisible উপায়ে সম্পন্ন হয়।
Thread-Safety: একাধিক থ্রেড একই রেফারেন্স ভ্যালুর উপর কাজ করলেও ডেটা সঠিক থাকে।
Lock-Free Mechanism: লক ব্যবহারের প্রয়োজন হয় না, ফলে পারফরম্যান্স বৃদ্ধি পায়।

AtomicReference এর গুরুত্বপূর্ণ Methods

১. `get()`

বর্তমান রেফারেন্স মানটি রিটার্ন করে।
Syntax:
```
public V get()
```

উদাহরণ:

AtomicReference<String> atomicRef = new AtomicReference<>("Initial Value");
System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Initial Value

২. `set(V newValue)`

রেফারেন্স মানটি সরাসরি আপডেট করে।
Syntax:
```
public void set(V newValue)
```

উদাহরণ:

atomicRef.set("Updated Value");
System.out.println("Updated Value: " + atomicRef.get()); // আউটপুট: Updated Value

৩. `compareAndSet(V expectedValue, V newValue)`

CAS (Compare-And-Swap) অপারেশনের মাধ্যমে রেফারেন্স মান আপডেট করে।
বর্তমান মান expectedValue এর সমান হলে এটি newValue দিয়ে আপডেট হয়।

Syntax:

public boolean compareAndSet(V expectedValue, V newValue)

উদাহরণ:

boolean isUpdated = atomicRef.compareAndSet("Initial Value", "New Value");
System.out.println("Was Updated: " + isUpdated); // আউটপুট: true
System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: New Value

৪. `getAndSet(V newValue)`

বর্তমান রেফারেন্স মানটি রিটার্ন করে এবং নতুন মান দিয়ে আপডেট করে।
Syntax:
```
public V getAndSet(V newValue)
```

উদাহরণ:

String oldValue = atomicRef.getAndSet("Another Value");
System.out.println("Old Value: " + oldValue); // আউটপুট: New Value
System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Another Value

৫. `weakCompareAndSet(V expectedValue, V newValue)`

একটি দুর্বল বা সম্ভাব্য compare-and-set অপারেশন সম্পন্ন করে। এটি সফল হতে পারে বা ব্যর্থ হতে পারে।

Syntax:

public boolean weakCompareAndSet(V expectedValue, V newValue)

৬. `accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction)`

নির্দিষ্ট একটি accumulator function ব্যবহার করে মানটি আপডেট করে।

Syntax:

public V accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction)

উদাহরণ:

AtomicReference<Integer> atomicInt = new AtomicReference<>(10);
atomicInt.accumulateAndGet(5, (current, update) -> current + update); 
System.out.println("Accumulated Value: " + atomicInt.get()); // আউটপুট: 15

৭. `updateAndGet(UnaryOperator<V> updateFunction)`

একটি UnaryOperator ব্যবহার করে বর্তমান মানটি আপডেট করে এবং নতুন মান রিটার্ন করে।

Syntax:

public V updateAndGet(UnaryOperator<V> updateFunction)

উদাহরণ:

atomicRef.updateAndGet(value -> value + " Updated Again");
System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Another Value Updated Again

AtomicReference উদাহরণ

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> atomicRef = new AtomicReference<>("Initial Value");

        // get() Method
        System.out.println("Initial Value: " + atomicRef.get());

        // set() Method
        atomicRef.set("Updated Value");
        System.out.println("After Set: " + atomicRef.get());

        // compareAndSet() Method
        boolean wasUpdated = atomicRef.compareAndSet("Updated Value", "New Value");
        System.out.println("Was Updated: " + wasUpdated);
        System.out.println("Current Value: " + atomicRef.get());

        // getAndSet() Method
        String oldValue = atomicRef.getAndSet("Final Value");
        System.out.println("Old Value: " + oldValue);
        System.out.println("Current Value: " + atomicRef.get());
    }
}

AtomicReference এর সুবিধা

Thread Safety: একাধিক থ্রেডের মধ্যে ডেটার সঠিকতা নিশ্চিত করে।
Lock-Free Synchronization: লক ছাড়া ডেটা সিঙ্ক্রোনাইজ করে, যা পারফরম্যান্স উন্নত করে।
CAS মেকানিজম: Compare-And-Swap এর মাধ্যমে ডেটা হস্তক্ষেপ প্রতিরোধ করে।
Concurrent Programming সহজ করে।

AtomicReference এর সীমাবদ্ধতা

Complexity: বড় ডেটাসেট বা জটিল ডেটা স্ট্রাকচারের জন্য কার্যকর নয়।
CPU Overhead: CAS অপারেশন বারবার ব্যর্থ হলে spinning ঘটতে পারে, যা CPU চক্র অপচয় করে।
Limited Scope: শুধুমাত্র একক রেফারেন্স মান ম্যানেজ করে।

উপসংহার

AtomicReference হল মাল্টি-থ্রেডিং পরিবেশে ডেটার উপর কাজ করার একটি অত্যন্ত কার্যকর টুল। এটি thread-safe operations পরিচালনা করতে সক্ষম এবং CAS মেকানিজম ব্যবহার করে ডেটা সঠিকতা বজায় রাখে। ছোট স্কেলের synchronization problems সমাধানের জন্য এটি একটি আদর্শ সমাধান।

Content added By

SATT Academy

AtomicStampedReference এবং AtomicMarkableReference:

299

AtomicStampedReference এবং AtomicMarkableReference হল Java এর java.util.concurrent.atomic প্যাকেজের দুটি ক্লাস, যা জটিল ডেটা ম্যানেজমেন্ট এবং মাল্টি-থ্রেডিং পরিবেশে CAS (Compare-And-Swap) অপারেশন নিশ্চিত করে। এগুলো সাধারণ AtomicReference এর উপর ভিত্তি করে কাজ করে, তবে অতিরিক্ত তথ্য সংযুক্ত করে আরও উন্নত কন্ট্রোল প্রদান করে।

AtomicStampedReference

AtomicStampedReference একটি অবজেক্টের রেফারেন্সের সাথে একটি অতিরিক্ত "স্ট্যাম্প" মান সংরক্ষণ করে। এটি বিশেষভাবে ABA সমস্যা সমাধানে ব্যবহৃত হয়।

ABA সমস্যা কী?

ABA সমস্যা ঘটে যখন একটি থ্রেড শেয়ার করা ডেটার একটি ভ্যালু চেক করে এবং দেখতে পায় যে এটি পরিবর্তিত হয়নি। কিন্তু, বাস্তবে, ডেটাটি A → B → A তে পরিবর্তিত হয়েছে।
সাধারণ CAS অ্যালগরিদম এই পরিবর্তনটি ধরতে পারে না, কিন্তু AtomicStampedReference স্ট্যাম্পের মাধ্যমে এই সমস্যা সমাধান করে।

AtomicStampedReference এর বৈশিষ্ট্য

প্রতিটি রেফারেন্সের সাথে একটি স্ট্যাম্প মান থাকে।
CAS অপারেশনের সময় এটি রেফারেন্স এবং স্ট্যাম্প উভয়কেই চেক করে।
এটি নিশ্চিত করে যে কোনো পরিবর্তন ঘটে থাকলে তা সঠিকভাবে চিহ্নিত করা যায়।

ব্যবহারের উদাহরণ

import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicStampedReferenceExample {
    public static void main(String[] args) {
        // Initial reference and stamp
        String initialReference = "A";
        int initialStamp = 1;

        AtomicStampedReference<String> atomicStampedRef = 
            new AtomicStampedReference<>(initialReference, initialStamp);

        // Getting the reference and stamp
        int[] stampHolder = new int[1];
        String currentRef = atomicStampedRef.get(stampHolder);
        System.out.println("Initial Reference: " + currentRef + ", Stamp: " + stampHolder[0]);

        // Compare and set with correct stamp
        boolean success = atomicStampedRef.compareAndSet("A", "B", initialStamp, initialStamp + 1);
        System.out.println("Operation Successful: " + success);

        // Get updated reference and stamp
        currentRef = atomicStampedRef.get(stampHolder);
        System.out.println("Updated Reference: " + currentRef + ", Stamp: " + stampHolder[0]);

        // Trying with wrong stamp
        success = atomicStampedRef.compareAndSet("B", "C", initialStamp, initialStamp + 1);
        System.out.println("Operation Successful with wrong stamp: " + success);
    }
}

আউটপুট:

Initial Reference: A, Stamp: 1
Operation Successful: true
Updated Reference: B, Stamp: 2
Operation Successful with wrong stamp: false

AtomicMarkableReference

AtomicMarkableReference একটি অবজেক্ট রেফারেন্সের সাথে একটি mark মান সংরক্ষণ করে। এই মার্কটি সাধারণত একটি boolean মান যা রেফারেন্সের অতিরিক্ত একটি অবস্থা (state) নির্দেশ করে।

AtomicMarkableReference এর বৈশিষ্ট্য

প্রতিটি রেফারেন্সের সাথে একটি মার্ক সংযুক্ত থাকে।
CAS অপারেশনের সময় এটি রেফারেন্স এবং মার্ক উভয়কেই চেক করে।
এটি সাধারণত রেফারেন্সের সাথে একটি অতিরিক্ত অবস্থা ট্র্যাক করার জন্য ব্যবহৃত হয়।

ব্যবহারের উদাহরণ

import java.util.concurrent.atomic.AtomicMarkableReference;

public class AtomicMarkableReferenceExample {
    public static void main(String[] args) {
        // Initial reference and mark
        String initialReference = "A";
        boolean initialMark = false;

        AtomicMarkableReference<String> atomicMarkableRef =
            new AtomicMarkableReference<>(initialReference, initialMark);

        // Getting the reference and mark
        boolean[] markHolder = new boolean[1];
        String currentRef = atomicMarkableRef.get(markHolder);
        System.out.println("Initial Reference: " + currentRef + ", Mark: " + markHolder[0]);

        // Compare and set with correct mark
        boolean success = atomicMarkableRef.compareAndSet("A", "B", false, true);
        System.out.println("Operation Successful: " + success);

        // Get updated reference and mark
        currentRef = atomicMarkableRef.get(markHolder);
        System.out.println("Updated Reference: " + currentRef + ", Mark: " + markHolder[0]);

        // Trying with wrong mark
        success = atomicMarkableRef.compareAndSet("B", "C", false, true);
        System.out.println("Operation Successful with wrong mark: " + success);
    }
}

আউটপুট:

Initial Reference: A, Mark: false
Operation Successful: true
Updated Reference: B, Mark: true
Operation Successful with wrong mark: false

AtomicStampedReference বনাম AtomicMarkableReference

বৈশিষ্ট্য	AtomicStampedReference	AtomicMarkableReference
ডেটা সংযুক্তি	রেফারেন্সের সাথে একটি স্ট্যাম্প।	রেফারেন্সের সাথে একটি মার্ক (boolean)।
সমাধান করে	ABA সমস্যা।	রেফারেন্সের অবস্থা ট্র্যাক করা।
উদ্দেশ্য	ডেটার সঠিকতা এবং পরিবর্তন শনাক্ত।	ডেটার অবস্থা চিহ্নিত করা।
স্ট্যাম্প/মার্ক টাইপ	`int`	`boolean`

ব্যবহার ক্ষেত্র

AtomicStampedReference:
- ABA সমস্যার সমাধান করতে।
- যেখানে রেফারেন্সের সাথে অতিরিক্ত একটি সংস্করণ বা স্ট্যাম্প সংযুক্ত থাকা প্রয়োজন।
AtomicMarkableReference:
- অবজেক্টের অবস্থা (state) ট্র্যাক করতে।
- Boolean মার্কের মাধ্যমে সহজে ডেটার বর্তমান অবস্থা যাচাই করতে।

AtomicStampedReference এবং AtomicMarkableReference মাল্টি-থ্রেডেড পরিবেশে ডেটার নির্ভুলতা নিশ্চিত করে এবং জটিল পরিস্থিতিতে সঠিক ফলাফল প্রদান করে। এগুলো Compare-And-Swap (CAS) অ্যালগরিদমের উপর ভিত্তি করে ডেটা আপডেটের সময় অতিরিক্ত নিয়ন্ত্রণ প্রদান করে।

Content added By

SATT Academy

Introduction

286

AtomicStampedReference এবং AtomicMarkableReference হল java.util.concurrent.atomic প্যাকেজের অংশ, যা Java-তে মাল্টি-থ্রেডিং এবং কনকারেন্সি ম্যানেজমেন্টের জন্য ব্যবহৃত হয়। এরা উভয়ই atomic reference classes এর অন্তর্গত এবং Compare-And-Swap (CAS) অপারেশন ব্যবহার করে ডেটা সুরক্ষা নিশ্চিত করে। এই ক্লাসগুলো একাধিক থ্রেডের মধ্যে shared data consistency বজায় রাখতে এবং race condition প্রতিরোধে গুরুত্বপূর্ণ ভূমিকা পালন করে।

AtomicStampedReference: কী এবং কবে ব্যবহার করবেন?

AtomicStampedReference এমন একটি ক্লাস, যা একটি অবজেক্ট রেফারেন্সের পাশাপাশি একটি "স্ট্যাম্প" মান সংরক্ষণ করে। এই স্ট্যাম্প মান ব্যবহার করে এটি ABA Problem সমাধান করতে সাহায্য করে।

ABA Problem কী?

ABA সমস্যা ঘটে যখন একটি রেফারেন্সের মান A থেকে পরিবর্তিত হয়ে B হয় এবং পুনরায় A তে ফিরে আসে। থ্রেড অন্যথায় বুঝতে পারে না যে রেফারেন্সটি পরিবর্তিত হয়েছিল। AtomicStampedReference স্ট্যাম্পের সাহায্যে এই পরিবর্তনকে ট্র্যাক করে।

ব্যবহার ক্ষেত্র:

Concurrency Management: যেখানে একই ডেটার মান বারবার পরিবর্তিত হতে পারে।
Version Tracking: ডেটার সাথে সংশ্লিষ্ট সংস্করণ বা স্ট্যাম্প সংরক্ষণ করা।

উদাহরণ:

import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicStampedReferenceExample {
    public static void main(String[] args) {
        String initialRef = "A";
        int initialStamp = 1;

        AtomicStampedReference<String> atomicRef = new AtomicStampedReference<>(initialRef, initialStamp);

        // Current reference and stamp
        System.out.println("Reference: " + atomicRef.getReference());
        System.out.println("Stamp: " + atomicRef.getStamp());

        // Update with compare-and-swap
        boolean success = atomicRef.compareAndSet("A", "B", 1, 2);
        System.out.println("Update Successful: " + success);
        System.out.println("New Reference: " + atomicRef.getReference());
        System.out.println("New Stamp: " + atomicRef.getStamp());
    }
}

AtomicMarkableReference: কী এবং কবে ব্যবহার করবেন?

AtomicMarkableReference এমন একটি ক্লাস, যা একটি অবজেক্ট রেফারেন্সের সাথে একটি boolean flag সংরক্ষণ করে। এটি অবজেক্টের একটি নির্দিষ্ট অবস্থা mark করে রাখতে সাহায্য করে।

ব্যবহার ক্ষেত্র:

State Tracking: ডেটার অবস্থা পরিবর্তনের জন্য একটি true বা false চিহ্ন সংরক্ষণ করা।
Concurrent Operations: একাধিক থ্রেডের মধ্যে ডেটার অবস্থা সিঙ্ক্রোনাইজ করে রাখা।

উদাহরণ:

import java.util.concurrent.atomic.AtomicMarkableReference;

public class AtomicMarkableReferenceExample {
    public static void main(String[] args) {
        String initialRef = "Initial";
        boolean initialMark = false;

        AtomicMarkableReference<String> atomicMarkRef = new AtomicMarkableReference<>(initialRef, initialMark);

        // Current reference and mark
        System.out.println("Reference: " + atomicMarkRef.getReference());
        System.out.println("Mark: " + atomicMarkRef.isMarked());

        // Update with compare-and-swap
        boolean success = atomicMarkRef.compareAndSet("Initial", "Updated", false, true);
        System.out.println("Update Successful: " + success);
        System.out.println("New Reference: " + atomicMarkRef.getReference());
        System.out.println("New Mark: " + atomicMarkRef.isMarked());
    }
}

AtomicStampedReference এবং AtomicMarkableReference এর তুলনা

প্যারামিটার	AtomicStampedReference	AtomicMarkableReference
সঞ্চিত তথ্য	Reference এবং একটি Stamp (ইন্টিজার)	Reference এবং একটি Mark (Boolean)
উদ্দেশ্য	Version/Stamp Tracking	State/Flag Tracking
ABA Problem সমাধান	হ্যাঁ	আংশিকভাবে
ব্যবহার ক্ষেত্র	ডেটার সংস্করণ পরিবর্তন ট্র্যাকিং	ডেটার অবস্থা চিহ্নিত করা

AtomicStampedReference এবং AtomicMarkableReference এর সুবিধা

AtomicStampedReference:

ABA Problem সমাধান: এটি স্ট্যাম্প ব্যবহার করে ABA সমস্যাকে কার্যকরভাবে প্রতিরোধ করে।
Thread Safety: মাল্টি-থ্রেডিংয়ে রেফারেন্স এবং স্ট্যাম্প নিরাপদভাবে পরিচালনা করা যায়।

AtomicMarkableReference:

State Tracking: ডেটার অবস্থা চিহ্নিত করা সহজ।
Concurrency-Friendly: থ্রেডগুলোর মধ্যে ডেটার অবস্থা সিঙ্ক্রোনাইজ রাখে।

সীমাবদ্ধতা

কমপ্লেক্সিটি: এই ক্লাসগুলো জটিল এবং ব্যবহারকারীর জন্য বোঝা কঠিন হতে পারে।
Performance Overhead: CAS অপারেশনের কারণে কিছু ক্ষেত্রে অতিরিক্ত ওভারহেড তৈরি হতে পারে।

সারসংক্ষেপ

AtomicStampedReference স্ট্যাম্প ব্যবহার করে ABA সমস্যা সমাধান করে এবং ডেটার সংস্করণ ট্র্যাকিংয়ে কার্যকর।
AtomicMarkableReference একটি রেফারেন্সের সাথে একটি boolean চিহ্ন সংরক্ষণ করে ডেটার অবস্থা পরিচালনা করে।
এই দুই ক্লাস মাল্টি-থ্রেডিং এবং কনকারেন্সি ম্যানেজমেন্টে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করতে গুরুত্বপূর্ণ।

Content added By

SATT Academy

Stamped এবং Markable Reference এর ভূমিকা

254

JavaScript এর Atomics API মূলত shared memory synchronization এবং atomic operations এর জন্য ব্যবহৃত হয়। তবে Stamped Reference এবং Markable Reference ধারণাগুলো JavaScript-এ সরাসরি অন্তর্ভুক্ত নয়; এগুলো মূলত concurrent programming এর অন্যান্য ভাষা (যেমন Java, C++) থেকে এসেছে। এই ধারণাগুলো atomic operations পরিচালনা এবং কনকারেন্সি সমস্যার সমাধানে গুরুত্বপূর্ণ ভূমিকা পালন করে। এখানে আমরা Stamped Reference এবং Markable Reference এর কনসেপ্ট এবং সম্ভাব্য ব্যবহার আলোচনা করব।

Stamped Reference

Stamped Reference কী?

Stamped Reference এমন একটি ডেটা স্ট্রাকচার যা একটি ডেটার সাথে একটি timestamp (stamp) সংযুক্ত করে। এর মাধ্যমে ডেটার একটি নির্দিষ্ট সংস্করণ ট্র্যাক করা যায়। এটি মূলত optimistic locking মেকানিজমের জন্য ব্যবহৃত হয়, যেখানে ডেটা আপডেট করার আগে এর বর্তমান সংস্করণ যাচাই করা হয়।

Stamped Reference এর মূল ধারণা

প্রতিটি ডেটা value এবং একটি stamp (version) নিয়ে গঠিত।
যখন একটি থ্রেড ডেটা আপডেট করতে চায়, তখন এটি বর্তমান stamp যাচাই করে নিশ্চিত হয় যে, অন্য কোনো থ্রেড ইতিমধ্যে ডেটা পরিবর্তন করেনি।
যদি বর্তমান stamp মিলে যায়, তবে ডেটা আপডেট করা হয় এবং নতুন stamp সেট করা হয়।

Stamped Reference এর সুবিধা

Race Condition প্রতিরোধ: একাধিক থ্রেড একই ডেটা পরিবর্তন করতে চাইলেও stamp যাচাই করে সমস্যা এড়ানো যায়।
Optimistic Locking: এটি থ্রেডগুলোর মধ্যে lock-free synchronization নিশ্চিত করে।

উদাহরণ

JavaScript-এ Stamped Reference সরাসরি নেই, তবে Atomics.compareExchange() ব্যবহার করে অনুরূপ কার্যপ্রণালী বাস্তবায়ন করা যায়।

const sharedBuffer = new SharedArrayBuffer(1024);
const typedArray = new Int32Array(sharedBuffer);

// Initial value and stamp
Atomics.store(typedArray, 0, 42); // Value
Atomics.store(typedArray, 1, 1); // Stamp (Version)

// Update with Stamped Reference logic
function updateValue(expectedValue, newValue, expectedStamp, newStamp) {
    if (Atomics.compareExchange(typedArray, 0, expectedValue, newValue) === expectedValue) {
        Atomics.compareExchange(typedArray, 1, expectedStamp, newStamp);
        return true; // Update successful
    }
    return false; // Update failed
}

// Try to update
if (updateValue(42, 50, 1, 2)) {
    console.log("Update successful");
} else {
    console.log("Update failed");
}

Markable Reference

Markable Reference কী?

Markable Reference একটি atomic reference যেখানে একটি ডেটার মানের সাথে একটি mark (flag) সংযুক্ত থাকে। এই mark সাধারণত একটি boolean flag বা binary state বোঝায়। এটি ডেটার সাথে কোনো নির্দিষ্ট অবস্থা (state) ট্র্যাক করার জন্য ব্যবহৃত হয়।

Markable Reference এর মূল ধারণা

একটি ডেটার সাথে একটি mark সংযুক্ত থাকে যা ডেটার অবস্থা নির্দেশ করে (যেমন valid/invalid, active/inactive)।
এটি সাধারণত atomic compare-and-swap (CAS) অপারেশনের মাধ্যমে পরিচালিত হয়।
একই ডেটা এবং mark এর ভিত্তিতে ডেটা পরিবর্তন বা যাচাই করা হয়।

Markable Reference এর সুবিধা

State Tracking: ডেটার অবস্থা ট্র্যাক করতে সাহায্য করে।
Concurrency Safety: একই সময়ে একাধিক থ্রেডের ডেটা ম্যানিপুলেশন থ্রেড-সেফ হয়।

উদাহরণ

JavaScript-এ Markable Reference সরাসরি নেই, তবে এটিও Atomics.compareExchange() এর মাধ্যমে প্রয়োগ করা সম্ভব।

const sharedBuffer = new SharedArrayBuffer(1024);
const typedArray = new Int32Array(sharedBuffer);

// Initial value and mark
Atomics.store(typedArray, 0, 42); // Value
Atomics.store(typedArray, 1, 0); // Mark (0 = inactive, 1 = active)

// Update with Markable Reference logic
function markValue(expectedValue, newValue, expectedMark, newMark) {
    if (Atomics.compareExchange(typedArray, 0, expectedValue, newValue) === expectedValue) {
        Atomics.compareExchange(typedArray, 1, expectedMark, newMark);
        return true; // Mark updated
    }
    return false; // Mark update failed
}

// Try to mark
if (markValue(42, 50, 0, 1)) {
    console.log("Value updated and marked as active");
} else {
    console.log("Failed to update or mark");
}

Stamped এবং Markable Reference এর ব্যবহার ক্ষেত্র

১. Optimistic Locking

Stamped Reference এর মাধ্যমে ডেটার সংস্করণ যাচাই করে ডেটা আপডেট করা হয়, যা optimistic locking এ ব্যবহৃত হয়।

২. State Management

Markable Reference ডেটার অবস্থা ট্র্যাক করার জন্য কার্যকর, যেমন কোনো ডেটা সক্রিয় (active) বা নিষ্ক্রিয় (inactive) আছে কিনা।

৩. Concurrent Data Structures

এই মডেলগুলো atomic linked lists, queues, এবং অন্যান্য non-blocking concurrent data structures তৈরি করতে ব্যবহৃত হয়।

৪. Thread-safe Operations

একই ডেটার বিভিন্ন অবস্থা এবং সংস্করণ ট্র্যাক করে thread-safe programming নিশ্চিত করে।

Stamped এবং Markable Reference এর সুবিধা

Race Condition প্রতিরোধ: একাধিক থ্রেডের ডেটা ম্যানিপুলেশন সঠিকভাবে পরিচালিত হয়।
Optimized Concurrency: লক-মুক্ত (lock-free) মডেলে ডেটা সঠিকতা বজায় রাখে।
Low Overhead: কম রিসোর্স ব্যবহার করে synchronization পরিচালনা করা যায়।
Data Integrity: ডেটার অবস্থা এবং সংস্করণ ট্র্যাক করার মাধ্যমে ডেটার সঠিকতা নিশ্চিত করে।

উপসংহার

Stamped Reference এবং Markable Reference ধারণাগুলো কনকারেন্সি সমস্যার সমাধানে গুরুত্বপূর্ণ ভূমিকা পালন করে। JavaScript-এর Atomics API ব্যবহার করে এগুলো আংশিকভাবে বাস্তবায়ন করা সম্ভব। এই ধারণাগুলো বিশেষ করে মাল্টি-থ্রেডেড অ্যাপ্লিকেশন এবং lock-free concurrent programming এর জন্য কার্যকর।

Content added By

SATT Academy

ব্যবহার এবং উদাহরণ

241

AtomicStampedReference এবং AtomicMarkableReference হল Java-এর java.util.concurrent.atomic প্যাকেজের অংশ। এই দুটি ক্লাস ব্যবহার করে মাল্টি-থ্রেডিংয়ের সময় শেয়ার করা রেফারেন্সের উপর সুনির্দিষ্ট এবং থ্রেড-সেফ অপারেশন পরিচালনা করা যায়। এরা CAS (Compare-And-Swap) মেকানিজম ব্যবহার করে এবং অতিরিক্ত তথ্য (স্ট্যাম্প বা মার্ক) সংরক্ষণ করে, যা ডেটার সঠিকতা নিশ্চিত করতে সাহায্য করে।

AtomicStampedReference

AtomicStampedReference একটি রেফারেন্সের (object reference) পাশাপাশি একটি স্ট্যাম্প মান সংরক্ষণ করে। এটি মূলত ABA সমস্যা সমাধানের জন্য ব্যবহৃত হয়।

ABA সমস্যা কী?

ABA সমস্যা ঘটে যখন একটি রেফারেন্সের মান পরিবর্তন হয় এবং আবার আগের মানে ফিরে আসে, কিন্তু এই পরিবর্তনটি অন্যান্য থ্রেড শনাক্ত করতে পারে না।

AtomicStampedReference একটি স্ট্যাম্প বা কাউন্টার ব্যবহার করে, যা প্রতিটি পরিবর্তনের সাথে আপডেট হয়। এটি নিশ্চিত করে যে রেফারেন্সটি আগের মতো দেখালেও এর স্ট্যাম্প ভিন্ন হলে পরিবর্তন শনাক্ত করা যায়।

AtomicStampedReference এর মেথডসমূহ

getReference(): রেফারেন্স রিটার্ন করে।
getStamp(): বর্তমান স্ট্যাম্প রিটার্ন করে।
compareAndSet(expectedReference, newReference, expectedStamp, newStamp):
যদি রেফারেন্স এবং স্ট্যাম্প উভয়ই প্রত্যাশিত মানের সাথে মেলে, তবে নতুন রেফারেন্স এবং স্ট্যাম্প সেট করে।
set(newReference, newStamp): নতুন রেফারেন্স এবং স্ট্যাম্প সেট করে।

AtomicStampedReference উদাহরণ

import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicStampedReferenceExample {
    public static void main(String[] args) {
        // রেফারেন্স এবং স্ট্যাম্প সেট করা
        String initialReference = "Initial";
        int initialStamp = 0;
        AtomicStampedReference<String> atomicStampedRef = new AtomicStampedReference<>(initialReference, initialStamp);

        // রেফারেন্স এবং স্ট্যাম্প পড়া
        System.out.println("Reference: " + atomicStampedRef.getReference());
        System.out.println("Stamp: " + atomicStampedRef.getStamp());

        // Compare and Set অপারেশন
        boolean success = atomicStampedRef.compareAndSet("Initial", "Updated", 0, 1);
        System.out.println("Update Success: " + success);
        System.out.println("New Reference: " + atomicStampedRef.getReference());
        System.out.println("New Stamp: " + atomicStampedRef.getStamp());
    }
}

আউটপুট:

Reference: Initial  
Stamp: 0  
Update Success: true  
New Reference: Updated  
New Stamp: 1

AtomicMarkableReference

AtomicMarkableReference একটি রেফারেন্সের পাশাপাশি একটি মার্ক (boolean flag) মান সংরক্ষণ করে। এটি সাধারণত এমন ক্ষেত্রে ব্যবহৃত হয় যেখানে একটি নির্দিষ্ট অবস্থা (marked বা unmarked) ট্র্যাক করতে হয়।

AtomicMarkableReference এর মেথডসমূহ

getReference(): রেফারেন্স রিটার্ন করে।
isMarked(): বর্তমান মার্ক স্টেট রিটার্ন করে।
compareAndSet(expectedReference, newReference, expectedMark, newMark):
যদি রেফারেন্স এবং মার্ক উভয়ই প্রত্যাশিত মানের সাথে মেলে, তবে নতুন রেফারেন্স এবং মার্ক সেট করে।
set(newReference, newMark): নতুন রেফারেন্স এবং মার্ক সেট করে।

AtomicMarkableReference উদাহরণ

import java.util.concurrent.atomic.AtomicMarkableReference;

public class AtomicMarkableReferenceExample {
    public static void main(String[] args) {
        // রেফারেন্স এবং মার্ক সেট করা
        String initialReference = "Initial";
        boolean initialMark = false;
        AtomicMarkableReference<String> atomicMarkableRef = new AtomicMarkableReference<>(initialReference, initialMark);

        // রেফারেন্স এবং মার্ক পড়া
        System.out.println("Reference: " + atomicMarkableRef.getReference());
        System.out.println("Is Marked: " + atomicMarkableRef.isMarked());

        // Compare and Set অপারেশন
        boolean success = atomicMarkableRef.compareAndSet("Initial", "Updated", false, true);
        System.out.println("Update Success: " + success);
        System.out.println("New Reference: " + atomicMarkableRef.getReference());
        System.out.println("New Mark: " + atomicMarkableRef.isMarked());
    }
}

আউটপুট:

Reference: Initial  
Is Marked: false  
Update Success: true  
New Reference: Updated  
New Mark: true

AtomicStampedReference এবং AtomicMarkableReference এর মধ্যে পার্থক্য

বৈশিষ্ট্য	AtomicStampedReference	AtomicMarkableReference
অতিরিক্ত মান	স্ট্যাম্প (একটি ইন্টিজার)।	মার্ক (একটি বুলিয়ান)।
ব্যবহার ক্ষেত্র	ABA সমস্যা সমাধানে ব্যবহৃত।	অবস্থা ট্র্যাকিং বা ফ্ল্যাগ ম্যানেজমেন্টে ব্যবহৃত।
কমপ্লেক্সিটি	রেফারেন্স এবং স্ট্যাম্পের মান উভয়ই পরিবর্তন করতে হয়।	শুধুমাত্র রেফারেন্স এবং মার্ক পরিবর্তন।

কেন ব্যবহার করবেন?

AtomicStampedReference:
- ABA সমস্যা সমাধানের জন্য।
- যখন রেফারেন্সের প্রতিটি পরিবর্তন একটি নির্দিষ্ট সংখ্যা বা স্ট্যাম্প দিয়ে চিহ্নিত করা প্রয়োজন।
AtomicMarkableReference:
- যখন একটি রেফারেন্সের সাথে একটি boolean flag সংরক্ষণ করতে হয়।
- অবস্থা বা স্টেট পরিবর্তন ট্র্যাক করার জন্য।

উপসংহার

AtomicStampedReference এবং AtomicMarkableReference মাল্টি-থ্রেডেড প্রোগ্রামে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করার জন্য গুরুত্বপূর্ণ টুল।

AtomicStampedReference ABA সমস্যা সমাধানে কার্যকর।
AtomicMarkableReference রেফারেন্সের সাথে একটি boolean state ট্র্যাক করতে সহায়ক।

এই ক্লাসগুলো ব্যবহার করে মাল্টি-থ্রেডেড প্রোগ্রামিং আরও নির্ভরযোগ্য এবং কার্যকর করা সম্ভব।

Content added By

SATT Academy

Atomics এর পরিচিতি Atomics এবং কনকারেন্সি Atomics এর মৌলিক কার্যপদ্ধতি Atomic Arrays Atomics এর সাথে কনকারেন্ট ডেটা স্ট্রাকচার

Atomic Classes এবং তাদের ব্যবহার

Atomic Classes এবং তাদের ভূমিকা

Atomic Classes

১. Atomics.add()

২. Atomics.sub()

৩. Atomics.load()

৪. Atomics.store()

৫. Atomics.exchange()

৬. Atomics.compareExchange()

৭. Atomics.wait()

৮. Atomics.notify()

Atomic Classes এর ব্যবহার ক্ষেত্র

১. Thread Synchronization

২. Shared Memory Management

৩. Low-Level Concurrency Control

৪. Avoiding Race Conditions

উপসংহার

AtomicInteger:

AtomicInteger কী?

AtomicInteger এর বৈশিষ্ট্য

AtomicInteger কনস্ট্রাকশন

AtomicInteger এর প্রধান মেথডসমূহ

AtomicInteger উদাহরণ

JavaScript-এর Atomics এবং Java-এর AtomicInteger এর মধ্যে পার্থক্য

সারসংক্ষেপ

Introduction

AtomicInteger এর বৈশিষ্ট্য

AtomicInteger কেন প্রয়োজন?

১. Race Condition এড়ানো

২. Thread-Safe Increment/Decrement

৩. Performance Optimization

AtomicInteger ক্লাসের সাধারণ মেথডসমূহ

উদাহরণ: AtomicInteger ব্যবহার

মাল্টি-থ্রেডিংয়ে সাধারণ integer ভেরিয়েবল ব্যবহার করলে Race Condition

AtomicInteger দিয়ে Race Condition সমাধান

AtomicInteger ব্যবহার করার সুবিধা

AtomicInteger এবং Synchronized এর তুলনা

Methods: get(), set(), getAndIncrement(), incrementAndGet(), compareAndSet(), ইত্যাদি

Atomics এর গুরুত্বপূর্ণ মেথডসমূহ

১. Atomics.get(typedArray, index)

২. Atomics.set(typedArray, index, value)

৩. Atomics.add(typedArray, index, value)

৪. Atomics.sub(typedArray, index, value)

৫. Atomics.increment(typedArray, index)

৬. Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)

৭. Atomics.exchange(typedArray, index, value)

৮. Atomics.wait(typedArray, index, value, timeout)

৯. Atomics.notify(typedArray, index, count)

উপসংহার

AtomicLong:

AtomicLong কী?

AtomicLong এর বৈশিষ্ট্য

AtomicLong এর সাধারণ মেথড

AtomicLong এর ব্যবহার উদাহরণ

উদাহরণ ১: মাল্টি-থ্রেডেড পরিবেশে AtomicLong ব্যবহার

AtomicLong এর সুবিধা

AtomicLong এর সীমাবদ্ধতা

Atomics বনাম AtomicLong

Introduction

AtomicLong এর বৈশিষ্ট্য

AtomicLong কেন প্রয়োজন?

AtomicLong কিভাবে কাজ করে?

AtomicLong ক্লাসের গুরুত্বপূর্ণ মেথড

উদাহরণ: AtomicLong এর ব্যবহার

AtomicLong এর সুবিধা

AtomicLong এর সীমাবদ্ধতা

Methods: addAndGet(), getAndAdd(), getAndDecrement(), ইত্যাদি

AtomicLong এর সাধারণ মেথডসমূহ

addAndGet(long delta)

getAndAdd(long delta)

getAndDecrement()

decrementAndGet()

get()

set(long newValue)

compareAndSet(long expect, long update)

getAndSet(long newValue)

AtomicLong ব্যবহার করার সুবিধা

উপসংহার

AtomicBoolean:

AtomicBoolean এর মূল ধারণা

১. `Atomics.add()`

২. `Atomics.sub()`

৩. `Atomics.load()`

৪. `Atomics.store()`

৫. `Atomics.exchange()`

৬. `Atomics.compareExchange()`

৭. `Atomics.wait()`

৮. `Atomics.notify()`

১. `Atomics.get(typedArray, index)`

২. `Atomics.set(typedArray, index, value)`

৩. `Atomics.add(typedArray, index, value)`

৪. `Atomics.sub(typedArray, index, value)`

৫. `Atomics.increment(typedArray, index)`

৬. `Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)`

৭. `Atomics.exchange(typedArray, index, value)`

৮. `Atomics.wait(typedArray, index, value, timeout)`

৯. `Atomics.notify(typedArray, index, count)`

১. `get()`

২. `set(boolean newValue)`

৩. `compareAndSet(boolean expected, boolean newValue)`

৪. `getAndSet(boolean newValue)`