Concurrency এবং Multithreading (কনকারেন্সি এবং মাল্টিথ্রেডিং)

কনকারেন্সি (Concurrency) এবং মাল্টিথ্রেডিং (Multithreading) হল দুটি গুরুত্বপূর্ণ ধারণা যা একটি প্রোগ্রামে একাধিক কাজ একযোগে পরিচালনা করতে ব্যবহৃত হয়। এই ধারণাগুলি ব্যবহার করে, আপনি অ্যাপ্লিকেশনের কার্যক্ষমতা বৃদ্ধি করতে পারেন, বিশেষত যখন আপনার অ্যাপ্লিকেশন অনেক সময় ব্যয়কারী কাজের সাথে কাজ করে (যেমন I/O অপারেশন, নেটওয়ার্কিং, ডেটাবেস অ্যাক্সেস ইত্যাদি)।

রুবিতে কনকারেন্সি এবং মাল্টিথ্রেডিং দুটি খুবই গুরুত্বপূর্ণ বিষয়, তবে রুবির GIL (Global Interpreter Lock) এর কারণে মাল্টিথ্রেডিং এর কিছু সীমাবদ্ধতা রয়েছে। তবুও, রুবি মাল্টিথ্রেডিং এবং কনকারেন্সি ব্যবস্থাপনার জন্য কিছু শক্তিশালী লাইব্রেরি এবং টুলস সরবরাহ করে, যেমন Thread, Fiber, Queue, এবং Concurrent::Ruby।

এখানে আমরা কনকারেন্সি এবং মাল্টিথ্রেডিং এর বিভিন্ন কনসেপ্ট এবং উদাহরণ নিয়ে আলোচনা করব।

১. Multithreading in Ruby (মাল্টিথ্রেডিং)

মাল্টিথ্রেডিং হল একটি প্রোগ্রামিং কৌশল যেখানে একাধিক থ্রেড একসাথে চলতে পারে, একে অন্যের সাথে পারস্পরিক ভাবে কাজ করে। থ্রেডগুলি সাধারণত একে অপরের সাথে ভাগ করা ডেটা এবং রিসোর্স ব্যবহার করে।

Ruby Thread (রুবি থ্রেড)

রুবিতে থ্রেড তৈরি করার জন্য Thread ক্লাস ব্যবহৃত হয়। এটি একাধিক কাজ একে একে বা параллেলভাবে সম্পাদন করতে সাহায্য করে।

উদাহরণ: একটি সাধারণ থ্রেড

# Creating a thread
thread = Thread.new do
  5.times do |i|
    puts "Thread 1: #{i}"
    sleep(1)
  end
end

# Main thread continues to run
5.times do |i|
  puts "Main thread: #{i}"
  sleep(1)
end

# Wait for the thread to finish
thread.join

এখানে, মূল থ্রেডের পাশাপাশি একটি নতুন থ্রেড Thread.new এর মাধ্যমে তৈরি করা হয়েছে, এবং এটি স্বতন্ত্রভাবে ৫টি বার "Thread 1" মেসেজ প্রিন্ট করবে। join মেথডটি মূল থ্রেডকে থ্রেডটির কাজ শেষ হওয়া পর্যন্ত অপেক্ষা করতে বাধ্য করবে।

থ্রেডের মধ্যে ডেটা শেয়ারিং

একাধিক থ্রেডের মধ্যে ডেটা শেয়ার করার জন্য সিঙ্ক্রোনাইজেশন ব্যবহার করা হয়, যাতে ডেটার সাথে একযোগে একাধিক থ্রেড কাজ করতে না পারে এবং ডেটা ত্রুটিপূর্ণ না হয়। রুবিতে Mutex (Mutual Exclusion) ব্যবহার করা হয় এই উদ্দেশ্যে।

mutex = Mutex.new

counter = 0
threads = []

5.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
      puts "Counter: #{counter}"
    end
  end
end

# Wait for all threads to finish
threads.each(&:join)

এখানে, Mutex.new একটি মিউটেক্স তৈরি করেছে এবং synchronize ব্লকের মধ্যে একে অপরের সাথে ডেটা শেয়ার করার সময় কেবল একটি থ্রেডের জন্য এক্সেস অনুমোদিত হয়েছে।

২. Concurrency in Ruby (কনকারেন্সি)

কনকারেন্সি হল একাধিক কাজ একে একে, কিন্তু একই সময় ব্লক না করে সম্পাদন করা। এটি বাস্তবে প্যারালেল প্রসেসিং নয়, বরং একাধিক কাজ সমান্তরালভাবে কাজ করতে পারে এমন একটি কৌশল। কনকারেন্সি কার্যকরী হতে পারে থ্রেডিং বা কোঅপারেটিভ মাল্টিটাস্কিং এর মাধ্যমে, তবে মাল্টিথ্রেডিং সবসময় প্যারালেল এক্সিকিউশন নয়।

Fiber (ফাইবার)

রুবিতে, Fiber একটি কনকারেন্ট প্রোগ্রামিং কৌশল, যা মাল্টিথ্রেডিংয়ের মত কার্য করে, তবে এটি কিছুটা আলাদা। ফাইবারগুলি একযোগভাবে কাজ করতে পারে এবং এগুলি সাধারণত কোঅপারেটিভ মুলটিটাস্কিং এর মধ্যে ব্যবহৃত হয়, যার মানে হল যে, ফাইবারগুলির কাজ যখন শেষ হবে, তখন অন্য ফাইবার চালু হবে।

উদাহরণ: Fiber ব্যবহার করা

fiber1 = Fiber.new do
  3.times do |i|
    puts "Fiber 1: #{i}"
    Fiber.yield
  end
end

fiber2 = Fiber.new do
  3.times do |i|
    puts "Fiber 2: #{i}"
    Fiber.yield
  end
end

# Running fibers
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume

এখানে, Fiber ব্যবহার করা হয়েছে দুইটি ফাইবার তৈরি করতে, এবং Fiber.yield দিয়ে তাদের মধ্যে স্যুইচিং করা হয়েছে।

৩. Thread Pooling (থ্রেড পুলিং)

রুবিতে Thread Pool হল একটি কৌশল, যেখানে একাধিক থ্রেড তৈরি করে তাদের একটি পুলে রাখা হয় এবং সেই থ্রেডগুলি প্রয়োজন অনুসারে পুনরায় ব্যবহার করা হয়। থ্রেড পুল ব্যবহার করা হয় যখন থ্রেডের তৈরি এবং ধ্বংস করার খরচ কমাতে হয়।

Concurrent::Ruby এর মধ্যে ThreadPoolExecutor ব্যবহার করে আপনি থ্রেড পুল তৈরি করতে পারেন।

require 'concurrent'

pool = Concurrent::ThreadPoolExecutor.new(
  min_threads: 2,
  max_threads: 10,
  max_queue: 100
)

# Submit tasks to the pool
10.times do |i|
  pool.post do
    puts "Processing task #{i}"
    sleep(1)
  end
end

# Wait for all tasks to complete
pool.shutdown
pool.wait_for_termination

এখানে, Concurrent::ThreadPoolExecutor ব্যবহার করে ২ থেকে ১০ থ্রেডের মধ্যে থ্রেড পুল তৈরি করা হয়েছে এবং ১০টি টাস্ক সমান্তরালে প্রসেস করা হচ্ছে।

৪. GIL (Global Interpreter Lock) in Ruby

রুবি’র GIL (Global Interpreter Lock) হলো একটি সমস্যা যেখানে একটাই থ্রেড এক সময়ে কোডের একটিই অংশ এক্সিকিউট করতে পারে। এটি মাল্টিথ্রেডিংয়ের পারফর্ম্যান্সে কিছুটা প্রভাব ফেলতে পারে। কিন্তু যখন আপনি I/O অপারেশন (যেমন, ফাইল রিড/রাইট, নেটওয়ার্ক কল) করতে চান, তখন একাধিক থ্রেড সহজেই কার্যকরী হতে পারে কারণ GIL মূলত CPU-bound কাজগুলিতে প্রভাব ফেলে।

GIL এর প্রভাব:

threads = []
10.times do
  threads << Thread.new do
    # CPU-bound operation, GIL will prevent true parallelism
    puts "Thread started"
  end
end

threads.each(&:join)

এখানে, GIL এর কারণে একে অপরের সাথে থ্রেডগুলোকে সম্পূর্ণ প্যারালেলভাবে এক্সিকিউট হতে দেওয়া হচ্ছে না।

৫. Synchronization (সিঙ্ক্রোনাইজেশন)

একাধিক থ্রেড যখন একই রিসোর্স (যেমন ভেরিয়েবল, ডেটা) শেয়ার করে তখন synchronization খুবই গুরুত্বপূর্ণ। Mutex (Mutual Exclusion) এবং ConditionVariable রুবির সিঙ্ক্রোনাইজেশন টুল, যা থ্রেডগুলিকে একই রিসোর্সে একযোগভাবে অ্যাক্সেসের অনুমতি দেয়।

উদাহরণ: Mutex ব্যবহার করা

mutex = Mutex.new
counter = 0
threads = []

10.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
    end
  end
end

threads.each(&:join)
puts "Final counter: #{counter}"  # Output: Final counter: 10

এখানে, Mutex.synchronize ব্লকটি ব্যবহৃত হয়েছে, যাতে একে অপরের সাথে থ্রেডগুলো ডেটা শেয়ার করার সময় কোনো সমস্যা না হয়।

সারসংক্ষেপ

• Multithreading রুবিতে একাধিক থ্রেড ব্যবহার করে একাধিক কাজ সমান্তরালে করা হয়, তবে GIL এর কারণে একাধিক CPU-bound কাজ একসাথে কার্যকরী হতে পারে না।
• Concurrency হল এমন একটি কৌশল, যেখানে একাধিক কাজ একই সময়ে চলছে না, তবে তা সময় ভাগ করে সম্পাদিত হচ্ছে।
• Fiber রুবিতে কনকারেন্সি হ্যান্ডল করতে ব্যবহৃত হয়, যেগুলো কোঅপারেটিভ মাল্টিটাস্কিং এ কাজ করে।
• Thread Pooling একাধিক থ্রেডের সাথে কাজ করার জন্য একটি পুল তৈরি করে, যার মাধ্যমে থ্রেড পুনঃব্যবহার করা যায়।
• **

Mutex** এবং ConditionVariable ব্যবহারের মাধ্যমে একাধিক থ্রেডের মধ্যে ডেটা শেয়ারিং সিঙ্ক্রোনাইজ করা হয়।

এগুলি রুবিতে কনকারেন্সি এবং মাল্টিথ্রেডিং এর মৌলিক ধারণা এবং তাদের প্রয়োগের ক্ষেত্রে সহায়ক।

Threads এবং Processes হল কম্পিউটারের সিস্টেমে একাধিক কাজ একযোগে চালানোর (concurrent execution) জন্য ব্যবহৃত দুটি গুরুত্বপূর্ণ ধারণা। যদিও তারা একে অপরের সাথে সম্পর্কিত, তবে তাদের মধ্যে কিছু মৌলিক পার্থক্য রয়েছে।

রুবিতে Threads এবং Processes ব্যবহৃত হয় কোডের একাধিক অংশকে একসাথে রান করতে, যার ফলে প্রোগ্রাম দ্রুত এবং দক্ষভাবে কাজ করতে পারে।

Processes (প্রসেস)

Process হল একটি প্রোগ্রামের এক্সিকিউটিং (চলমান) কপি। যখন একটি প্রোগ্রাম রান করা হয়, তখন এটি একটি প্রসেস তৈরি করে। প্রতিটি প্রসেসের নিজস্ব মেমরি স্পেস (address space), প্রোগ্রাম কাউন্টার, রেজিস্টার, এবং অন্যান্য সম্পদ থাকে। একাধিক প্রসেস একে অপরের থেকে সম্পূর্ণ পৃথক থাকে এবং তারা সাধারণত একে অপরের মেমরি অ্যাক্সেস করতে পারে না।

Process এর বৈশিষ্ট্য:

• একটি একক প্রসেসে একটি অ্যাড্রেস স্পেস থাকে: প্রতিটি প্রসেস আলাদা মেমরি ব্যবহার করে এবং অন্য প্রসেসের মেমরি অ্যাক্সেস করতে পারে না (except for shared memory areas).
• প্রসেস ম্যানেজমেন্ট: অপারেটিং সিস্টেম প্রসেসের জন্য রিসোর্স বরাদ্দ করে এবং সেগুলির মধ্যে যোগাযোগ এবং সমন্বয় (synchronization) নিয়ন্ত্রণ করে।
• প্রসেস প্রক্রিয়া: একাধিক প্রসেস একসাথে রান হতে পারে, কিন্তু তারা সম্পূর্ণভাবে পৃথক থাকে এবং একে অপরকে প্রভাবিত করে না।

উদাহরণ:

ধরা যাক, আপনি একটি ওয়েব সার্ভার চালাচ্ছেন যা একাধিক HTTP রিকোয়েস্ট প্রসেস করে। এখানে, প্রতিটি HTTP রিকোয়েস্টকে একটি পৃথক প্রসেস হিসেবে ভাবা যেতে পারে।

রুবি দিয়ে প্রসেস তৈরি:

pid = Process.fork
if pid.nil?
  # Child process
  puts "This is the child process"
else
  # Parent process
  puts "This is the parent process"
end

এখানে, Process.fork ব্যবহার করে একটি নতুন প্রসেস তৈরি করা হয়েছে। এটি মূল প্রসেসের একটি কপি তৈরি করে, যেখানে পরবর্তীতে আলাদা কোড এক্সিকিউট করা হয়।

Threads (থ্রেডস)

Thread হল একটি ছোট একক এক্সিকিউটিং ইউনিট, যা একটি প্রসেসের মধ্যে রান করে। থ্রেড একটি প্রসেসের অংশ হিসেবে কাজ করে এবং প্রসেসের মেমরি স্পেস শেয়ার করে, তবে এটি অন্যান্য থ্রেডের থেকে আলাদা কোড চালায়। একাধিক থ্রেড একসাথে চলতে পারে, যার ফলে একই প্রোগ্রাম একাধিক কাজ (tasks) করতে সক্ষম হয়।

Thread এর বৈশিষ্ট্য:

• একাধিক থ্রেড একই মেমরি শেয়ার করে: একটি থ্রেডের জন্য মেমরি বরাদ্দ থাকে না; বরং এটি প্রসেসের মধ্যে মেমরি শেয়ার করে। থ্রেডের মধ্যে থাকা ডেটা একই প্রক্রিয়ায় অ্যাক্সেস করা যেতে পারে।
• কম্পিউটার রিসোর্সের জন্য কম খরচ: থ্রেডের মধ্যে যোগাযোগ আরও দ্রুত হয় কারণ তারা একই মেমরি শেয়ার করে, তাই থ্রেডে সিঙ্ক্রোনাইজেশন করতে হয়।
• থ্রেড পুল: একাধিক থ্রেড ব্যবহার করে কাজটি দ্রুত করা যেতে পারে, বিশেষত অনেক ছোট কাজ একসাথে করতে হলে।

উদাহরণ:

ধরা যাক, একটি প্রোগ্রাম যেটি ফাইল থেকে ডেটা পড়ে এবং সেই ডেটা প্রসেস করে। এখানে, আপনি আলাদা থ্রেড ব্যবহার করতে পারেন, যাতে ফাইল পড়া এবং ডেটা প্রসেসিং একসাথে চলতে পারে।

রুবি দিয়ে থ্রেড তৈরি:

thread1 = Thread.new do
  5.times { |i| puts "Thread 1: #{i}" }
end

thread2 = Thread.new do
  5.times { |i| puts "Thread 2: #{i}" }
end

thread1.join
thread2.join

এখানে, দুটি আলাদা থ্রেড (thread1 এবং thread2) তৈরি করা হয়েছে, যা তাদের নিজস্ব কাজ করছে। join মেথডটি ব্যবহার করে আমরা থ্রেডগুলোর কাজ শেষ হওয়া পর্যন্ত অপেক্ষা করি।

Threads এবং Processes এর মধ্যে পার্থক্য

Threads এবং Processes এর ব্যবহার

• Threads:
  • সিঙ্ক্রোনাস কাজের জন্য, যেমন একাধিক কাজ একসাথে করার জন্য, যেমন ফাইল অপারেশন, নেটওয়ার্ক কল ইত্যাদি।
  • ডেটা প্রসেসিং বা ইভেন্ট লুপ সিস্টেমের জন্য উপযুক্ত।
• Processes:
  • যখন সম্পূর্ণ আলাদা কাজ চলতে হবে, যেমন একটি বড় অ্যাপ্লিকেশন যা একাধিক কাজ পরিচালনা করে, যেমন একাধিক ইউজারের জন্য পৃথক সেশন পরিচালনা।

রুবিতে Threads এবং Processes এর কার্যকারিতা

রুবি থ্রেড এবং প্রসেস ব্যবহার করার সুবিধা হল:

1. Threads: একাধিক কাজ একসাথে চালাতে পারেন, যেমন ফাইল পড়া এবং লেখা।
2. Processes: একাধিক কোড একসাথে রান করতে পারেন, যা পৃথক মেমরি স্পেস এবং সম্পদ ব্যবহারের মাধ্যমে নির্দিষ্ট কাজ সম্পাদন করতে সক্ষম।

রুবি থ্রেড এবং প্রসেস ব্যবহারের মাধ্যমে আপনি আপনার প্রোগ্রামকে আরও কার্যকর এবং দ্রুত করতে পারেন।

Multithreading হলো এমন একটি কৌশল, যেখানে একসাথে একাধিক থ্রেড চলতে পারে, ফলে একই প্রোগ্রামের মধ্যে বিভিন্ন কাজ একসাথে (parallel) বা আলাদা আলাদা সময় (concurrent) এ সম্পন্ন হতে পারে। রুবি ভাষায় multithreading ব্যবহার করে আপনি একাধিক থ্রেডের মাধ্যমে ডেটা প্রসেসিং, I/O অপারেশন, বা লম্বা সময়ের কাজ গুলি দ্রুত সম্পন্ন করতে পারেন।

রুবি থ্রেডিং ম্যানেজমেন্ট Thread ক্লাসের মাধ্যমে করা হয়, যা রুবির একটি গুরুত্বপূর্ণ কম্পোনেন্ট। এটি আপনাকে একাধিক থ্রেড তৈরি, থ্রেডগুলোর মধ্যে সমন্বয় এবং থ্রেডগুলির মধ্যে ডেটা শেয়ার করার সুযোগ দেয়।

১. Thread ক্লাসের মাধ্যমে Multithreading

রুবিতে Thread ক্লাস ব্যবহার করে নতুন থ্রেড তৈরি এবং পরিচালনা করা হয়। এটি থ্রেডের মধ্যে কোড এক্সিকিউট করে এবং Thread.new ব্যবহার করে নতুন থ্রেড শুরু করা হয়।

Thread.new Syntax:

thread = Thread.new do
  # কাজ যা থ্রেডে চলবে
end

একটি সাধারণ উদাহরণ:

# একটি থ্রেড তৈরি করা হচ্ছে
thread = Thread.new do
  5.times do |i|
    puts "Thread 1: #{i}"
    sleep(1)  # 1 সেকেন্ডের জন্য থ্রেডটি অপেক্ষা করবে
  end
end

# মেইন থ্রেডে আরেকটি কাজ
5.times do |i|
  puts "Main thread: #{i}"
  sleep(1)  # 1 সেকেন্ডের জন্য থ্রেডটি অপেক্ষা করবে
end

# থ্রেডটি শেষ হওয়া পর্যন্ত অপেক্ষা করা
thread.join

আউটপুট:

Main thread: 0
Thread 1: 0
Main thread: 1
Thread 1: 1
Main thread: 2
Thread 1: 2
Main thread: 3
Thread 1: 3
Main thread: 4
Thread 1: 4

এখানে, একটি নতুন থ্রেড তৈরি করা হয়েছে, যা ৫টি বার "Thread 1: X" মুদ্রণ করবে, এবং মেইন থ্রেডে অন্য একটি কাজ চলছে যা "Main thread: X" মুদ্রণ করবে। sleep(1) ব্যবহারের মাধ্যমে প্রতিটি থ্রেডে ১ সেকেন্ডের জন্য বিরতি দেওয়া হয়েছে।

২. Thread#join Method

join মেথড থ্রেডের কার্যক্রম সমাপ্ত হওয়ার জন্য অপেক্ষা করে। যদি আপনি চাইেন যে মেইন থ্রেড অন্য থ্রেডের কাজ শেষ না হওয়া পর্যন্ত অপেক্ষা করুক, তাহলে join ব্যবহার করতে হবে।

thread = Thread.new do
  5.times do |i|
    puts "Thread 1: #{i}"
    sleep(1)
  end
end

# মেইন থ্রেডে অন্য কাজ
puts "Main thread is waiting for Thread 1 to finish..."
thread.join  # Thread 1 এর কাজ শেষ না হওয়া পর্যন্ত অপেক্ষা করা হবে
puts "Thread 1 has finished."

এখানে, join মেথড ব্যবহার করে মেইন থ্রেড Thread 1 এর কাজ শেষ হওয়ার জন্য অপেক্ষা করছে।

৩. Thread Synchronization

একাধিক থ্রেড একসাথে কাজ করার সময় data consistency নিশ্চিত করার জন্য সিঙ্ক্রোনাইজেশন প্রয়োজন হয়। রুবি Mutex (Mutual Exclusion) ব্যবহার করে থ্রেডের মধ্যে সিঙ্ক্রোনাইজেশন নিশ্চিত করে।

Mutex Example:

mutex = Mutex.new

thread1 = Thread.new do
  mutex.synchronize do
    5.times do |i|
      puts "Thread 1: #{i}"
      sleep(1)
    end
  end
end

thread2 = Thread.new do
  mutex.synchronize do
    5.times do |i|
      puts "Thread 2: #{i}"
      sleep(1)
    end
  end
end

# থ্রেড শেষ হওয়া পর্যন্ত অপেক্ষা করা
thread1.join
thread2.join

এখানে, mutex.synchronize ব্যবহার করে আমরা প্রতিটি থ্রেডের কাজ সিঙ্ক্রোনাইজ করেছি, যাতে একসাথে থ্রেডগুলো একই রিসোর্স একসাথে এক্সেস না করে।

৪. Thread Pooling (থ্রেড পুলিং)

একাধিক থ্রেড তৈরি করার সময় অনেক ক্ষেত্রে একই ধরনের কাজের জন্য থ্রেড পুনরায় ব্যবহার করা হতে পারে, যা Thread Pooling এর মাধ্যমে করা হয়। রুবিতে Concurrent::Future বা ThreadPool গেমপ্যাক ব্যবহার করে থ্রেড পুল তৈরি করা সম্ভব।

Thread Pool Example (Concurrent Gem):

# Concurrent gem ইনস্টল করা
# gem install concurrent-ruby

require 'concurrent-ruby'

pool = Concurrent::ThreadPoolExecutor.new

# থ্রেড পুলে কাজ যোগ করা
10.times do |i|
  pool.post do
    puts "Task #{i} is being executed"
    sleep(1)
  end
end

# সব কাজ শেষ হওয়া পর্যন্ত অপেক্ষা করা
pool.shutdown
pool.wait_for_termination

এখানে, ThreadPoolExecutor ব্যবহার করে ১০টি টাস্ক পুলে যোগ করা হয়েছে এবং shutdown এর মাধ্যমে থ্রেড পুলটি বন্ধ হয়ে গেলে অপেক্ষা করা হচ্ছে।

৫. Thread Safety (থ্রেড সেফটি)

থ্রেড সেফটি নিশ্চিত করতে হলে আপনার কোড এমনভাবে লিখতে হবে যাতে একাধিক থ্রেড একসাথে একই রিসোর্স বা ডেটা পরিবর্তন করতে না পারে। এজন্য Mutex এবং Atomic Variables (যেমন Concurrent::Atomic) ব্যবহার করা যেতে পারে।

Thread Safety Example:

require 'concurrent-ruby'

counter = Concurrent::AtomicFixnum.new(0)

threads = []

5.times do
  threads << Thread.new do
    10.times do
      counter.increment
    end
  end
end

threads.each(&:join)

puts "Final counter value: #{counter.value}"

এখানে, Concurrent::AtomicFixnum ব্যবহার করে থ্রেড সেফভাবে একটি কাউন্টার ইনক্রিমেন্ট করা হয়েছে।

৬. থ্রেডের কিছু সীমাবদ্ধতা

রুবি তে থ্রেডিং ব্যবহারের সময় কিছু সীমাবদ্ধতা থাকে, যা মূলত Global Interpreter Lock (GIL) এর কারণে ঘটে। GIL হল একটি মেকানিজম যা একই সময়ে একাধিক থ্রেডকে সম্পূর্ণরূপে কার্যকরী হতে দেয় না, তবে এটি I/O অপারেশনগুলি (যেমন ফাইল বা নেটওয়ার্ক রিকোয়েস্ট) পরিচালনা করার জন্য কার্যকরী।

• CPU Bound Task: রুবিতে থ্রেডিং CPU-bound কাজগুলির জন্য খুব কার্যকরী নয়, কারণ GIL কেবল একটি থ্রেডকে একবারে CPU রিসোর্স দেওয়ার অনুমতি দেয়।
• I/O Bound Task: I/O অপারেশনের জন্য থ্রেডিং কার্যকরী, যেমন ওয়েব রিকোয়েস্ট, ফাইল রিড বা রাইট ইত্যাদি।

সারসংক্ষেপ

• Multithreading রুবিতে একাধিক থ্রেডের মাধ্যমে একযোগভাবে কাজ সম্পাদন করার জন্য ব্যবহৃত হয়।
• Thread ক্লাস দিয়ে নতুন থ্রেড তৈরি, এবং Thread.new ও Thread#join ব্যবহার করে থ্রেডের কার্যক্রম নিয়ন্ত্রণ করা হয়।
• Mutex ব্যবহার করে থ্রেড সিঙ্ক্রোনাইজেশন নিশ্চিত করা যায়।
• Thread Safety এবং Atomic Variables ব্যবহারের মাধ্যমে থ্রেড সেফটি নিশ্চিত করা সম্ভব।
• রুবিতে Global Interpreter Lock (GIL) এর কারণে CPU-bound কাজের ক্ষেত্রে থ্রেডিং সীমাবদ্ধ হতে পারে, তবে I/O-bound কাজের জন্য থ্রেডিং খুব কার্যকরী।

Concurrent Programming হচ্ছে একাধিক কাজ একযোগে সম্পন্ন করার প্রক্রিয়া, যেখানে একাধিক কার্যক্রম (threads বা processes) একে অপরের সাথে সমান্তরালভাবে (concurrently) কাজ করতে পারে। এটি ব্যবহৃত হয় যখন প্রোগ্রামটি একাধিক কাজ এক সাথে, সিমালটেনিয়াসলি সম্পন্ন করার ক্ষমতা রাখে। কনকারেন্ট প্রোগ্রামিংয়ের মূল লক্ষ্য হল ব্যবহৃত রিসোর্স (যেমন CPU) দক্ষভাবে ব্যবহার করা এবং কার্যক্রম দ্রুত শেষ করা।

রুবি ভাষায়, কনকারেন্ট প্রোগ্রামিং কিছু জনপ্রিয় কৌশল ব্যবহার করে, যেমন Threads, Fibers, Process Management, এবং Async I/O। এখানে আমরা এই কৌশলগুলি নিয়ে আলোচনা করব এবং কীভাবে এগুলি রুবিতে কার্যকরভাবে ব্যবহৃত হয় তা দেখাব।

১. Threads in Ruby

Threads হল রুবিতে কনকারেন্ট প্রোগ্রামিংয়ের একটি সাধারণ উপায়। একটি থ্রেড হলো একটি ছোট একক কার্যক্রম, যা একসাথে অন্যান্য থ্রেডের সাথে কার্যকরী হতে পারে। রুবিতে থ্রেড ব্যবহারে একাধিক কার্যক্রম একসাথে সম্পাদন করা সম্ভব।

Syntax:

thread = Thread.new do
  # code to execute in the thread
end

thread.join  # Wait for the thread to finish

উদাহরণ:

# Create two threads to run two tasks concurrently
thread1 = Thread.new do
  5.times do |i|
    puts "Thread 1: #{i}"
    sleep 1
  end
end

thread2 = Thread.new do
  5.times do |i|
    puts "Thread 2: #{i}"
    sleep 1
  end
end

# Wait for both threads to complete
thread1.join
thread2.join

আউটপুট:

Thread 1: 0
Thread 2: 0
Thread 1: 1
Thread 2: 1
Thread 1: 2
Thread 2: 2
Thread 1: 3
Thread 2: 3
Thread 1: 4
Thread 2: 4

এখানে দুটি থ্রেডে আলাদা আলাদা কার্যক্রম চলেছে এবং একই সময়ে কাজ হয়েছে, যার ফলে কার্যক্রম দ্রুত সমাপ্ত হয়েছে।

Thread Safety:

থ্রেড ব্যবহারের সময় Thread Safety নিশ্চিত করা গুরুত্বপূর্ণ, কারণ একাধিক থ্রেড একসাথে একটি কমন রিসোর্স ব্যবহার করতে পারে এবং এতে ডেটা কনফ্লিক্ট হতে পারে। রুবিতে Mutex এবং Monitor ব্যবহার করে থ্রেড সেফটি নিশ্চিত করা যায়।

২. Fibers in Ruby

Fibers হল রুবির আরও এক কনকারেন্ট প্রোগ্রামিং টুল, যা lightweight থ্রেড হিসেবে কাজ করে। ফাইবার থ্রেডের তুলনায় আরও বেশি কার্যকরী এবং দ্রুত কাজ করে, কারণ এগুলি non-preemptive। একটি ফাইবার কার্যকরী না হলে অন্য ফাইবার চালাতে পারে, তবে তার পূর্ববর্তী ফাইবারটি explicitly স্টপ করতে হয়।

Syntax:

fiber = Fiber.new do
  # code to run in the fiber
end

fiber.resume  # Start the fiber

উদাহরণ:

fiber1 = Fiber.new do
  5.times do |i|
    puts "Fiber 1: #{i}"
    Fiber.yield  # Yield control to the next fiber
  end
end

fiber2 = Fiber.new do
  5.times do |i|
    puts "Fiber 2: #{i}"
    Fiber.yield
  end
end

# Resuming fibers
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume
fiber1.resume
fiber2.resume

আউটপুট:

Fiber 1: 0
Fiber 2: 0
Fiber 1: 1
Fiber 2: 1
Fiber 1: 2
Fiber 2: 2
Fiber 1: 3
Fiber 2: 3
Fiber 1: 4
Fiber 2: 4

এখানে, Fiber.yield মেথডটি এক ফাইবারের execution বন্ধ করে অন্য ফাইবারে control পাঠাচ্ছে। এটি আরও বেশি lightweight কনকারেন্ট প্রোগ্রামিংয়ের জন্য উপকারী।

৩. Process Management (Multiprocessing)

Multiprocessing হল এমন একটি পদ্ধতি যেখানে একাধিক প্রসেস একসাথে কাজ করে। রুবিতে Process ক্লাস ব্যবহার করে একাধিক প্রসেস চালানো সম্ভব।

Syntax:

process = Process.fork do
  # code to execute in the new process
end
Process.wait  # Wait for the process to finish

উদাহরণ:

# Creating two separate processes
process1 = Process.fork do
  5.times do |i|
    puts "Process 1: #{i}"
    sleep 1
  end
end

process2 = Process.fork do
  5.times do |i|
    puts "Process 2: #{i}"
    sleep 1
  end
end

# Wait for both processes to finish
Process.wait(process1)
Process.wait(process2)

এখানে, দুটি আলাদা প্রসেস একসাথে কাজ করছে। Process.fork নতুন প্রসেস তৈরি করে এবং Process.wait এটি শেষ হওয়া পর্যন্ত মূল প্রসেসে অপেক্ষা করে।

৪. Async I/O (Asynchronous Input/Output)

Asynchronous I/O (async I/O) হল এমন একটি প্রক্রিয়া যেখানে ইনপুট বা আউটপুট অপারেশনগুলি একে অপরের থেকে স্বাধীনভাবে কাজ করে, অর্থাৎ একটি অপারেশন সম্পন্ন হওয়ার জন্য অন্যটির অপেক্ষা করতে হয় না। এটি I/O-bound operations যেমন ফাইল রিডিং, নেটওয়ার্ক কল ইত্যাদির ক্ষেত্রে খুবই কার্যকরী।

রুবিতে EventMachine বা Async gem ব্যবহৃত হয় async I/O পরিচালনার জন্য।

উদাহরণ (Async I/O using EventMachine):

require 'eventmachine'

EM.run do
  EM.add_timer(2) do
    puts "This will be printed after 2 seconds"
    EM.stop
  end
end

এখানে, EventMachine ব্যবহৃত হয়েছে asynchronous টাইমার পরিচালনা করার জন্য, যা নির্দিষ্ট সময় পরে একটি কাজ করবে এবং এদিকে অন্য কাজগুলো চলতে থাকবে।

৫. Actor Model for Concurrency

Actor Model হল একটি প্যাটার্ন যা রুবিতে কনকারেন্ট প্রোগ্রামিংয়ের জন্য কার্যকরী হতে পারে। এটি বিভিন্ন একক actors (অবজেক্ট) ব্যবহার করে, প্রতিটি actor একে অপরের থেকে স্বাধীনভাবে কাজ করতে পারে এবং তাদের মধ্যে মেসেজ পাস করার মাধ্যমে সমন্বয় করা হয়।

রুবি এদের ব্যবহারের জন্য Celluloid বা Concurrent-Ruby মতো লাইব্রেরি ব্যবহার করতে পারে।

উদাহরণ (using Concurrent-Ruby):

require 'concurrent-ruby'

actor = Concurrent::Actor.spawn(:actor1) do |message|
  puts "Received message: #{message}"
end

actor.tell("Hello, Actor!")

এখানে, actor একটি পৃথক থ্রেড বা প্রক্রিয়া হিসেবে কাজ করছে এবং অন্য মেসেজগুলি পাস করে তার কার্যক্রম সম্পন্ন করছে।

সারসংক্ষেপ

• Threads: রুবিতে Thread ক্লাস ব্যবহার করে একাধিক থ্রেডের মাধ্যমে কনকারেন্ট প্রোগ্রামিং করা যায়, যেখানে প্রতিটি থ্রেড একটি আলাদা কার্যক্রম পরিচালনা করে।
• Fibers: Fibers হল থ্রেডের তুলনায় আরো লাইটওয়েট কনকারেন্ট প্রোগ্রামিং টুল, যা কোডের নির্দিষ্ট অংশের উপর নিয়ন্ত্রণ রেখে অন্য অংশে কাজ করতে সাহায্য করে।
• Multiprocessing: একাধিক process ব্যবহারের মাধ্যমে একাধিক কাজ একসাথে করা হয়। এটি সিপিইউ-bounded অপারেশনগুলির জন্য উপকারী।
• Async I/O: Asynchronous I/O প্যাটার্ন ব্যবহার করে ইনপুট ও আউটপুট অপারেশনগুলি একে অপরের থেকে স্বাধীনভাবে কার্যকরী হতে পারে।
• Actor Model: Actor মডেল কনকারেন্ট প্রোগ্রামিংয়ে মেসেজ পাসিং এর মাধ্যমে একাধিক কার্যক্রম পরিচালনা করতে সহায়তা করে।

এই কনকারেন্ট প্রোগ্রামিং কৌশলগুলি রুবি প্রোগ্রামে কোডের কার্যকারিতা এবং দক্ষতা বৃদ্ধি করতে সাহায্য করে, বিশেষ করে যখন একাধিক কাজ সমান্তরালে সম্পন্ন করতে হয়।

Thread Synchronization এবং Data Sharing হল মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের দুটি অত্যন্ত গুরুত্বপূর্ণ ধারণা, যা একাধিক থ্রেডের মধ্যে নিরাপদভাবে ডেটা প্রবাহ এবং সমন্বয় নিশ্চিত করে। থ্রেডিং প্রোগ্রামিংয়ে একাধিক থ্রেড একই ডেটাকে অ্যাক্সেস করতে পারে, এবং যদি সেগুলো সঠিকভাবে সমন্বিত না হয়, তাহলে data corruption বা race conditions ঘটতে পারে। এই সমস্যাগুলো সমাধান করতে synchronization এবং locking mechanisms ব্যবহৃত হয়।

রুবি (Ruby) ভাষায়, Thread Synchronization এবং Data Sharing এর জন্য কিছু বিশেষ মেকানিজম রয়েছে, যেমন Mutex, Monitor, এবং ConditionVariable। এখানে, আমরা এই বিষয়গুলো বিস্তারিতভাবে আলোচনা করব।

১. Thread Synchronization in Ruby

Thread Synchronization হল এমন একটি কৌশল যার মাধ্যমে একাধিক থ্রেডের মধ্যে একসাথে কাজ করার সময় ডেটার নিরাপত্তা নিশ্চিত করা হয়। যখন একাধিক থ্রেড একই ডেটার উপরে কাজ করে, তখন সেগুলোর মধ্যে race conditions এবং data corruption হতে পারে। এই ধরনের সমস্যা এড়াতে mutex বা monitor ব্যবহার করা হয়, যা শুধুমাত্র একটি থ্রেডকে একে একে ডেটা অ্যাক্সেস করার অনুমতি দেয়।

১.১ Mutex (Mutual Exclusion)

Mutex (Mutual Exclusion) একটি লক যা এক থ্রেডকে একটি নির্দিষ্ট কোড ব্লক অ্যাক্সেস করার অনুমতি দেয় এবং অন্য থ্রেডকে সেটি অ্যাক্সেস করতে বাধা দেয় যতক্ষণ না প্রথম থ্রেড কাজটি শেষ করে।

উদাহরণ:

require 'thread'

mutex = Mutex.new

# Shared resource
counter = 0

# Creating two threads
threads = []
2.times do
  threads << Thread.new do
    1000.times do
      mutex.synchronize do
        counter += 1
      end
    end
  end
end

# Waiting for threads to finish
threads.each(&:join)

puts counter  # Output should be 2000 (ensuring no race condition)

এখানে, mutex.synchronize ব্লকটি একটি লক তৈরি করেছে, যার মাধ্যমে শুধুমাত্র একটি থ্রেড একে একে counter ভেরিয়েবল অ্যাক্সেস করতে পারবে। ফলে, race condition রোধ করা হয়েছে এবং ডেটার নিরাপত্তা নিশ্চিত করা হয়েছে।

১.২ Monitor

Monitor রুবির একটি অতিরিক্ত ক্লাস যা mutex এর চেয়ে কিছুটা বেশি সুবিধাজনক, কারণ এটি মিথস্ক্রিয়া এবং অবরোধ সমাধানের জন্য আরও উন্নত ফিচার প্রদান করে। Monitor ব্যবহার করলে আপনার কোড আরও সহজে এবং পরিষ্কারভাবে লেখা যায়।

উদাহরণ:

require 'monitor'

monitor = Monitor.new
counter = 0

threads = []
2.times do
  threads << Thread.new do
    1000.times do
      monitor.synchronize do
        counter += 1
      end
    end
  end
end

threads.each(&:join)

puts counter  # Output should be 2000

এখানে, monitor.synchronize ব্যবহার করে থ্রেডগুলির মধ্যে নিরাপদ সমন্বয় নিশ্চিত করা হয়েছে। এটি mutex এর মতোই কাজ করে, তবে কিছু ক্ষেত্রে এটি আরও সুবিধাজনক হতে পারে।

২. Data Sharing Between Threads

Data Sharing হল একাধিক থ্রেডের মধ্যে ডেটা শেয়ার করার প্রক্রিয়া। যদিও একাধিক থ্রেড একই ডেটাকে শেয়ার করতে পারে, কিন্তু যদি সেই ডেটা অ্যাক্সেস করার সময় সঠিক সমন্বয় না থাকে, তাহলে data inconsistency হতে পারে। এর সমাধান হিসেবে mutex, condition variables, এবং queues ব্যবহার করা হয়।

২.১ Condition Variables

Condition Variables একটি থ্রেডের জন্য অপেক্ষা (wait) করার বা অন্য থ্রেডের কোনো পরিবর্তন হওয়ার পর কাজ করতে পারে। এটি মূলত থ্রেডের মধ্যে সিঙ্ক্রোনাইজেশন প্রক্রিয়া করতে ব্যবহৃত হয়, যেখানে একটি থ্রেড অন্য থ্রেডের কার্যাবলী সম্পন্ন হওয়ার জন্য অপেক্ষা করে।

উদাহরণ:

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
counter = 0

# Consumer thread
consumer = Thread.new do
  mutex.synchronize do
    condition.wait(mutex) while counter == 0  # Wait until counter > 0
    puts "Consumed: #{counter}"
  end
end

# Producer thread
producer = Thread.new do
  mutex.synchronize do
    counter = 10  # Produce data
    condition.signal  # Signal the consumer thread
  end
end

consumer.join
producer.join

এখানে, condition.wait থ্রেডকে একটি শর্ত পূর্ণ না হওয়া পর্যন্ত অপেক্ষা করতে বলে, এবং condition.signal অন্য থ্রেডকে সিগন্যাল পাঠায়, যার ফলে সে কাজটি শুরু করতে পারে। এটি synchronization নিশ্চিত করার জন্য ব্যবহৃত হয়।

৩. Queue for Data Sharing

রুবি থ্রেডিংয়ে Queue একটি খুবই কার্যকরী ডেটা শেয়ারিং মেকানিজম, যেখানে এক থ্রেড enqueue (অর্থাৎ ডেটা যুক্ত) করে এবং অন্য থ্রেড সেই ডেটা dequeue (অর্থাৎ বের করে) করতে পারে। এটি থ্রেডের মধ্যে সিঙ্ক্রোনাইজড ডেটা শেয়ার করতে ব্যবহৃত হয়।

উদাহরণ:

require 'thread'

queue = Queue.new

# Producer thread
producer = Thread.new do
  5.times do |i|
    queue.push(i)  # Push data into the queue
    puts "Produced: #{i}"
  end
end

# Consumer thread
consumer = Thread.new do
  5.times do
    item = queue.pop  # Pop data from the queue
    puts "Consumed: #{item}"
  end
end

producer.join
consumer.join

এখানে, Queue একটি থ্রেড থেকে আরেক থ্রেডে ডেটা শেয়ার করার জন্য ব্যবহার করা হয়েছে। থ্রেডগুলো enqueue এবং dequeue করে ডেটা শেয়ার করেছে। Queue এর নিজস্ব ইন্টারনাল সিঙ্ক্রোনাইজেশন রয়েছে, তাই এটি থ্রেড সেফ (thread-safe)।

সারসংক্ষেপ

• Thread Synchronization হল এমন একটি কৌশল যার মাধ্যমে একাধিক থ্রেড একই ডেটার উপরে কাজ করার সময় সঠিক সমন্বয় এবং নিরাপত্তা নিশ্চিত করা হয়। Mutex, Monitor, এবং ConditionVariable এই উদ্দেশ্যে ব্যবহৃত হয়।
• Mutex থ্রেডের মধ্যে একসাথে একই কোড ব্লক অ্যাক্সেস করা থেকে বিরত রাখে।
• Monitor একটি উন্নত সিঙ্ক্রোনাইজেশন মেকানিজম, যা mutex এর মত কাজ করে তবে আরও অনেক ফিচার দিয়ে থাকে।
• Condition Variables থ্রেডগুলোর মধ্যে সিঙ্ক্রোনাইজেশন এবং একটি থ্রেডকে অন্য থ্রেডের কাজ সম্পন্ন হওয়ার জন্য অপেক্ষা করতে সাহায্য করে।
• Queue থ্রেডের মধ্যে ডেটা শেয়ার করতে ব্যবহৃত হয়, যেখানে এক থ্রেড ডেটা যোগ (enqueue) করে এবং অন্য থ্রেড তা বের (dequeue) করে।

এই কৌশলগুলি একে অপরের সাথে সমন্বিতভাবে কাজ করে এবং মাল্টি-থ্রেডেড প্রোগ্রামিংকে আরো কার্যকর, নিরাপদ এবং সিঙ্ক্রোনাইজড করে তোলে।