send, receive, এবং Message Queue

Erlang-এ send, receive, এবং Message Queue এর ব্যবহার

Erlang-এ send, receive, এবং message queue এর ধারণাগুলি অত্যন্ত গুরুত্বপূর্ণ, কারণ এগুলি process communication (প্রক্রিয়ার মধ্যে যোগাযোগ) এবং concurrency এর ক্ষেত্রে মূল ভূমিকা পালন করে। Erlang-এর actor model এর মধ্যে processes একে অপরের সাথে message passing এর মাধ্যমে যোগাযোগ করে এবং message queue তে মেসেজগুলি অপেক্ষমাণ থাকে, যা প্রসেসটি পরে প্রক্রিয়া করতে পারে।

1. send (মেসেজ পাঠানো)

Erlang-এ send অপারেটর ব্যবহার করে একটি প্রক্রিয়া (process) অন্য একটি প্রক্রিয়াকে মেসেজ পাঠাতে পারে। মেসেজ পাসিং হল Erlang এর actor model এর মূল অংশ, যেখানে একটি প্রক্রিয়া একটি নির্দিষ্ট PID (Process Identifier) এর মাধ্যমে অন্য প্রক্রিয়াকে মেসেজ পাঠায়।

! অপারেটর

Erlang-এ মেসেজ পাঠানোর জন্য ! অপারেটর ব্যবহৃত হয়। এটি একটি প্রক্রিয়াকে একটি মেসেজ পাঠায়, এবং এই মেসেজটি প্রাপ্ত প্রক্রিয়ার message queue তে জমা হয়।

উদাহরণ:

1> Pid = spawn(fun() -> receive_message() end).
<0.34.0>
2> Pid ! hello.

এখানে, Pid একটি প্রক্রিয়ার PID (Process Identifier) এবং hello একটি মেসেজ। ! চিহ্নটি ব্যবহৃত হয়ে এই মেসেজটি প্রক্রিয়াটি পাঠাচ্ছে।

2. receive (মেসেজ গ্রহণ করা)

Erlang-এ receive ব্লক ব্যবহার করে একটি প্রক্রিয়া তার message queue থেকে মেসেজ গ্রহণ করতে পারে। যখন একটি প্রক্রিয়া receive ব্লক প্রবেশ করে, তখন এটি অপেক্ষা করে যতক্ষণ না একটি মেসেজ তার queue তে আসে। একবার মেসেজ আসলে, প্রক্রিয়াটি সেই মেসেজটি গ্রহণ করে এবং প্রক্রিয়া চালিয়ে যায়।

উদাহরণ:

receive_message() ->
    receive
        hello -> io:format("Hello received~n");
        goodbye -> io:format("Goodbye received~n");
        _ -> io:format("Unknown message~n")
    end.

এখানে, receive_message/0 ফাংশনটি মেসেজ গ্রহণ করতে ব্যবহার হচ্ছে। এর মধ্যে তিনটি প্যাটার্ন রয়েছে:

• hello: যদি "hello" মেসেজ আসে, তাহলে "Hello received" প্রদর্শন করবে।
• goodbye: যদি "goodbye" মেসেজ আসে, তাহলে "Goodbye received" প্রদর্শন করবে।
• _: কোনো অপরিচিত মেসেজ এলে "Unknown message" প্রদর্শন করবে।

টেস্টিং:

1> c(receive_example).
{ok,receive_example}
2> Pid = spawn(fun() -> receive_example:receive_message() end).
<0.34.0>
3> Pid ! hello.
Hello received
ok

এখানে, hello মেসেজ প্রক্রিয়ায় পাঠানো হলে, সেটি receive_message/0 ফাংশন দ্বারা গ্রহণ করা হয় এবং "Hello received" আউটপুট আসে।

3. Message Queue (মেসেজ কিউ)

Erlang-এ প্রতিটি প্রক্রিয়ার নিজস্ব একটি message queue থাকে, যেখানে মেসেজগুলি জমা থাকে যতক্ষণ না সেগুলি প্রক্রিয়া করা হয়। মেসেজগুলি আসার পর receive ব্লকের মাধ্যমে message queue থেকে নেওয়া হয়। Erlang এর actor model এ এই মেসেজ কিউগুলির সাহায্যে একাধিক প্রক্রিয়া নিজেদের মধ্যে যোগাযোগ করে।

প্রতিটি প্রক্রিয়া যখন মেসেজ পায়, তখন সেটি প্রথমে মেসেজ কিউতে জমা হয় এবং প্রক্রিয়া receive ব্লক দিয়ে মেসেজগুলি প্রক্রিয়া করে।

মেসেজ কিউ এর কাজের উদাহরণ:

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

start() ->
    Pid = spawn(fun process_message/0),
    Pid ! {self(), "Message 1"},
    Pid ! {self(), "Message 2"},
    Pid ! {self(), "Message 3"}.

process_message() ->
    receive
        {From, Msg} -> 
            io:format("Received message: ~p from ~p~n", [Msg, From]),
            process_message()
    end.

এখানে, start/0 ফাংশনটি তিনটি মেসেজ পাঠায় একটি প্রক্রিয়াকে। process_message/0 ফাংশনটি receive ব্লক ব্যবহার করে মেসেজ কিউ থেকে মেসেজ গ্রহণ করে এবং সেগুলি প্রদর্শন করে। প্রতিটি মেসেজ পাওয়ার পর, এটি পুনরায় process_message/0 কে কল করে, যাতে পরবর্তী মেসেজটি গ্রহণ করা যায়।

টেস্টিং:

1> c(message_queue_example).
{ok,message_queue_example}
2> message_queue_example:start().
Received message: "Message 1" from <0.34.0>
Received message: "Message 2" from <0.34.0>
Received message: "Message 3" from <0.34.0>
ok

এখানে তিনটি মেসেজ প্রক্রিয়ার মাধ্যমে একে একে কিউ থেকে গ্রহণ করা হয় এবং আউটপুটে মেসেজের তথ্য প্রদর্শিত হয়।

4. Asynchronous Message Passing

Erlang-এ মেসেজ পাসিং asynchronous হয়, অর্থাৎ একটি প্রক্রিয়া অন্য প্রক্রিয়াকে মেসেজ পাঠানোর পর তা তৎক্ষণাৎ রেসপন্সের জন্য অপেক্ষা করে না। মেসেজ পাঠানো এবং গ্রহণ করা একে অপরের উপর নির্ভরশীল নয়। এটি সিস্টেমের পারফরম্যান্স উন্নত করে এবং non-blocking প্রক্রিয়া তৈরি করতে সাহায্য করে।

উদাহরণ: Asynchronous মেসেজ পাঠানো

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

start() ->
    Pid = spawn(fun() -> wait_for_message() end),
    Pid ! {self(), "Hello, Process!"},
    io:format("Message sent asynchronously.~n").

wait_for_message() ->
    receive
        {Sender, Msg} -> 
            io:format("Received message: ~p from ~p~n", [Msg, Sender])
    end.

এখানে, start/0 একটি নতুন process তৈরি করে এবং একটি মেসেজ asynchronously পাঠায়। wait_for_message/0 ফাংশনটি সেই মেসেজ গ্রহণ করে এবং রেসপন্স দেয়। তবে start/0 ফাংশনটি পাঠানোর পরে তৎক্ষণাৎ চলতে থাকে, মেসেজ পাওয়ার জন্য অপেক্ষা করে না।

টেস্টিং:

1> c(async_example).
{ok,async_example}
2> async_example:start().
Message sent asynchronously.
Received message: "Hello, Process!" from <0.34.0>
ok

এখানে, মেসেজটি asynchronous ভাবে পাঠানো হয়েছে এবং প্রসেসটি তা প্রক্রিয়া করেছে।

উপসংহার

• send: Erlang-এ একটি প্রক্রিয়া অন্য প্রক্রিয়াকে মেসেজ পাঠানোর জন্য ! চিহ্ন ব্যবহার করে।
• receive: একটি প্রক্রিয়া মেসেজ গ্রহণ করার জন্য receive ব্লক ব্যবহার করে।
• Message Queue: প্রতিটি Erlang প্রক্রিয়ার একটি message queue থাকে, যেখানে প্রক্রিয়া মেসেজগুলি জমা করে এবং সেগুলি পরবর্তীতে প্রক্রিয়া করে।
• Asynchronous: Erlang-এ মেসেজ পাসিং asynchronous, অর্থাৎ প্রক্রিয়া একটি মেসেজ পাঠানোর পর অপেক্ষা না করে পরবর্তী কাজ করতে পারে।

এই message passing মডেলটি Erlang-এ ডিস্ট্রিবিউটেড এবং কনকারেন্ট সিস্টেম তৈরিতে অত্যন্ত কার্যকরী এবং সিস্টেমের fault tolerance এবং scalability নিশ্চিত করতে সহায়তা করে।