Web Development Atomic Arrays গাইড ও নোট

312

Atomic Arrays হল মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ব্যবহৃত একটি ধারণা, যেখানে atomic operations এর মাধ্যমে একাধিক থ্রেড একটি শেয়ার করা অ্যারের উপর নিরাপদে কাজ করতে পারে। JavaScript-এ এটি TypedArray (যেমন Int8Array, Uint32Array, ইত্যাদি) এবং SharedArrayBuffer এর সাথে Atomics API ব্যবহার করে বাস্তবায়িত হয়।

Atomic Arrays কী?

Atomic Arrays হল SharedArrayBuffer এবং TypedArray এর একটি সমন্বয়, যা Atomics API এর মাধ্যমে atomic operations চালাতে সক্ষম। এটি শেয়ার করা মেমোরির উপর thread-safe অপারেশন নিশ্চিত করে, যেমন:

Read এবং Write
Increment এবং Decrement
Bitwise Operations (AND, OR, XOR)
Synchronization (wait এবং notify)

কেন Atomic Arrays প্রয়োজন?

Thread Safety: মাল্টি-থ্রেডেড প্রোগ্রামে একাধিক থ্রেড একই ডেটাতে কাজ করলেও ডেটা দুর্নীতি (data corruption) এড়ানো।
Performance Optimization: লক-মুক্ত অপারেশনের মাধ্যমে উচ্চ কার্যক্ষমতা নিশ্চিত করা।
Shared Memory Management: একই অ্যারের ডেটা বিভিন্ন থ্রেডের মধ্যে ভাগাভাগি করে ব্যবহার করা।
Race Condition প্রতিরোধ: একাধিক থ্রেড ডেটা ম্যানিপুলেট করার সময় প্রতিযোগিতা এড়ানো।

Atomic Arrays এর উপাদান

Atomic Arrays তৈরি করতে নিচের তিনটি উপাদান প্রয়োজন:

SharedArrayBuffer:
একাধিক থ্রেডের মধ্যে ডেটা ভাগাভাগি করার জন্য একটি বিশেষ ধরনের বাফার।
TypedArray:
Int8Array, Uint16Array, Int32Array ইত্যাদি টাইপড অ্যারে, যা মেমোরি ম্যানেজমেন্ট সহজ করে।
Atomics API:
Atomic Arrays এর উপর atomic operations সম্পাদন করার জন্য ব্যবহৃত মেথডগুলোর সেট।

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

১. Read এবং Write অপারেশন

Atomics.load(typedArray, index)
নির্দিষ্ট ইনডেক্স থেকে মান পড়ে।
Atomics.store(typedArray, index, value)
নির্দিষ্ট ইনডেক্সে মান সংরক্ষণ করে।

২. Increment এবং Decrement অপারেশন

Atomics.add(typedArray, index, value)
ইনডেক্সে মান যোগ করে এবং পূর্ববর্তী মান রিটার্ন করে।
Atomics.sub(typedArray, index, value)
ইনডেক্স থেকে মান বিয়োগ করে এবং পূর্ববর্তী মান রিটার্ন করে।
Atomics.increment(typedArray, index)
ইনডেক্সে মান ১ দ্বারা বৃদ্ধি করে।
Atomics.decrement(typedArray, index)
ইনডেক্সে মান ১ দ্বারা কমায়।

৩. Bitwise Operations

Atomics.and(typedArray, index, value)
ইনডেক্সের মানের সাথে value এর বিটওয়াইজ AND অপারেশন সম্পন্ন করে।
Atomics.or(typedArray, index, value)
বিটওয়াইজ OR অপারেশন সম্পন্ন করে।
Atomics.xor(typedArray, index, value)
বিটওয়াইজ XOR অপারেশন সম্পন্ন করে।

৪. Synchronization

Atomics.wait(typedArray, index, value)
ইনডেক্সে নির্দিষ্ট মানের জন্য থ্রেডকে অপেক্ষা করায়।
Atomics.notify(typedArray, index, count)
নির্দিষ্ট সংখ্যক থ্রেডকে জাগিয়ে তোলে।

উদাহরণ: Atomic Arrays তৈরি এবং ব্যবহার

SharedArrayBuffer এবং TypedArray ব্যবহার

// SharedArrayBuffer তৈরি
const sharedBuffer = new SharedArrayBuffer(16); // 16 বাইট মেমোরি বরাদ্দ
const typedArray = new Int32Array(sharedBuffer); // Int32Array তৈরি

// Atomics.store() দিয়ে মান সেট
Atomics.store(typedArray, 0, 5); // Index 0 এ 5 সেট
Atomics.store(typedArray, 1, 10); // Index 1 এ 10 সেট

// Atomics.add() দিয়ে মান যোগ
const oldValue = Atomics.add(typedArray, 0, 3); // Index 0 এ 3 যোগ করে
console.log(`Old Value: ${oldValue}, New Value: ${Atomics.load(typedArray, 0)}`);
// আউটপুট: Old Value: 5, New Value: 8

// Atomics.wait() এবং Atomics.notify() উদাহরণ
const worker = new Worker('worker.js');
worker.postMessage(sharedBuffer); // Worker এ SharedArrayBuffer পাঠানো

Worker ফাইল: worker.js

onmessage = function(event) {
    const sharedBuffer = event.data;
    const typedArray = new Int32Array(sharedBuffer);

    // Index 0 এর জন্য অপেক্ষা
    Atomics.wait(typedArray, 0, 8);

    // Notify করার পর কাজ সম্পন্ন
    console.log('Worker: Value updated, proceeding...');
};

Main Thread থেকে Notify

// Index 0 এ মান পরিবর্তন করে এবং Worker কে জাগায়
Atomics.store(typedArray, 0, 12);
Atomics.notify(typedArray, 0, 1); // Worker কে জাগানো

Atomic Arrays এর সুবিধা

Thread-Safe Operations: একাধিক থ্রেডের মধ্যে ডেটা ম্যানিপুলেশন সঠিক এবং নিরাপদ।
High Performance: লক-মুক্ত পদ্ধতিতে দ্রুত কাজ সম্পন্ন হয়।
Data Consistency: একাধিক থ্রেডের ডেটা ব্যবহার করার সময় কনসিস্টেন্সি বজায় রাখে।
Synchronization Mechanism: থ্রেডগুলোর মধ্যে কাজ সমন্বয় সহজ।

Atomic Arrays এর সীমাবদ্ধতা

Complexity: নতুনদের জন্য এর ব্যবহারে কিছুটা জটিলতা থাকতে পারে।
Limited Scope: শুধুমাত্র SharedArrayBuffer এবং TypedArray এর সাথে কাজ করে।
Browser Compatibility: সব ব্রাউজারে SharedArrayBuffer এবং Atomics API সমর্থিত নয়।

Atomic Arrays মাল্টি-থ্রেডেড প্রোগ্রামে shared memory ব্যবস্থাপনার একটি গুরুত্বপূর্ণ টুল। এটি ডেটার সঠিকতা এবং থ্রেডের কার্যক্ষমতা বজায় রেখে উন্নত প্রোগ্রামিং অভিজ্ঞতা প্রদান করে।

Content added By

SATT Academy

AtomicIntegerArray এবং AtomicLongArray:

320

AtomicIntegerArray এবং AtomicLongArray হল Java-এর java.util.concurrent.atomic প্যাকেজের ক্লাস, যা thread-safe এবং atomic operations সাপোর্ট করে। এগুলো multi-threaded environment-এ integer এবং long টাইপের ডেটা ম্যানেজমেন্টের জন্য ব্যবহৃত হয়। প্রতিটি অপারেশন (যেমন রিড, রাইট, ইনক্রিমেন্ট) অখণ্ডভাবে (atomic) পরিচালিত হয়, যার ফলে data consistency বজায় থাকে এবং race condition প্রতিরোধ করা যায়।

AtomicIntegerArray

পরিচিতি

এটি integer array এর উপর atomic operations পরিচালনা করে।
একাধিক থ্রেড একসঙ্গে একটি AtomicIntegerArray এর মান পরিবর্তন করতে পারে, কিন্তু প্রতিটি অপারেশন নিরাপদভাবে (thread-safe) সম্পন্ন হয়।

মুল Constructor

AtomicIntegerArray(int length)
AtomicIntegerArray(int[] array)

প্রথম কনস্ট্রাক্টর একটি নির্দিষ্ট আকারের (length) অ্যারে তৈরি করে।
দ্বিতীয় কনস্ট্রাক্টর একটি বিদ্যমান integer array থেকে নতুন AtomicIntegerArray তৈরি করে।

AtomicIntegerArray এর গুরুত্বপূর্ণ মেথড

get(int index): নির্দিষ্ট ইনডেক্স থেকে মান রিটার্ন করে।
set(int index, int newValue): নির্দিষ্ট ইনডেক্সে একটি নতুন মান সেট করে।
getAndSet(int index, int newValue): পুরোনো মান রিটার্ন করে এবং একটি নতুন মান সেট করে।
incrementAndGet(int index): ইনডেক্সের মান ১ বৃদ্ধি করে এবং নতুন মান রিটার্ন করে।
getAndIncrement(int index): ইনডেক্সের মান ১ বৃদ্ধি করার আগে পুরোনো মান রিটার্ন করে।
compareAndSet(int index, int expectedValue, int newValue): যদি ইনডেক্সের মান expectedValue এর সমান হয়, তাহলে newValue দিয়ে আপডেট করে।

উদাহরণ

import java.util.concurrent.atomic.AtomicIntegerArray;

public class Main {
    public static void main(String[] args) {
        int[] values = {10, 20, 30};
        AtomicIntegerArray atomicArray = new AtomicIntegerArray(values);

        // Get and Set Operations
        System.out.println("Initial value at index 0: " + atomicArray.get(0)); // 10
        atomicArray.set(0, 50);
        System.out.println("Updated value at index 0: " + atomicArray.get(0)); // 50

        // Increment Operations
        System.out.println("Value before increment: " + atomicArray.getAndIncrement(1)); // 20
        System.out.println("Value after increment: " + atomicArray.get(1)); // 21

        // Compare and Set
        boolean success = atomicArray.compareAndSet(2, 30, 100);
        System.out.println("Compare and Set successful: " + success); // true
        System.out.println("Value at index 2: " + atomicArray.get(2)); // 100
    }
}

AtomicLongArray

পরিচিতি

এটি long array এর উপর atomic operations পরিচালনা করে।
এটি একইভাবে thread-safe এবং মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের জন্য উপযোগী।

মূল Constructor

AtomicLongArray(int length)
AtomicLongArray(long[] array)

প্রথম কনস্ট্রাক্টর একটি নির্দিষ্ট আকারের (length) AtomicLongArray তৈরি করে।
দ্বিতীয় কনস্ট্রাক্টর একটি বিদ্যমান long array থেকে নতুন AtomicLongArray তৈরি করে।

AtomicLongArray এর গুরুত্বপূর্ণ মেথড

get(int index): নির্দিষ্ট ইনডেক্স থেকে মান রিটার্ন করে।
set(int index, long newValue): নির্দিষ্ট ইনডেক্সে একটি নতুন মান সেট করে।
getAndSet(int index, long newValue): পুরোনো মান রিটার্ন করে এবং একটি নতুন মান সেট করে।
incrementAndGet(int index): ইনডেক্সের মান ১ বৃদ্ধি করে এবং নতুন মান রিটার্ন করে।
getAndIncrement(int index): ইনডেক্সের মান ১ বৃদ্ধি করার আগে পুরোনো মান রিটার্ন করে।
compareAndSet(int index, long expectedValue, long newValue): যদি ইনডেক্সের মান expectedValue এর সমান হয়, তাহলে newValue দিয়ে আপডেট করে।

উদাহরণ

import java.util.concurrent.atomic.AtomicLongArray;

public class Main {
    public static void main(String[] args) {
        long[] values = {100L, 200L, 300L};
        AtomicLongArray atomicArray = new AtomicLongArray(values);

        // Get and Set Operations
        System.out.println("Initial value at index 0: " + atomicArray.get(0)); // 100
        atomicArray.set(0, 500L);
        System.out.println("Updated value at index 0: " + atomicArray.get(0)); // 500

        // Increment Operations
        System.out.println("Value before increment: " + atomicArray.getAndIncrement(1)); // 200
        System.out.println("Value after increment: " + atomicArray.get(1)); // 201

        // Compare and Set
        boolean success = atomicArray.compareAndSet(2, 300L, 1000L);
        System.out.println("Compare and Set successful: " + success); // true
        System.out.println("Value at index 2: " + atomicArray.get(2)); // 1000
    }
}

AtomicIntegerArray এবং AtomicLongArray এর প্রয়োগ ক্ষেত্র

Thread-Safe Counter: মাল্টি-থ্রেডের মধ্যে কাউন্টার পরিচালনা করা।
Shared Resources: একাধিক থ্রেডের মধ্যে শেয়ার করা ডেটার উপর কাজ করা।
Concurrency Control: মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলিতে ডেটা কনসিস্টেন্সি বজায় রাখা।
Atomic Updates: ডেটা রিড এবং রাইট করতে লক-মুক্ত (lock-free) পদ্ধতি ব্যবহার।

AtomicIntegerArray বনাম AtomicLongArray

বৈশিষ্ট্য	AtomicIntegerArray	AtomicLongArray
ডেটা টাইপ	int	long
ব্যবহারের ক্ষেত্র	ছোট সংখ্যার ডেটা ম্যানিপুলেশন	বড় সংখ্যার ডেটা ম্যানিপুলেশন
স্টোরেজ রেঞ্জ	32-bit signed integer (-2³¹ to 2³¹-1)	64-bit signed long (-2⁶³ to 2⁶³-1)

উপসংহার

AtomicIntegerArray এবং AtomicLongArray ক্লাস মাল্টি-থ্রেডিংয়ে ডেটা পরিচালনার জন্য খুবই কার্যকর। এগুলো থ্রেড-সেফ increment, decrement, এবং conditional update সাপোর্ট করে, যা data consistency এবং performance নিশ্চিত করে।

Content added By

SATT Academy

Introduction এবং অ্যারে পরিচালনা

229

Atomic Arrays হল JavaScript-এ Atomics API এবং SharedArrayBuffer এর সাথে ব্যবহৃত একটি বিশেষ কনসেপ্ট, যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে অ্যারে ডেটা পরিচালনায় atomic operations নিশ্চিত করে। এটি TypedArray এর উপর ভিত্তি করে কাজ করে, যা SharedArrayBuffer এর মাধ্যমে মেমোরি শেয়ার করতে সক্ষম।

Atomic Arrays: Introduction

Atomic Arrays মূলত SharedArrayBuffer এর উপর ভিত্তি করে তৈরি করা TypedArray। এগুলোতে Atomics API ব্যবহার করে থ্রেড-সেফ অপারেশন সম্পাদন করা হয়। মাল্টি-থ্রেডিংয়ের সময় ডেটা ম্যানিপুলেশনে Race Condition এবং Data Corruption প্রতিরোধ করার জন্য এগুলো ব্যবহৃত হয়।

কেন Atomic Arrays প্রয়োজন?

Thread-safe Data Management: একাধিক থ্রেড একসঙ্গে ডেটা পড়া এবং লেখা করতে পারে।
Synchronization: থ্রেডগুলোর মধ্যে ডেটা সিঙ্ক্রোনাইজ করে।
Performance Optimization: লক-মুক্ত (lock-free) প্রোগ্রামিংয়ের মাধ্যমে পারফরম্যান্স বৃদ্ধি করে।
Data Integrity: ডেটা সঠিকভাবে আপডেট এবং পরিচালনা নিশ্চিত করে।

Atomic Arrays এর বৈশিষ্ট্য

Thread-safety: একই সময়ে একাধিক থ্রেড ডেটার উপর কাজ করলেও ডেটার সঠিকতা বজায় থাকে।
Atomic Operations: ডেটা পড়া, লেখা, এবং আপডেট করার জন্য নির্দিষ্ট মেথড।
Shared Memory: SharedArrayBuffer ব্যবহার করে মেমোরি শেয়ার করা হয়।
TypedArray Integration: Int8Array, Int16Array, Int32Array এর সাথে কাজ করে।

Atomic Arrays: কিভাবে কাজ করে?

Atomic Arrays এর অপারেশনগুলো Atomics API এর মাধ্যমে সম্পন্ন হয়। এটি সরাসরি TypedArray এর নির্দিষ্ট ইনডেক্সে কাজ করে এবং থ্রেড-সেফ অপারেশন নিশ্চিত করে।

স্টেপস:

SharedArrayBuffer তৈরি করুন।
TypedArray এর সাথে SharedArrayBuffer লিঙ্ক করুন।
Atomics API ব্যবহার করে ডেটা পড়া বা আপডেট করুন।

Atomic Arrays এর ফাংশনসমূহ

১. Atomics.load(typedArray, index)

একটি নির্দিষ্ট ইনডেক্স থেকে ডেটা পড়ে।

const buffer = new SharedArrayBuffer(16); // 16-byte মেমোরি
const intArray = new Int32Array(buffer);
intArray[0] = 42;

const value = Atomics.load(intArray, 0);
console.log(value); // আউটপুট: 42

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

নির্দিষ্ট ইনডেক্সে একটি ভ্যালু সেট করে।

Atomics.store(intArray, 1, 100);
console.log(intArray[1]); // আউটপুট: 100

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

নির্দিষ্ট ইনডেক্সে একটি মান যোগ করে এবং পূর্ববর্তী মান রিটার্ন করে।

const previous = Atomics.add(intArray, 1, 10);
console.log(previous); // আউটপুট: 100
console.log(intArray[1]); // আউটপুট: 110

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

নির্দিষ্ট ইনডেক্স থেকে একটি মান বিয়োগ করে এবং পূর্ববর্তী মান রিটার্ন করে।

Atomics.sub(intArray, 1, 10);
console.log(intArray[1]); // আউটপুট: 100

৫. Atomics.compareExchange(typedArray, index, expected, replacement)

ইনডেক্সে যদি মান expected এর সমান হয়, তবে সেটি replacement দিয়ে প্রতিস্থাপন করে।

const result = Atomics.compareExchange(intArray, 1, 100, 200);
console.log(result); // আউটপুট: 100
console.log(intArray[1]); // আউটপুট: 200

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

নির্দিষ্ট ইনডেক্সে একটি মান পরিবর্তনের জন্য অপেক্ষা করে।

Atomics.wait(intArray, 0, 42, 1000); // ১ সেকেন্ড অপেক্ষা করবে যদি মান ৪২ না হয়

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

একটি নির্দিষ্ট সংখ্যা পর্যন্ত থ্রেডকে জাগিয়ে তোলে।

Atomics.notify(intArray, 0, 1); // একটি থ্রেডকে জাগিয়ে তোলে

Atomic Arrays এর ব্যবহার

উদাহরণ ১: মাল্টি-থ্রেডিংয়ে Atomic Arrays

const buffer = new SharedArrayBuffer(1024);
const intArray = new Int32Array(buffer);

// Worker 1
Atomics.store(intArray, 0, 50);

// Worker 2
Atomics.add(intArray, 0, 10);

// Main Thread
console.log(Atomics.load(intArray, 0)); // আউটপুট: 60

উদাহরণ ২: ডেটা আপডেট এবং সিঙ্ক্রোনাইজেশন

const buffer = new SharedArrayBuffer(1024);
const intArray = new Int32Array(buffer);

function increment() {
    for (let i = 0; i < 1000; i++) {
        Atomics.add(intArray, 0, 1);
    }
}

increment();
console.log(Atomics.load(intArray, 0)); // আউটপুট: 1000

Atomic Arrays ব্যবহারের সুবিধা

Thread-safe Operations: মাল্টি-থ্রেডিংয়ে ডেটা সঠিক রাখে।
Performance: লক-মুক্ত (lock-free) অপারেশন নিশ্চিত করে।
Data Consistency: একাধিক থ্রেড কাজ করলেও ডেটার সঠিকতা বজায় থাকে।
Concurrency Management: থ্রেডগুলোর মধ্যে সিঙ্ক্রোনাইজেশন নিশ্চিত করে।

Atomic Arrays এর সীমাবদ্ধতা

Complex API: নতুনদের জন্য এটি জটিল হতে পারে।
Memory Limitation: SharedArrayBuffer এর সাইজ ফিক্সড থাকে।
Browser Support: সব ব্রাউজারে সাপোর্ট নেই।
Limited Data Types: শুধুমাত্র TypedArray এর সাথে কাজ করে।

Atomic Arrays মাল্টি-থ্রেডেড অ্যাপ্লিকেশনে ডেটা ম্যানেজমেন্ট এবং সিঙ্ক্রোনাইজেশনের জন্য একটি শক্তিশালী টুল। এটি Web Workers এর মাধ্যমে ডেটা শেয়ারিং এবং ডেটার উপর নির্ভরযোগ্য অপারেশন নিশ্চিত করে।

Content added By

SATT Academy

Methods: get(), set(), getAndAdd(), compareAndSet()

315

Atomic Arrays হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ফিচার যা atomic operations এর মাধ্যমে একটি অ্যারের উপাদানগুলোকে থ্রেড-সেফভাবে পরিচালনা করতে ব্যবহৃত হয়। এটি AtomicIntegerArray, AtomicLongArray, এবং AtomicReferenceArray এর মতো ক্লাস সরবরাহ করে।

এই ক্লাসগুলোতে এমন মেথড রয়েছে যা একাধিক থ্রেডের মধ্যে synchronization ছাড়াই কাজ করতে পারে। এর ফলে মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটা সঠিকতা বজায় রাখা সহজ হয়।

গুরুত্বপূর্ণ মেথডসমূহ এবং তাদের কার্যপ্রণালী

১. get(index)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এর মান পড়ে।
এটি থ্রেড-সেফ।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(0, 10); // Index 0 তে 10 সেট করা

System.out.println(atomicArray.get(0)); // আউটপুট: 10

২. set(index, value)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এ একটি নতুন মান সেট করে।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(1, 20); // Index 1 এ 20 সেট করা

System.out.println(atomicArray.get(1)); // আউটপুট: 20

৩. getAndAdd(index, delta)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এর বর্তমান মান রিটার্ন করে এবং তারপর একটি নির্দিষ্ট delta মান যোগ করে।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(2, 30); // Index 2 তে 30 সেট করা

int previousValue = atomicArray.getAndAdd(2, 5); // 5 যোগ করার আগে পুরানো মান রিটার্ন করবে
System.out.println("Previous Value: " + previousValue); // আউটপুট: 30
System.out.println("Updated Value: " + atomicArray.get(2)); // আউটপুট: 35

৪. compareAndSet(index, expectedValue, newValue)

এই মেথডটি একটি নির্দিষ্ট index এর মান পরীক্ষা করে এবং যদি সেটি expectedValue এর সমান হয়, তবে এটি newValue তে আপডেট করে। সফল হলে এটি true রিটার্ন করে, অন্যথায় false।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(3, 40); // Index 3 এ 40 সেট করা

boolean isUpdated = atomicArray.compareAndSet(3, 40, 50); // যদি 40 হয়, তবে 50 তে আপডেট করবে
System.out.println("Update Successful: " + isUpdated); // আউটপুট: true
System.out.println("Updated Value: " + atomicArray.get(3)); // আউটপুট: 50

Atomic Arrays এর বৈশিষ্ট্য

Thread-Safe Operations: একাধিক থ্রেডের মধ্যে ডেটা পরিবর্তন সঠিকভাবে সম্পন্ন হয়।
Non-blocking Mechanism: CAS (Compare-And-Swap) মেকানিজম ব্যবহার করে ডেটা আপডেট করে, যা লক-মুক্ত এবং পারফরম্যান্স বৃদ্ধিতে কার্যকর।
Immutable Index: অ্যারের ইনডেক্স স্থির (immutable), তাই একাধিক থ্রেড একই ইনডেক্সে কাজ করলেও ডেটা সঠিক থাকে।

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

import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicArrayExample {
    public static void main(String[] args) {
        // Atomic Array তৈরি
        AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);

        // মান সেট করা
        atomicArray.set(0, 10);
        atomicArray.set(1, 20);
        atomicArray.set(2, 30);

        // get() ব্যবহার
        System.out.println("Index 1 Value: " + atomicArray.get(1)); // আউটপুট: 20

        // getAndAdd() ব্যবহার
        System.out.println("Index 2 Old Value: " + atomicArray.getAndAdd(2, 5)); // আউটপুট: 30
        System.out.println("Index 2 New Value: " + atomicArray.get(2)); // আউটপুট: 35

        // compareAndSet() ব্যবহার
        boolean isUpdated = atomicArray.compareAndSet(1, 20, 50); // যদি 20 হয়, তবে 50 তে আপডেট করবে
        System.out.println("Compare-And-Set Successful: " + isUpdated); // আউটপুট: true
        System.out.println("Index 1 New Value: " + atomicArray.get(1)); // আউটপুট: 50
    }
}

Atomic Arrays এর সুবিধা

Thread-safe Reads এবং Writes: একাধিক থ্রেডের ক্ষেত্রে ডেটা নিরাপদ থাকে।
Lock-Free Synchronization: লক ব্যবহার ছাড়াই ডেটা ম্যানিপুলেশন করা যায়।
High Performance: Synchronization blocks বা locks এর তুলনায় দ্রুত কাজ করে।

Atomic Arrays এর সীমাবদ্ধতা

Fixed Size: Atomic Arrays এর আকার একবার নির্ধারণ করার পর পরিবর্তন করা যায় না।
Single Type: প্রতিটি অ্যারে শুধুমাত্র একটি নির্দিষ্ট ডেটা টাইপ (যেমন Integer, Long) ধারণ করতে পারে।
Complex Logic: জটিল লজিক বা ডেটা স্ট্রাকচার ব্যবহারের ক্ষেত্রে অতিরিক্ত ব্যবস্থাপনার প্রয়োজন হতে পারে।

উপসংহার

Atomic Arrays মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটা ম্যানিপুলেশনের সময় synchronization এবং atomicity নিশ্চিত করার জন্য একটি কার্যকর সমাধান। এর মেথডগুলো যেমন get(), set(), getAndAdd(), এবং compareAndSet() মাল্টি-থ্রেডিংয়ের চ্যালেঞ্জ মোকাবিলায় বিশেষ ভূমিকা রাখে। এটি উচ্চ-পারফরম্যান্স অ্যাপ্লিকেশন এবং ডেটা সঠিকতা বজায় রাখার জন্য অত্যন্ত উপযোগী।

Content added By

SATT Academy

AtomicReferenceArray:

269

AtomicReferenceArray হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা array of references (অবজেক্ট রেফারেন্স) এর উপর atomic operations সম্পাদন করার জন্য ব্যবহৃত হয়। এটি মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে thread-safe উপায়ে রেফারেন্স ভ্যালু পরিবর্তন এবং পরিচালনা করতে ব্যবহৃত হয়।

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

Thread Safety: একাধিক থ্রেড একই সময় একটি রেফারেন্স পরিবর্তন করার চেষ্টা করলেও ডেটা সঠিক থাকে।
Immutable Array: অ্যারের দৈর্ঘ্য immutable অর্থাৎ একবার সেট করার পর পরিবর্তন করা যায় না।
Atomicity: প্রতিটি অপারেশন atomic অর্থাৎ বিভাজ্য নয়, যা ডেটার সঠিকতা নিশ্চিত করে।
Reference Management: এটি অ্যারের প্রতিটি রেফারেন্সের মান পৃথকভাবে এবং নিরাপদভাবে পরিচালনা করতে পারে।

কনস্ট্রাক্টর

AtomicReferenceArray দুটি প্রধান কনস্ট্রাক্টর প্রদান করে:

AtomicReferenceArray(int length):
নির্দিষ্ট আকারের একটি অ্যারে তৈরি করে, যেখানে প্রতিটি এলিমেন্ট শুরুতে null থাকে।
```
AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(5); // ৫ এলিমেন্টের অ্যারে
```
AtomicReferenceArray(T[] array):
একটি বিদ্যমান অ্যারে থেকে নতুন AtomicReferenceArray তৈরি করে। বিদ্যমান অ্যারের পরিবর্তনগুলি নতুন অ্যারেতে প্রতিফলিত হয় না।
```
String[] array = {"A", "B", "C"};
AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(array);
```

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

get(int index)

বর্ণনা: নির্দিষ্ট index এ থাকা ভ্যালু রিটার্ন করে।

উদাহরণ:

System.out.println(atomicArray.get(0)); // আউটপুট: "A"

set(int index, E newValue)

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

উদাহরণ:

atomicArray.set(1, "New B");
System.out.println(atomicArray.get(1)); // আউটপুট: "New B"

compareAndSet(int index, E expect, E update)

বর্ণনা:
যদি index-এ থাকা ভ্যালু expect এর সমান হয়, তবে এটি update মানে আপডেট করে এবং true রিটার্ন করে। অন্যথায় কিছুই পরিবর্তন করে না এবং false রিটার্ন করে।

উদাহরণ:

boolean result = atomicArray.compareAndSet(1, "New B", "Updated B");
System.out.println(result); // আউটপুট: true
System.out.println(atomicArray.get(1)); // আউটপুট: "Updated B"

getAndSet(int index, E newValue)

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

উদাহরণ:

String oldValue = atomicArray.getAndSet(2, "New C");
System.out.println(oldValue); // আউটপুট: "C"
System.out.println(atomicArray.get(2)); // আউটপুট: "New C"

lazySet(int index, E newValue)

বর্ণনা:
এটি set() এর মতো কাজ করে তবে কিছু অপ্টিমাইজেশনের জন্য "lazy" উপায়ে মান আপডেট করে। সাধারণত এটি একসঙ্গে চলমান থ্রেডগুলোর জন্য কার্যকর।
উদাহরণ:
```
atomicArray.lazySet(3, "Lazy D");
```

length()

বর্ণনা: অ্যারের দৈর্ঘ্য রিটার্ন করে।

উদাহরণ:

System.out.println(atomicArray.length()); // আউটপুট: ৫

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

import java.util.concurrent.atomic.AtomicReferenceArray;

public class AtomicReferenceArrayExample {
    public static void main(String[] args) {
        // বিদ্যমান অ্যারে থেকে AtomicReferenceArray তৈরি
        String[] array = {"A", "B", "C", "D", "E"};
        AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(array);

        // মান পড়া এবং সেট করা
        System.out.println("Initial Value at index 1: " + atomicArray.get(1)); // আউটপুট: B
        atomicArray.set(1, "Updated B");
        System.out.println("Updated Value at index 1: " + atomicArray.get(1)); // আউটপুট: Updated B

        // compareAndSet ব্যবহার
        boolean isUpdated = atomicArray.compareAndSet(2, "C", "Updated C");
        System.out.println("Compare and Set Result: " + isUpdated); // আউটপুট: true
        System.out.println("Value at index 2: " + atomicArray.get(2)); // আউটপুট: Updated C

        // getAndSet ব্যবহার
        String oldValue = atomicArray.getAndSet(3, "Updated D");
        System.out.println("Old Value at index 3: " + oldValue); // আউটপুট: D
        System.out.println("New Value at index 3: " + atomicArray.get(3)); // আউটপুট: Updated D
    }
}

AtomicReferenceArray এর সুবিধা

Thread Safety: মাল্টি-থ্রেডিংয়ের জন্য উপযোগী।
Atomicity: প্রতিটি মেথড ডেটা ম্যানিপুলেশনে atomic operation নিশ্চিত করে।
Flexibility: এটি অবজেক্ট রেফারেন্স ব্যবহার করে, যা প্রায় সব ধরনের ডেটা মডেল পরিচালনা করতে পারে।
Performance: লক-মুক্ত (lock-free) পদ্ধতি হওয়ায় পারফরম্যান্স উন্নত করে।

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

Fixed Size: অ্যারের আকার নির্দিষ্ট করার পরে পরিবর্তন করা যায় না।
Complexity: সাধারণ array পরিচালনার তুলনায় কিছুটা জটিল।
Overhead: থ্রেড-সেফ অপারেশন নিশ্চিত করার জন্য কিছু পারফরম্যান্স ওভারহেড তৈরি হতে পারে।

AtomicReferenceArray মাল্টি-থ্রেডেড পরিবেশে array of references পরিচালনার জন্য একটি কার্যকর সমাধান, যেখানে থ্রেড সেফটি এবং ডেটার সঠিকতা গুরুত্বপূর্ণ। এটি বিশেষ করে ডেটা ম্যানিপুলেশনের ক্ষেত্রে atomicity নিশ্চিত করে।

Content added By

SATT Academy

Generics এর সাথে Reference Arrays

328

AtomicReferenceArray হল java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা reference arrays এর উপরে atomic operations সম্পন্ন করতে ব্যবহৃত হয়। এটি Generics এর সাথে ব্যবহার করা যায় এবং থ্রেড-সেফ (thread-safe) পদ্ধতিতে reference types পরিচালনা করতে সাহায্য করে।

AtomicReferenceArray কী?

এটি একটি atomic array of objects যেখানে প্রতিটি অপারেশন thread-safe।
Generics ব্যবহার করে বিভিন্ন ধরনের ডেটা (যেমন String, Object, Custom Class) এর উপর কাজ করতে পারে।
এটি লক-মুক্ত (lock-free) অপারেশন সরবরাহ করে, যার ফলে উচ্চ কার্যক্ষমতা বজায় থাকে।
Thread Safety নিশ্চিত করে একাধিক থ্রেড একযোগে ডেটা ম্যানিপুলেট করলেও ডেটা সঠিক থাকে।

AtomicReferenceArray এর প্রধান বৈশিষ্ট্য

Atomic Operations: প্রতিটি অপারেশন যেমন get(), set(), এবং compareAndSet() indivisible বা অখণ্ড।
Thread-Safe: একাধিক থ্রেড একই সময়ে ডেটা অ্যাক্সেস বা পরিবর্তন করলেও ডেটা দুর্নীতি হয় না।
Generics Support: এটি যেকোনো reference type (Generics) এর জন্য ব্যবহারযোগ্য।
Non-blocking Performance: লক ছাড়াই ডেটা পরিচালিত হয়, যা কার্যক্ষমতা বাড়ায়।
Immutability of Size: একটি AtomicReferenceArray এর সাইজ তৈরি হওয়ার পরে পরিবর্তন করা যায় না।

AtomicReferenceArray তৈরি করা

import java.util.concurrent.atomic.AtomicReferenceArray;

public class AtomicReferenceArrayExample {
    public static void main(String[] args) {
        // AtomicReferenceArray তৈরি
        AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(5);

        // ডেটা সেট করা
        atomicArray.set(0, "Java");
        atomicArray.set(1, "Python");
        atomicArray.set(2, "C++");

        // ডেটা পড়া
        System.out.println("Index 0: " + atomicArray.get(0)); // Output: Java
        System.out.println("Index 1: " + atomicArray.get(1)); // Output: Python

        // compareAndSet ব্যবহার
        boolean updated = atomicArray.compareAndSet(1, "Python", "JavaScript");
        System.out.println("Updated: " + updated); // Output: true
        System.out.println("Index 1: " + atomicArray.get(1)); // Output: JavaScript
    }
}

AtomicReferenceArray এর মেথডসমূহ

১. get(int index)

নির্দিষ্ট index থেকে মান পড়ে।

String value = atomicArray.get(0); // Index 0 থেকে ডেটা পড়ে

২. set(int index, E newValue)

নির্দিষ্ট index এ একটি নতুন মান সেট করে।

atomicArray.set(1, "Python"); // Index 1 এ Python সেট

৩. compareAndSet(int index, E expected, E newValue)

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

boolean isUpdated = atomicArray.compareAndSet(1, "Python", "JavaScript");

৪. getAndSet(int index, E newValue)

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

String oldValue = atomicArray.getAndSet(2, "C#");

৫. length()

অ্যারের সাইজ রিটার্ন করে।

int size = atomicArray.length(); // আউটপুট: 5

AtomicReferenceArray ব্যবহার কেন গুরুত্বপূর্ণ?

১. Thread-Safe Arrays

একাধিক থ্রেড যখন একটি reference array এর উপরে কাজ করে, তখন AtomicReferenceArray ডেটা সঠিকতা নিশ্চিত করে।

২. Generics এর সমর্থন

Generics এর মাধ্যমে এটি বিভিন্ন ডেটা টাইপের সাথে ব্যবহার করা যায়, যেমন Strings, Custom Objects, ইত্যাদি।

৩. Race Condition প্রতিরোধ

প্রতিটি অপারেশন atomic হওয়ার কারণে race condition প্রতিরোধ করা যায়।

৪. Performance Optimization

লক-মুক্ত (lock-free) অপারেশন পারফরম্যান্স বাড়ায় এবং synchronization overhead হ্রাস করে।

উদাহরণ: Custom Class এর সাথে Generics ব্যবহার

import java.util.concurrent.atomic.AtomicReferenceArray;

class Product {
    String name;
    double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return name + " - $" + price;
    }
}

public class CustomClassExample {
    public static void main(String[] args) {
        // Custom Class এর জন্য AtomicReferenceArray
        AtomicReferenceArray<Product> productArray = new AtomicReferenceArray<>(3);

        // প্রোডাক্ট যুক্ত করা
        productArray.set(0, new Product("Laptop", 999.99));
        productArray.set(1, new Product("Smartphone", 599.99));

        // প্রোডাক্ট পড়া
        System.out.println("Index 0: " + productArray.get(0)); // Output: Laptop - $999.99
        System.out.println("Index 1: " + productArray.get(1)); // Output: Smartphone - $599.99

        // compareAndSet ব্যবহার
        boolean updated = productArray.compareAndSet(1, 
                                new Product("Smartphone", 599.99), 
                                new Product("Tablet", 399.99));
        System.out.println("Updated: " + updated); // Output: false
    }
}

AtomicReferenceArray এর সুবিধা

Thread-Safe Reference Management: অ্যারেতে একাধিক থ্রেড কাজ করলেও ডেটা নিরাপদ থাকে।
Generics Support: যেকোনো টাইপের ডেটার সাথে ব্যবহার করা যায়।
Race Condition প্রতিরোধ: থ্রেডের মধ্যে ডেটা কনসিস্টেন্সি নিশ্চিত করে।
High Performance: লক ছাড়াই ডেটা পরিচালিত হয়।

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

Immutable Size: অ্যারের সাইজ তৈরি হওয়ার পরে পরিবর্তন করা যায় না।
Complexity: সহজ অ্যারের তুলনায় ব্যবহার কিছুটা জটিল।
Generics Comparisons: compareAndSet() শুধুমাত্র reference equality চেক করে, deep equality নয়।

উপসংহার

AtomicReferenceArray মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে reference types পরিচালনার জন্য একটি কার্যকর সমাধান। এটি thread safety, atomicity, এবং high performance নিশ্চিত করে। Generics এর সমর্থনের মাধ্যমে এটি আরও কার্যকর হয়ে ওঠে, বিশেষত যেখানে ডেটা কনসিস্টেন্সি এবং রেস কন্ডিশন প্রতিরোধ গুরুত্বপূর্ণ।

Content added By

SATT Academy

Methods: get(), set(), compareAndSet()

336

AtomicReferenceArray Java এর একটি ক্লাস যা atomic operations সহ reference arrays পরিচালনা করার জন্য ব্যবহৃত হয়। এটি java.util.concurrent.atomic প্যাকেজের অংশ, যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ব্যবহৃত হয় এবং থ্রেড-সেফ ডেটা অপারেশন সমর্থন করে।

এই ক্লাসে বিভিন্ন গুরুত্বপূর্ণ মেথড আছে, যেগুলি ডেটা এক্সেস ও আপডেট করার সময় থ্রেড-সেফনেস নিশ্চিত করে। এখানে get(), set(), এবং compareAndSet() মেথডগুলোর বিস্তারিত আলোচনা করা হলো।

১. `get(int index)` Method

get() মেথড একটি নির্দিষ্ট index থেকে অ্যারের মান পড়ে। এটি একটি থ্রেড-সেফ অপারেশন, অর্থাৎ একাধিক থ্রেড একই অ্যারের একাধিক উপাদান পড়লেও ডেটা সঠিকভাবে রিটার্ন হবে।

সিনট্যাক্স:

public E get(int index)

প্যারামিটার:

index: অ্যারের index যার মান আপনি পড়তে চান।

রিটার্ন:

রিটার্ন করে index তে থাকা মান (যে ধরনের অবজেক্ট অ্যারে ধারণ করে)।

উদাহরণ:

AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(5);
atomicArray.set(0, "Hello");
atomicArray.set(1, "World");

String value = atomicArray.get(0);
System.out.println(value); // আউটপুট: Hello

২. `set(int index, E newValue)` Method

set() মেথড একটি নির্দিষ্ট index তে নতুন মান সেট করে। এই অপারেশনটি atomic এবং থ্রেড-সেফ, অর্থাৎ একাধিক থ্রেড একই সময় একই index এ মান সেট করতে পারবে না।

সিনট্যাক্স:

public void set(int index, E newValue)

প্যারামিটার:

index: অ্যারের index যেখানে মানটি সেট করতে চান।
newValue: নতুন মান যা index তে সেট করা হবে।

উদাহরণ:

AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(5);
atomicArray.set(0, "Hello");
atomicArray.set(1, "World");

// নতুন মান সেট করা
atomicArray.set(0, "Hi");
System.out.println(atomicArray.get(0)); // আউটপুট: Hi

৩. `compareAndSet(int index, E expect, E update)` Method

compareAndSet() একটি atomic অপারেশন যা নির্দিষ্ট index তে expect মানের সাথে তুলনা করে এবং যদি তা মেলে তবে update মান সেট করে। এটি একটি compare-and-swap (CAS) অপারেশন। এটি মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে race condition প্রতিরোধে সহায়ক।

সিনট্যাক্স:

public boolean compareAndSet(int index, E expect, E update)

প্যারামিটার:

index: অ্যারের index যেটিতে আপনি কাজ করতে চান।
expect: যেই মানটি index তে উপস্থিত থাকতে হবে, যাতে update মান সেট করা যাবে।
update: নতুন মান যা expect এর সাথে মিললে index এ সেট হবে।

রিটার্ন:

true: যদি index তে expect মান মিলে যায় এবং তা সফলভাবে update হয়।
false: যদি index তে expect মান না মেলে এবং কোন আপডেট না হয়।

উদাহরণ:

AtomicReferenceArray<String> atomicArray = new AtomicReferenceArray<>(5);
atomicArray.set(0, "Hello");

boolean isUpdated = atomicArray.compareAndSet(0, "Hello", "Hi");
System.out.println("Updated: " + isUpdated); // আউটপুট: Updated: true
System.out.println(atomicArray.get(0)); // আউটপুট: Hi

// যদি মান না মেলে
boolean isUpdatedFailed = atomicArray.compareAndSet(0, "World", "Java");
System.out.println("Updated: " + isUpdatedFailed); // আউটপুট: Updated: false

`get()`, `set()`, এবং `compareAndSet()` এর মধ্যে পার্থক্য

get() শুধুমাত্র অ্যারের নির্দিষ্ট index তে থাকা মান পড়ে এবং কোনো পরিবর্তন করে না।
set() নির্দিষ্ট index তে একটি নতুন মান সেট করে এবং এটি সরাসরি ডেটাকে আপডেট করে।
compareAndSet() প্রথমে একটি expect মানের সাথে তুলনা করে, যদি তা মেলে তবে update মান সেট করা হয়। এটি একটি তুলনা এবং পরিবর্তন (CAS) অপারেশন যা thread-safety নিশ্চিত করে এবং race condition প্রতিরোধে ব্যবহৃত হয়।

AtomicReferenceArray মেথডগুলি যেমন get(), set(), এবং compareAndSet() মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে thread-safe অ্যারের অপারেশন সঞ্চালনে অত্যন্ত কার্যকর।

get() মান পড়ে,
set() মান আপডেট করে,
compareAndSet() সুনির্দিষ্ট মানের সাথে তুলনা করে এবং শুধু তখনই সেট করে যখন পূর্বের মান মেলে।

এগুলি atomic operations প্রদান করে, যা অ্যারে-এ ডেটার সঠিকতা এবং সুরক্ষা নিশ্চিত করে, বিশেষত যখন একাধিক থ্রেড একই অ্যারে ব্যবহার করে।

Content added By

SATT Academy

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