লিনাক্সের অনেক প্রোগ্রাম এবং ম্যান পৃষ্ঠায় আমি কোড ব্যবহার করে দেখেছি fork()। আমাদের কেন ব্যবহার করা দরকার fork()এবং এর উদ্দেশ্য কী?
উত্তর:
fork()আপনি কীভাবে ইউনিক্সে নতুন প্রক্রিয়া তৈরি করেন। আপনি যখন কল করবেন তখন আপনি forkনিজের প্রক্রিয়াটির একটি অনুলিপি তৈরি করছেন যার নিজস্ব ঠিকানার স্থান রয়েছে । এটি একাধিক কর্মকে একে অপরের থেকে স্বতন্ত্রভাবে চালনার অনুমতি দেয় যদিও তাদের প্রত্যেককেই নিজের কাছে মেশিনের সম্পূর্ণ স্মৃতি রয়েছে।
এখানে এর কয়েকটি উদাহরণ ব্যবহার রয়েছে fork:
fork আপনাকে কমান্ড লাইন থেকে অনুরোধ করা প্রোগ্রামগুলি চালাতে ব্যবহার করে।forkপ্রতিটি যা তার নিজস্ব অ্যাড্রেস স্পেস মধ্যে অনুরোধ পরিচালনা একাধিক সার্ভারের প্রসেস তৈরি করতে। যদি একজন মারা যায় বা মেমরি ফাঁস হয়, অন্যরা ক্ষতিগ্রস্থ হয় না, তাই এটি দোষ সহ্য করার ব্যবস্থা হিসাবে কাজ করে।fork পৃথক প্রক্রিয়ার মধ্যে প্রতিটি পৃষ্ঠা হ্যান্ডেল করতে ব্যবহার করে। এটি এক পৃষ্ঠায় ক্লায়েন্ট-সাইড কোডটিকে আপনার পুরো ব্রাউজারটি নামিয়ে আনতে বাধা দেবে।forkকিছু সমান্তরাল প্রোগ্রামগুলিতে প্রসেস স্প্যান করতে ব্যবহৃত হয় ( এমপিআই ব্যবহার করে লেখাগুলি যেমন )। নোটটি থ্রেড ব্যবহার করা থেকে পৃথক , যার নিজস্ব ঠিকানা স্থান নেই এবং প্রক্রিয়াটির মধ্যে বিদ্যমান existforkশিশু প্রক্রিয়াগুলি শুরু করতে অপ্রত্যক্ষভাবে ব্যবহার করে। উদাহরণস্বরূপ, প্রতিবার subprocess.Popenপাইথনের মতো কমান্ড ব্যবহার করার সময় আপনি forkএকটি শিশু প্রক্রিয়াজাত করেন এবং এর আউটপুট পড়েন। এটি প্রোগ্রামগুলিকে এক সাথে কাজ করতে সক্ষম করে।forkশেলের সাধারণ ব্যবহারের ব্যবহার দেখতে এই জাতীয় কিছু দেখতে পারে:
int child_process_id = fork();
if (child_process_id) {
// Fork returns a valid pid in the parent process. Parent executes this.
// wait for the child process to complete
waitpid(child_process_id, ...); // omitted extra args for brevity
// child process finished!
} else {
// Fork returns 0 in the child process. Child executes this.
// new argv array for the child process
const char *argv[] = {"arg1", "arg2", "arg3", NULL};
// now start executing some other program
exec("/path/to/a/program", argv);
}
শেলটি ব্যবহার করে একটি শিশু প্রক্রিয়া তৈরি করে execএবং এটি সম্পূর্ণ হওয়ার জন্য অপেক্ষা করে , তারপরে এটি নিজের প্রয়োগের সাথে চালিয়ে যায়। মনে রাখবেন যে আপনাকে এইভাবে কাঁটাচামচ ব্যবহার করতে হবে না। আপনি সর্বদা প্রচুর শিশু প্রক্রিয়া বন্ধ করে দিতে পারেন, যেমন একটি সমান্তরাল প্রোগ্রামটি করতে পারে এবং প্রত্যেকে একই সাথে একটি প্রোগ্রাম চালাতে পারে। মূলত, আপনি যখনই ইউনিক্স সিস্টেমে নতুন প্রক্রিয়া তৈরি করছেন, আপনি ব্যবহার করছেন fork()। উইন্ডোজ সমতুল্যের জন্য, একবার দেখুন CreateProcess।
আপনি যদি আরও উদাহরণ এবং আরও দীর্ঘতর ব্যাখ্যা চান তবে উইকিপিডিয়ায় একটি সুন্দর সারসংক্ষেপ রয়েছে। এবং আধুনিক অপারেটিং সিস্টেমগুলিতে কীভাবে প্রক্রিয়াগুলি, থ্রেডগুলি এবং একযোগিতাপত্র কাজ করে সে সম্পর্কে এখানে কিছু স্লাইড রয়েছে ।
fork()পথ ইউনিক্স একটি নতুন প্রসেস নির্মাণ করতে, কিন্তু গোঁড়া হবে, সেখানে অন্তত এক অন্য নন: posix_spawn()।
কাঁটাচামচ () কীভাবে ইউনিক্স নতুন প্রক্রিয়া তৈরি করে। আপনি কাঁটাচামচ () কল করার সময়, আপনার প্রক্রিয়া ক্লোন করা হয়েছে এবং দুটি পৃথক প্রক্রিয়া সেখান থেকে কার্যকর করা চালিয়ে যায়। তার মধ্যে একটি, সন্তানের কাঁটাচামচ () ফিরে আসবে। অন্য, পিতা বা মাতা, কাঁটাচামচ () পিডি (প্রসেস আইডি) সন্তানের ফিরিয়ে আনবে return
উদাহরণস্বরূপ, আপনি যদি শেলটিতে নিম্নলিখিতটি লিখেন, শেল প্রোগ্রামটি কাঁটাচামচ () কল করবে এবং তারপরে সন্তানের মধ্যে আপনি যে কমান্ডটি ব্যবহার করেছিলেন (টেলনেটড, এই ক্ষেত্রে) সম্পাদন করবে, যখন পিতা-মাতা আবার প্রম্পটটি প্রদর্শন করবে, পাশাপাশি একটি বার্তা হিসাবে পটভূমি প্রক্রিয়া পিআইডি নির্দেশ করে।
$ telnetd &
আপনি নতুন প্রক্রিয়া তৈরি করার কারণ হিসাবে, একইভাবে আপনার অপারেটিং সিস্টেমটি অনেক কিছুই করতে পারে। এজন্য আপনি কোনও প্রোগ্রাম চালাতে পারেন এবং এটি চলাকালীন অন্য উইন্ডোতে স্যুইচ করুন এবং অন্য কিছু করুন।
কাঁটাচামচ () শিশু প্রক্রিয়া তৈরি করতে ব্যবহৃত হয়। যখন একটি কাঁটাচামচ () ফাংশন বলা হয়, একটি নতুন প্রক্রিয়া তৈরি হবে এবং কাঁটাচামচ () ফাংশন কলটি শিশু এবং পিতামাতার জন্য আলাদা মান প্রদান করবে।
যদি রিটার্নের মান 0 হয় তবে আপনি জানেন যে আপনি শিশু প্রক্রিয়া এবং যদি ফেরতের মানটি একটি সংখ্যা হয় (যা চাইল্ড প্রক্রিয়া আইডি হিসাবে ঘটে থাকে) তবে আপনি জানেন যে আপনি পিতামাতা। (এবং যদি এটি একটি নেতিবাচক সংখ্যা হয়, কাঁটাচামচ ব্যর্থ হয়েছিল এবং কোনও শিশু প্রক্রিয়া তৈরি করা হয়নি)
কাঁটাচামচ () মূলত সেই প্রক্রিয়াটির জন্য শিশু প্রক্রিয়া তৈরি করতে ব্যবহৃত হয় যাতে আপনি এই ফাংশনটি কল করছেন used আপনি যখনই একটি কাঁটাচামচ () কল করবেন তখন শিশু আইডির জন্য এটি শূন্য দেয়।
pid=fork()
if pid==0
//this is the child process
else if pid!=0
//this is the parent process
এর মাধ্যমে আপনি পিতামাতার এবং সন্তানের জন্য বিভিন্ন ক্রিয়াকলাপ সরবরাহ করতে পারেন এবং মাল্টিথ্রেডিং বৈশিষ্ট্যটি ব্যবহার করতে পারেন।
কাঁটাচামচ () পিতামাতার মতো একটি নতুন শিশু প্রক্রিয়া তৈরি করবে। সুতরাং এর পরে কোডে আপনি চালিত সমস্ত কিছু উভয় প্রক্রিয়া দ্বারা চালিত হবে - খুব কার্যকর যদি আপনার কাছে কোনও সার্ভার থাকে এবং আপনি একাধিক অনুরোধগুলি পরিচালনা করতে চান।
আপনি যদি অ্যাপ্লিকেশন লিখছেন তবে আপনাকে সম্ভবত প্রতিদিনের প্রোগ্রামিংয়ে কাঁটাচামচ ব্যবহার করার দরকার নেই।
এমনকি যদি আপনি চান যে আপনার প্রোগ্রামটি কোনও কাজ করার জন্য অন্য প্রোগ্রাম শুরু করতে পারে, তবে অন্যান্য সহজ ইন্টারফেস রয়েছে যা পর্দার পিছনে কাঁটাচামচ ব্যবহার করে, যেমন সি এবং পার্লের "সিস্টেম"।
উদাহরণস্বরূপ, আপনি যদি নিজের অ্যাপ্লিকেশনটি কোনও প্রোগ্রাম শুরু করতে চান যেমন বিসি আপনার জন্য কিছু গণনা করার জন্য, আপনি এটি চালানোর জন্য 'সিস্টেম' ব্যবহার করতে পারেন। একটি নতুন প্রক্রিয়া তৈরি করতে সিস্টেম একটি 'কাঁটাচামচ' করে, তারপরে একটি প্রক্রিয়াটি বিসিতে পরিণত করার জন্য 'এক্সিকিউট' করে। একবার বিসি সম্পূর্ণ হলে, সিস্টেমটি আপনার প্রোগ্রামে নিয়ন্ত্রণ ফিরিয়ে দেয়।
আপনি অন্যান্য প্রোগ্রামগুলিও অবিচ্ছিন্নভাবে চালাতে পারেন, তবে কীভাবে তা আমি মনে করতে পারি না।
আপনি যদি সার্ভার, শেল, ভাইরাস বা অপারেটিং সিস্টেম লিখতে থাকেন তবে আপনার কাঁটাচামচ ব্যবহার করার সম্ভাবনা বেশি।
system()। আমি পড়ছিলাম fork()কারণ আমার সি কোডটি একটি অজগর স্ক্রিপ্ট চালানো চাই run
সিস্টেম কল ফর্ক () প্রক্রিয়া তৈরি করতে ব্যবহৃত হয়। এটি কোনও আর্গুমেন্ট নেয় না এবং কোনও প্রক্রিয়া আইডি দেয়। কাঁটাচামচ () এর উদ্দেশ্য হ'ল একটি নতুন প্রক্রিয়া তৈরি করা, যা কলারের শিশু প্রক্রিয়াতে পরিণত হয়। একটি নতুন শিশু প্রক্রিয়া তৈরি হওয়ার পরে, উভয় প্রক্রিয়া কাঁটা () সিস্টেম কলের পরে পরবর্তী নির্দেশনা কার্যকর করবে। অতএব, আমাদের সন্তানের থেকে পিতামাতাকে আলাদা করতে হবে। কাঁটাচামড়ার () ফেরতের মানটি পরীক্ষা করে এটি করা যেতে পারে:
যদি কাঁটাচামচ () একটি নেতিবাচক মান প্রদান করে তবে একটি শিশু প্রক্রিয়া তৈরি করা ব্যর্থ হয়েছিল। কাঁটাচামচ () সদ্য নির্মিত শিশু প্রক্রিয়াতে একটি শূন্য প্রদান করে। কাঁটাচামচ () সন্তানের প্রক্রিয়া আইডি, পিতামাতাকে একটি ধনাত্মক মান প্রদান করে। প্রত্যাবর্তিত প্রক্রিয়া আইডি সিড / টাইপস.কম-এ সংজ্ঞায়িত pid_t প্রকারের। সাধারণত, প্রক্রিয়া আইডি একটি পূর্ণসংখ্যা হয়। তদুপরি, একটি প্রক্রিয়া এই প্রক্রিয়াটিতে নির্ধারিত প্রক্রিয়া আইডি পুনরুদ্ধার করতে ফাংশন গেটপিড () ব্যবহার করতে পারে। অতএব, সিস্টেমটি কাঁটাচামচ () কল করার পরে, একটি সহজ পরীক্ষা বলতে পারে যে শিশুটি কোন প্রক্রিয়াটি। অনুগ্রহ করে নোট করুন যে ইউনিক্স পিতামাতার ঠিকানার জায়গার একটি সঠিক অনুলিপি তৈরি করবে এবং এটি সন্তানের হাতে দেবে। অতএব, পিতামাতার এবং সন্তানের প্রক্রিয়াগুলির পৃথক ঠিকানার স্থান রয়েছে।
আসুন উপরের বিষয়গুলি পরিষ্কার করার জন্য এটি একটি উদাহরণ দিয়ে বুঝতে পারি। এই উদাহরণটি পিতামাতার এবং সন্তানের প্রক্রিয়াগুলিকে আলাদা করে না।
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#define MAX_COUNT 200
#define BUF_SIZE 100
void main(void)
{
pid_t pid;
int i;
char buf[BUF_SIZE];
fork();
pid = getpid();
for (i = 1; i <= MAX_COUNT; i++) {
sprintf(buf, "This line is from pid %d, value = %d\n", pid, i);
write(1, buf, strlen(buf));
}
}
মনে করুন উপরের প্রোগ্রামটি কাঁটাচামচ () কল করার বিন্দু পর্যন্ত কার্যকর করে।
যদি কাঁটাচামচ () কলটি সফলভাবে সম্পাদন করা হয়, ইউনিক্স ঠিকানা জায়গাগুলির দুটি অভিন্ন অনুলিপি তৈরি করবে, একটি পিতামাতার জন্য এবং অন্যটি সন্তানের জন্য। উভয় প্রক্রিয়া কাঁটাচামচ () কল অনুসরণ করে পরবর্তী বিবৃতিতে তাদের সম্পাদন শুরু করবে। এই ক্ষেত্রে, উভয় প্রক্রিয়া অ্যাসাইনমেন্টে তাদের সম্পাদন শুরু করবে
pid = .....;
উভয় প্রক্রিয়া সিস্টেম কল ফর্ক () এর ঠিক পরে তাদের কার্যকর করা শুরু করে। যেহেতু উভয় প্রসেসের অভিন্ন তবে পৃথক ঠিকানার স্পেস রয়েছে, কাঁটাচামচ () কলের আগে আরম্ভ হওয়া সেই পরিবর্তনশীলগুলির উভয় ঠিকানা ফাঁকে একই মান রয়েছে। যেহেতু প্রতিটি প্রক্রিয়াটির নিজস্ব ঠিকানা স্থান রয়েছে, যে কোনও পরিবর্তন অন্যদের থেকে স্বতন্ত্র থাকবে। অন্য কথায়, যদি পিতা-মাতা তার ভেরিয়েবলের মান পরিবর্তন করে তবে পরিবর্তনটি পিতামাতার প্রক্রিয়ার ঠিকানার জায়গার পরিবর্তনশীলকে কেবল প্রভাবিত করবে। কাঁটাচামচ () কল দ্বারা তৈরি অন্যান্য ঠিকানা স্পেসে অভিন্ন পরিবর্তনশীল নাম থাকলেও প্রভাবিত হবে না।
প্রিন্টফের চেয়ে লেখার ব্যবহার করার কারণ কী? এটি কারণ প্রিন্টফ () "বাফার করা", যার অর্থ প্রিন্টফ () প্রসেসের আউটপুটকে একসাথে ভাগ করবে। অভিভাবক প্রক্রিয়াটির জন্য আউটপুটটি বাফার করার সময়, শিশু কিছু তথ্য মুদ্রণের জন্য প্রিন্টফ ব্যবহার করতে পারে, যা বাফার করা হবে। ফলস্বরূপ, আউটপুটটি তত্ক্ষণাত স্ক্রিনে প্রেরণ করা হবে না, তাই আপনি প্রত্যাশিত ফলাফলের সঠিক ক্রমটি পেতে পারেন না। সবচেয়ে খারাপ, দুটি প্রক্রিয়া থেকে আউটপুট অদ্ভুত উপায়ে মিশ্রিত হতে পারে। এই সমস্যাটি কাটিয়ে উঠতে আপনি "আনফারড" রাইটিংটি বিবেচনা করতে পারেন।
আপনি যদি এই প্রোগ্রামটি চালনা করেন তবে আপনি স্ক্রিনে নিম্নলিখিতগুলি দেখতে পাবেন:
................
This line is from pid 3456, value 13
This line is from pid 3456, value 14
................
This line is from pid 3456, value 20
This line is from pid 4617, value 100
This line is from pid 4617, value 101
................
This line is from pid 3456, value 21
This line is from pid 3456, value 22
................
প্রক্রিয়া ID 3456 পিতা বা মাতা বা সন্তানের জন্য নির্ধারিত এক হতে পারে। এই প্রক্রিয়াগুলি একই সাথে পরিচালিত হওয়ার কারণে, তাদের আউটপুট লাইনগুলি বরং একটি অনির্দেশ্য উপায়ে সংযুক্ত করা হয়। তদতিরিক্ত, এই লাইনের ক্রম সিপিইউ শিডিয়ুলার দ্বারা নির্ধারিত হয়। অতএব, আপনি যদি আবার এই প্রোগ্রামটি চালনা করেন তবে আপনি সম্পূর্ণ ভিন্ন ফলাফল পেতে পারেন।
মাল্টিপ্রসেসিং কম্পিউটিংয়ের কেন্দ্রবিন্দু। উদাহরণস্বরূপ, আপনি এখনও ইন্টারনেট ব্রাউজ করার সময় আপনার আইই বা ফায়ারফক্স আপনার জন্য একটি ফাইল ডাউনলোড করার জন্য একটি প্রক্রিয়া তৈরি করতে পারে। অথবা, আপনি যখন ওয়ার্ড প্রসেসরে কোনও ডকুমেন্ট প্রিন্ট করছেন তখন আপনি বিভিন্ন পৃষ্ঠাগুলি দেখতে পারেন এবং এর সাথে কিছু সম্পাদনা করতে পারেন।
প্রতিটি দেহ যেমন লিখেছে তেমন নতুন প্রক্রিয়া তৈরি করতে কাঁটা () ব্যবহার করা হয়।
এখানে আমার কোড যা বাইনারি গাছ আকারে প্রক্রিয়া তৈরি করে ....... এটি বাইনারি ট্রিতে প্রক্রিয়া তৈরি করতে চান এমন স্তরগুলির সংখ্যা স্ক্যান করতে বলবে
#include<unistd.h>
#include<fcntl.h>
#include<stdlib.h>
int main()
{
int t1,t2,p,i,n,ab;
p=getpid();
printf("enter the number of levels\n");fflush(stdout);
scanf("%d",&n);
printf("root %d\n",p);fflush(stdout);
for(i=1;i<n;i++)
{
t1=fork();
if(t1!=0)
t2=fork();
if(t1!=0 && t2!=0)
break;
printf("child pid %d parent pid %d\n",getpid(),getppid());fflush(stdout);
}
waitpid(t1,&ab,0);
waitpid(t2,&ab,0);
return 0;
}
আউটপুট
enter the number of levels
3
root 20665
child pid 20670 parent pid 20665
child pid 20669 parent pid 20665
child pid 20672 parent pid 20670
child pid 20671 parent pid 20670
child pid 20674 parent pid 20669
child pid 20673 parent pid 20669
কাঁটা () সিস্টেম কল কী তা প্রথমে বুঝতে হবে। আমাকে বিস্তারিত বলতে দাও
কাঁটাচামচ () সিস্টেম কল পিতামাতার প্রক্রিয়াটির যথাযথ নকল তৈরি করে, এটি প্যারেন্ট স্ট্যাকের নকল তৈরি করে, গাদা, আরম্ভকৃত ডেটা, আনইনটিয়ালাইজড ডেটা তৈরি করে এবং কোডটি পিতামাতার প্রক্রিয়ার সাথে কেবল পঠন মোডে ভাগ করে।
কাঁটাচামচ কল কল মেমরির অনুলিপি অনুলিপি ভিত্তিতে অনুলিপি করে, যখন অনুলিপি করার প্রয়োজন হয় তখন শিশু ভার্চুয়াল মেমরি পৃষ্ঠায় তৈরি করে page
এখন কাঁটাচামড়ার উদ্দেশ্য ():
fork()একটি শিশু প্রক্রিয়া উত্সাহিত করতে ব্যবহৃত হয়। সাধারণত এটি থ্রেডিং হিসাবে একই ধরণের পরিস্থিতিতে ব্যবহৃত হয়, তবে পার্থক্য রয়েছে। থ্রেডের বিপরীতে fork()পুরো পৃথক প্রক্রিয়া তৈরি করে যার অর্থ শিশু এবং পিতামাতারা যখন একে একে একে একে একে একে একে একে একে একে একে একে একে অপরকে সরাসরি fork()আলাদা করে রাখে না, তখনও তারা একে অপরের স্মৃতির স্থান অ্যাক্সেস করতে পারে না (সাধারণ সমস্যায় না গিয়ে) আপনি অন্য প্রোগ্রামের মেমোরি অ্যাক্সেস করতে যান)।
fork()এখনও কিছু সার্ভার অ্যাপ্লিকেশন ব্যবহার করে, বেশিরভাগই এমন একটি * NIX মেশিনে রুট হিসাবে চালিত যা ব্যবহারকারীর অনুরোধগুলি প্রক্রিয়া করার আগে অনুমতিগুলি ড্রপ করে। এখনও কিছু অন্যান্য ব্যবহারের কেস রয়েছে, তবে বেশিরভাগ লোকেরা এখন মাল্টিথ্রেডিংয়ে চলে গেছে।
নতুন প্রক্রিয়া শুরু করার জন্য কাঁটা () বনাম কেবল একটি এক্সিকিউটিভ () ফাংশন থাকার পিছনে যুক্তিটি ইউনিক্স স্ট্যাক এক্সচেঞ্জের অনুরূপ প্রশ্নের উত্তরে ব্যাখ্যা করা হয়েছে ।
মূলত, যেহেতু কাঁটাচামচ বর্তমান প্রক্রিয়াটি অনুলিপি করে, কোনও প্রক্রিয়ার জন্য বিভিন্ন সম্ভাব্য সমস্ত বিকল্প ডিফল্টরূপে প্রতিষ্ঠিত হয়, সুতরাং প্রোগ্রামার তাদের সরবরাহ করে না।
উইন্ডোজ অপারেটিং সিস্টেমে, বিপরীতে, প্রোগ্রামারগুলিকে ক্রিয়েটপ্রসেস ফাংশনটি ব্যবহার করতে হবে যা অনেক বেশি জটিল এবং নতুন প্রক্রিয়াটির পরামিতিগুলি সংজ্ঞায়িত করার জন্য একটি বহুমুখী কাঠামো গড়ে তোলা দরকার।
সুতরাং, সংক্ষেপে বলতে গেলে, কাঁটাচামড়ার কারণ (বনাম মৃত্যুদণ্ড কার্যকর করা) নতুন প্রক্রিয়া তৈরির ক্ষেত্রে সরলতা।
একটি শিশু প্রক্রিয়া তৈরি করতে কাঁটাচামচ () সিস্টেম কল ব্যবহার। এটি পিতামাতার প্রক্রিয়ার হুবহু সদৃশ। কাঁটাচামড়া অনুলিপি স্ট্যাক বিভাগ, হিপ বিভাগ, তথ্য বিভাগ, পরিবেশ পরিবর্তনশীল, পিতামাতার কাছ থেকে কমান্ড লাইন আর্গুমেন্ট।
কাঁটাচামচ () ফাংশন বিদ্যমান প্রক্রিয়া যার থেকে এটা বলা হয় অনুরূপ করে একটি নতুন প্রসেস নির্মাণ করতে ব্যবহার করা হয়। বিদ্যমান ক্রিয়াটি যা থেকে এই ফাংশনটি বলা হয় এটি প্যারেন্ট প্রক্রিয়া হয়ে যায় এবং নতুন তৈরি প্রক্রিয়া শিশু প্রক্রিয়াতে পরিণত হয়। যেমন ইতিমধ্যে বলা হয়েছে যে শিশুটি পিতামাতার একটি সদৃশ অনুলিপি তবে এতে কিছু ব্যতিক্রম রয়েছে।
অপারেটিং সিস্টেমে চলমান অন্যান্য প্রক্রিয়ার মতো সন্তানের অনন্য পিআইডি রয়েছে।
সন্তানের একটি প্যারেন্ট প্রসেস আইডি রয়েছে যা
এটি তৈরি করা প্রক্রিয়ার পিআইডি সমান ।
রিসোর্স ব্যবহার এবং সিপিইউ টাইম কাউন্টারগুলি শিশু প্রক্রিয়াতে শূন্যে পুনরায় সেট করা হয়েছে।
সন্তানের মধ্যে মুলতুবি থাকা সংকেতের সেট খালি।
শিশু তার পিতামাতার কাছ থেকে কোনও টাইমার উত্তরাধিকারী হয় না
উদাহরণ:
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
int var_glb; /* A global variable*/
int main(void)
{
pid_t childPID;
int var_lcl = 0;
childPID = fork();
if(childPID >= 0) // fork was successful
{
if(childPID == 0) // child process
{
var_lcl++;
var_glb++;
printf("\n Child Process :: var_lcl = [%d], var_glb[%d]\n", var_lcl, var_glb);
}
else //Parent process
{
var_lcl = 10;
var_glb = 20;
printf("\n Parent process :: var_lcl = [%d], var_glb[%d]\n", var_lcl, var_glb);
}
}
else // fork failed
{
printf("\n Fork failed, quitting!!!!!!\n");
return 1;
}
return 0;
}
এখন, যখন উপরের কোডটি সংকলন করে চালানো হবে:
$ ./fork
Parent process :: var_lcl = [10], var_glb[20]
Child Process :: var_lcl = [1], var_glb[1]