Process তৈরি এবং Message Passing

Erlang-এ Process তৈরি এবং Message Passing

Erlang-এ processes এবং message passing দুটি অত্যন্ত গুরুত্বপূর্ণ ধারণা, যা ডিস্ট্রিবিউটেড এবং কনকারেন্ট (concurrent) সিস্টেম তৈরি করতে ব্যবহৃত হয়। Erlang এর শক্তিশালী process model এবং message passing এর মাধ্যমে সিস্টেমের বিভিন্ন অংশকে একে অপরের সাথে যোগাযোগ করানো সম্ভব হয়, যা উচ্চ স্তরের parallelism এবং fault tolerance নিশ্চিত করে।

1. Process তৈরি (Creating Processes)

Erlang-এ প্রতিটি process একটি স্বাধীন একক হিসেবে চলে, যার নিজস্ব মেমরি স্পেস এবং সম্পূর্ণ আইসোলেশন থাকে। Erlang এর lightweight processes খুব কম রিসোর্স ব্যবহার করে এবং সেগুলি একযোগে অনেকটা সংখ্যায় চলতে পারে। এর জন্য Erlang-এ spawn/1, spawn/2 বা spawn/3 ফাংশন ব্যবহার করে নতুন process তৈরি করা হয়।

1.1 Process তৈরি করা spawn/1 এর মাধ্যমে

Erlang-এ spawn/1 ফাংশন ব্যবহার করে একটি নতুন process তৈরি করা যায়, যেখানে সেই process একটি নির্দিষ্ট ফাংশন (বা ফাংশনালিটি) চালাবে।

-module(process_example).
-export([start/0, loop/0]).

start() ->
    spawn(fun loop/0).  % This spawns a new process running 'loop/0'

loop() ->
    io:format("Hello from a new process!~n"),
    loop().  % Recursively calling 'loop' to keep the process alive.

এখানে, start/0 ফাংশনটি নতুন একটি process তৈরি করে যা loop/0 ফাংশনটি চালাবে। loop/0 ফাংশনটি কনস্ট্যান্টভাবে আউটপুট করবে "Hello from a new process!" এবং নিজেকে পুনরায় কল করবে।

1.2 Process চালানো

1> c(process_example).
{ok,process_example}
2> process_example:start().
Hello from a new process!
Hello from a new process!

এই কোডটি চালালে, loop/0 ফাংশনটি নতুন process তৈরি করে এবং অনন্তকাল ধরে আউটপুট তৈরি করবে।

2. Message Passing (মেসেজ পাসিং)

Erlang-এ process গুলি একে অপরের সাথে message passing এর মাধ্যমে যোগাযোগ করে। একটি process অন্য process কে মেসেজ পাঠাতে পারে, এবং প্রাপ্ত process সেই মেসেজ গ্রহণ করে সেটি প্রক্রিয়া করতে পারে। মেসেজ পাসিং শুধুমাত্র Erlang-এর actor model এর একটি অংশ এবং এটি asynchronous অর্থাৎ একে অপরের উপর নির্ভর না হয়ে কাজ করে।

2.1 Message Passing Syntax

Erlang-এ মেসেজ পাঠানোর জন্য ! চিহ্ন ব্যবহার করা হয়। একটি process একটি অন্য process কে মেসেজ পাঠাতে পারে, যেমন:

Pid ! Message.

এখানে, Pid হল সেই process এর প্রোসেস আইডেন্টিফায়ার (PID) যেটি মেসেজটি পাবে এবং Message হল মেসেজের কনটেন্ট।

2.2 Process থেকে মেসেজ গ্রহণ করা

একটি process তার নিজস্ব receive ব্লকের মাধ্যমে মেসেজ গ্রহণ করে। যখন একটি process মেসেজ গ্রহণ করতে চায়, তখন receive ব্লক ব্যবহার করে মেসেজ পেলে তা প্রক্রিয়া করা হয়।

-module(process_comm).
-export([start/0, loop/0]).

start() ->
    Pid = spawn(fun loop/0),
    Pid ! hello,  % Sending a message to the new process
    io:format("Message sent to the process.~n").

loop() ->
    receive
        hello -> io:format("Hello received!~n")
    end.

এখানে, start/0 ফাংশনটি নতুন একটি process তৈরি করে এবং সেই process-এ একটি মেসেজ (hello) পাঠায়। loop/0 ফাংশনটি receive ব্লক ব্যবহার করে মেসেজ গ্রহণ করে এবং যখন "hello" মেসেজ আসে, তখন আউটপুট "Hello received!" প্রদান করবে।

2.3 Process থেকে মেসেজ পাঠানো এবং গ্রহণ করা

1> c(process_comm).
{ok,process_comm}
2> process_comm:start().
Message sent to the process.
Hello received!

এখানে, start/0 ফাংশনটি প্রথমে একটি নতুন process তৈরি করে এবং তারপর একটি "hello" মেসেজ পাঠায়। এই মেসেজটি loop/0 দ্বারা গ্রহণ করা হয় এবং আউটপুট হিসেবে "Hello received!" প্রদর্শিত হয়।

3. Asynchronous Message Passing

Erlang-এ message passing সাধারণত asynchronous হয়। এর মানে হল, একটি process মেসেজ পাঠানোর পর তা অবিলম্বে অন্য process এর কাছ থেকে রেসপন্স পেতে অপেক্ষা করে না। মেসেজ পাসের পর process নিজের কাজ করতে পারে। যখন প্রাপ্ত process প্রস্তুত হবে, তখন সেটি মেসেজটি প্রক্রিয়া করবে।

উদাহরণ:

-module(async_example).
-export([start/0, send_message/1]).

start() ->
    Pid = spawn(fun send_message/1),
    Pid ! {self(), "Hello, Process!"},  % Send a message to another process
    receive
        {Pid, Response} -> io:format("Received response: ~p~n", [Response])
    end.

send_message(Pid) ->
    receive
        {Sender, Message} -> 
            Sender ! {Pid, "Got your message: " ++ Message}
    end.

এখানে, start/0 ফাংশনটি প্রথমে একটি নতুন process তৈরি করে এবং একটি মেসেজ পাঠায়। মেসেজটি প্রাপ্ত process send_message/1 সেই মেসেজটি পুনরায় পাঠানোর মাধ্যমে একে অপরকে আউটপুট দেয়।

টেস্টিং:

1> c(async_example).
{ok,async_example}
2> async_example:start().
Received response: {<0.33.0>,"Got your message: Hello, Process!"}

এখানে, start/0 প্রথমে মেসেজ পাঠায় এবং তার পরবর্তী আউটপুট হিসেবে মেসেজ প্রক্রিয়া হয়ে "Got your message" হিসেবে ফিরে আসে।

4. Process Id (PID) এবং Process Monitoring

Erlang-এ প্রতিটি process একটি PID (process identifier) থাকে, যা প্রক্রিয়ার চিহ্নিতকারী হিসেবে ব্যবহৃত হয়। মেসেজ পাসিংয়ে PID ব্যবহার করা হয় যাতে নির্দিষ্ট process কে মেসেজ পাঠানো যায়।

উদাহরণ:

1> Pid = spawn(fun() -> io:format("Hello from the process!~n") end).
<0.33.0>
2> Pid ! goodbye.

এখানে, Pid হল যে process থেকে মেসেজটি যাবে, এবং সেই process-এ একটি আউটপুট হবে। PID হল Erlang process গুলির নির্দিষ্ট পরিচায়ক।

Process Monitoring

Erlang-এ process গুলোর কার্যক্রম monitoring এবং linking করাও সম্ভব। এর মাধ্যমে একটি process এর অবস্থার উপর নজর রাখা যায়, এবং যদি কোনো process হঠাৎ করে crash হয়ে যায় তবে সেটি অন্য process-এ প্রভাব ফেলতে পারে।

উপসংহার

Erlang-এ process creation এবং message passing হল ডিস্ট্রিবিউটেড এবং কনকারেন্ট সিস্টেম তৈরির মুল ভিত্তি। Processes একে অপরের সাথে asynchronous message passing এর মাধ্যমে যোগাযোগ করে, যা কার্যকরীভাবে সিস্টেমের স্কেলেবিলিটি এবং fault tolerance নিশ্চিত করে। Erlang এর actor model এ processes একে অপরের সাথে যোগাযোগ করতে সক্ষম, যা সিস্টেমের কার্যকারিতা এবং পারফরম্যান্স বৃদ্ধি করে।