menusearch
javapro.ir
جستجو
۱۳۹۶/۱/۱۹ شنبه
(1)
(0)
جلسه سی و ششم - چندنخی(Multithreading)
جلسه سی و ششم - چندنخی(Multithreading)
آموزش آسان و ساده زبان برنامه نویسی جاوا
همین الان که پشت کامپیوتر خود نشستید و دارید این جلسه از آموزش های جاوا را مطالعه می کنید
،سیستم شما دارد چند عمل را همزمان انجام میدهد!! مثلا برنامه PDFReader شما در حال اجرای این
کتاب الکترونیکی هستش و احتمالا دارید با یک پخش کننده، موسیقی مورد علاقه خود را گوش
می کنید و همزمان مرورگر فایرفاکس رو باز کردید و نکته ای از این کتاب را در گوگل سرچ می زنید
و ....کامپیوتر شما همه این کارها رو براتون همزمان انجام می دهد بدون این که شما متوجه شوید!!!
یعنی چندین عملیات بصورت همزمان!! چندنخی (Multithreading) در جاوا نیز به همین مفهوم
اشاره دارد یعنی اومده که به ما کمک کنه بتوانیم برنامه ای بنویسیم که توانایی این رو داشته باشه
که چندین عملیات رو همزمان برامون انجام دهد.

جاوا یک زبان برنامه نویسی چندنخی (Multithreading) است ، یعنی ما می توانیم
برنامه های چندنخی (Multithreading)،برنامه هایی که چندین عملیات را همزمان با هم برامون انجام میدن را بنویسیم و توسعه دهیم.

یک برنامه چندنخی شامل دو یا چند بخش است که می توانند بصورت همزمان اجرا شوند.
و هر بخش در همان زمان اجرا می توانند کار متفاوتی را انجام دهند.
من نمی خوام زیاد وارد جزییات کار thread ها شوم!!! بیشتر هدف اینه که کاربردشون چیه
و چطور ازشون در برنامه مون استفاده کنیم!!جهت آگاهی از جزییات thread ها در گوگل
سرچ کنید!!!منابع در این مورد زیاد!! ما میخوایم سریع بریم شراغ کدنویسی :-)
همان طور که گفتیم ،چندنخی (Multithreading)به اجرای همزمان چند بخش از یک برنامه
اشاره دارد، این یعنی ما برای هر بخش از برنامه خود یک thread تعریف کرده و این thread ها
هستند که همزمان در حال اجرا هستند!!! به همین دلیل به آن Multithreading می گویند
یعنی اجرای همزمان چند thread در برنامه مون. اگر تا اینجا متوجه نشدید اصلا نگران نباشید
سعی می کنیم این مبحث چغر!!! رو به هر ترتیبی شده یاد بگیریم :-)

از مزایا و کاربرد های thread ها در جاوا :
1.    چندنخی (Multithreading)کاربر را محدود نمی کند،چرا که تردها (thread ها)
هنگام اجرا مستقل از هم هستند و می توانند عملیات های متعدد را همزمان انجام بدهند.
2.    با thread ها شما می توانید چندین عملیات را باهم انجام بدید و این باعث صرفه جویی در زمان می شود.
3.    همان طور که گفتیم thread ها مستقل از یکدیگر هستند و روی هم تاثیری ندارند مگر استثنایی رخ دهد.

مثال از دنیای واقعی
احتمالا پیش خودتون بگید چقدر داره توضیح میده چرا نمیره سراغ کدنویسی اینم شد آموزش؟! :-)
منم مثل خودتون بی تابم برای رفتن سراغ کدنویسی اما چه کنیم که باید ابتدا مفهوم و کاربرد
thread برامون روشن بشه

خب تا اینجا گفتیم هر بخش از برنامه که بطور همزمان اجرا می شود یک thread می باشد
و به اجرای همزمان چند بخش از برنامه یا چند thread ، چندنخی (Multithreading) می گویند.
برای درک بهتر مفهوم و کاربرد thread در برنامه نویسی یک مثال از دنیای واقعی برای شما می زنیم!!
مثال از یک انسان می زنیم!! یک انسان را در نظر بگیرید! یک انسان از چندین
بخش تشکیل شده است!!! مثلا بخش شنوایی یا گوش انسان ،بخش بینایی یا چشم انسان،
بخش دهان انسان،بخش قلب ،بخش مغز،بخش دست و....
وقتی شما با دوست خود در مورد یک موضوع در حال صحبت کردن هستید ،
همزمان دارید دوستتون رو می بینید این یعنی بخش چشم داره کار میکنه، بعد
همزمان دارید در مورد موضوع تک چرخ زدن جعفر در خیابان صحبت می کنی!
این یعنی بخش دهان همزمان در حال کار و اجرا می باشد و همچنین با حرکات
دستتون دارید اشاره هایی می کنید این یعنی بخش دست در حال اجرا می باشد
و یهو هیجان زده میشید و تپش قلبتون میره بالا این یعنی بخش تپش قلب همزمان در حال اجرا
در بدنتون می باشد!!! در این مثال چند بخش از بدن شما همزمان در حال اجرا و کار کردن بود و
هر بخش مستقل از یکدیگر بدون این که تاثیری رو هم بگذارند همزمان در حال اجرا بودند یعنی
شما همزمان با چشمتون می دیدید و با دهانتون حرف می زدید و با دستتون اشاره می کردید
و تپش قلبتون بالا می رفت بدون این که هر بخش اختلالی در سایر بخش های بدنتون ایجاد کند.
اگه  بدن انسان را به یک برنامه کامپیوتری تشبیه کنیم! به هر بخش از بدن شما که به طور همزمان
یک عملیاتی را انجام می دهند یک thread می گوییم.
در برنامه نویسی هم کاربرد thread همین گونه می باشد،یعنی ما قصد داریم برنامه مون رو
از تک بعدی و تک کاره ای خارج کنیم و برنامه ای با استفاده از مفهوم چندنخی بنویسیم که
توانایی اجرای همزمان چندین کار را داشته باشد.
مثلا در بدن انسان از مفهوم چندنخی استفاده شده است و ما می توانیم همزمان که قلبمون
در حال تپش و پمپاژ خون و معده مان در حال هضم غذا و کلیه هامون در حال تصفیه خون
و چشمون در حال دیدن و گوششمون در حال شنیدن هست خم شویم و گوشی هوشمند
خود را برداریم و پست جعفر که در اینستاگرام گذاشته رو با انگشت شست لایک کنیم :-)
اگر در بدن انسان از مفهوم چندنخی استفاده نشده بود یک فاجعه رخ می داد!!! یعنی
در ساده ترین حالت ممکن که داشتیم با دوستمون صحبت می کردیم ابتدا بخش چشم
دوستمون رو میدید بعد که کار دیدن تمام می شد یهویی چشمون بسته می شد و
بخش گوش کار می کرد!! بعد که قصد جواب دادن به دوستمون رو داشتیم یهویی
بخش گوش غیر فعال میشد و بخش دهان کار میکرد البته اگر شانس اینو داشته باشیم
که قلبمون کار و کنه و متوقف نشده باشه :-)
در برنامه نویسی هم مفهوم چندنخی (Multithreading) بسیار مهم و حیاتی برای
برنامه ما می باشد. مثلا اگر قصد ساخت یک بازی را داشتیم باید از مفهوم چندنخی
استفاده کنیم! چرا که یک بازی باید پاسخ گوی همزمان زدن دکمه های کیبورد توسط کاربر،
حرکت اشیای درون بازی، گرافیک بازی و... باشد!!
امیدوارم توانسته باشم با مثال مفهوم چندنخی (Multithreading) را برای شما روشن کنم.
حالا می رویم سراغ مفهوم چندنخی (Multithreading) در زبان جاوا و چگونکی
استفاده از آن هنگام کد نویسی :-)

چرخه حیات یک thread (Life Cycle of a Thread) :
یک thread در چرخه حیات خود مراحل مختلفی را طی می کند. برای مثال یک thread
متولد می شود،اجرا می شود و سپس می میرد.نمودار زیر چرخه کامل حیات یک thread را نشان می دهد:

مراحل ایجاد ترد در جاوا

در زیر مراحل چرخه حیات thread را بررسی می کنیم:

New (متولد شدن):
در این مرحله یک thread جدید ایجاد کرده و چرخه حیات thread ایجاد شده شروع می شود.
در این مرحله thread فقط متولد یا ایجاد شده است و هیچ کار دیگه ای نمی کند
و در همین حالت باقی می ماند.

Runnable(اجرا کردن):
در این مرحله  thread تازه متولد شده به حالت آماده به اجرا در می آید.thread
  در این حالت برای اجرای وظیفه ای در نظر گرفته می شود.

Waiting (در حالت انتظار):
گاهی اوقات یک thread به حالت انتظار می رود.خب چه موقع؟! وقتی که یک
thread دیگر در حال اجرای وظیفه ای باشد ،thread اول تا اتمام کار thread دوم
به حالت انتظار یا wait می رود و بعد از این که thread دوم انجام وظیفه اش تمام شد
thread اول دوباره Runnable یا به وضعیت اجرایی شدن می رود.
مثلا وقتی که دوست شما دارد باهاتون صحبت می کند ،اگر گوش شما را یک thread
فرض کنیم که Runnable شده و در وضعیت running  قرار گرفته و حرف های دوستتون
را می شنود.همزمان که thread گوش شما در حال شنیدن هست ،thread دهان شما
در حال wainting یا انتظار قرار گرفته که بعد از اتمام گوش دادن ، thread دهان به
وضعیت Runnable  در آمده و شروع به حرف زدن می کند و thread گوش به حالت
waiting یا انتظار می رود :-)

Dead (مردن یا خاتمه):
یک thread ، Runnable شده هنگامی به وضعیت Dead می رود یا خاتمه پیدا می کند
که وظیفه ای که بر دوش داشته تمام شده باشد.

پیاده سازی Thread در جاوا

پیاده سازی thread در جاوا به این گونه است که ما می توانیم کلاس های خود را
به یک thread تبدیل سازیم.یعنی کاری کنیم که کلاس های ما یک thread در نظر گرفته شوند.

ایجاد یک Thread با پیاده سازی اینترفیس Runnable :
برای این که کلاس شما یک thread در نظر گرفته شود کافیست در کلاس
خود اینترفیس Runnable را پیاده سازی کنید.یعنی  اینترفیس Runnable را در
کلاس خود  implements کنید.

برای تبدیل کلاس خود به یک thread کافیست گام های زیر را بردارید:


گام اول:
 اینترفیس Runnable را در کلاس خود  implements کنید:
فرض کنید کلاسی بصورت زیر داشته باشیم:
 
package  javalike;

public  class  Cat {

}

حالا قصد داریم کاری کنیم که کلاس Cat یک Thread درنظر گرفته شود.برای این کار 
  اینترفیس Runabble   را در کلاس  Cat implements می کنیم:

 
 
package  javalike;
 
public  class  Cat  implements  Runnable {
 
}
گام دوم:
 
اینترفیس Runnable در بدنه خود یک متد با نام run دارد که شکل نوشتن آن بصورت زیر است:
 
  public void run();             

حال طبق مبحث اینترفیس که در جلسات گذشته مطالعه کردیم ،هر کلاسی که یک اینترفیس
را implements کرد بلاجبار باید متدهای درون اینترفیس را در بدنه خود پیاده سازی کند.
خب ما در گام اول اینترفیس Runabble   را در کلاس  Cat implementsکردیم پس لازم است
متد run اینترفیس Runnable را در کلاس Cat پیاده سازی کنیم:
 
package  javalike;

public  class  Cat  implements  Runnable {


    public void run() {
        
    }

}

 

همان طور که گفتیم یک thread هنگام ایجاد و در حالت اجرایی شدن وظیفه و عمل
مشخصی را انجام می دهد. این وظیفه و عملی که برای thread مشخص می کنیم
باید درون متد run قرار گیرد. نتیجه می گیریم که هر دستور لازم الاجرایی که
برای thread مشخص می کنیم باید درون متدrun قرار گیرد.
حالا ما قصد داریم دستور چاپ پیام "Hello Javalike" را در متد run پیاده سازی کنیم:

 
package  javalike;

public  class  Cat  implements  Runnable {   


    public  void  run()  {
    
        System.out.println("Hello Javalike");
    }

}

خب اگر ما thread خود را متولد کنیم ، بعدش به مرحله اجرایی شدن برسانیم
آن وظیفه ای که thread ما انجام می دهد  اجرای دستورات درون متدrun
می باشد و از آنجایی که دستور ما در درون متد runدر مثال بالا چاپ پیام
"Hello Javalike" می باشد ، در محیط کنسول پیام مذکور چاپ می شود.
خب تا این جا چطور بود؟ امیدوارم که واضع و روشن توضیح داده باشم البته
هنوز تمام نشده!! بریم سراغ گام بعدی :-)


گام سوم:

در گام سوم نیاز داریم که Thread خود را متولد یا ایجاد کنیم!!! یا به عبارت دیگر
در مرحله new قرارش دهیم.ما در اینجا از واژه تولد یا ایجاد Thread استفاده کردیم!
در برنامه نویسی جاوا برای تولد یا ایجاد یک Thread باید از کلاس Thread شی ایجاد کنیم
شبیه شی سازی در حالت عادی از یک کلاس! خب Thread هم یک کلاس آماده در پکیج java.lang می باشد.
پس برای برای تولد یک Thread کافیست از کلاس Thread یک نمونه یا شی ایجاد کنیم.
هنگام شی سازی از کلاس Thread نیاز به صدا زدن سازنده آن داریم.این کلاس
سازنده های گوناگونی دارد.یکی از متداول ترین سازنده های آن که ازش استفاده می کنیم بصورت زیر است:
 
Thread(Runnable arg0, String arg1)

این سازنده دو پارامتر میگیرد، پارامتر اول یعنی arg0 نمونه ای (شی ) از کلاسی است
که اینترفیس Runnable را implements کرده باشد. مثلا از آنجایی که کلاس Cat
اینترفیس Runnable را implements کرده ،شی از نوع کلاس Cat می تواند
جایگزین پارامتر arg0 شود.

بجای arg1 نیز می توانید نامی به بچه Thread تازه متولد شده خود بدهید :-)

خب تغییراتی که به کد مثال کلاس Cat می دهیم بصورت زیر است:
یک متد main برای کلاس Cat تعریف می کنیم و یک  شی از نوع کلاس Cat
و یک شی از نوع کلاس Thread ایجاد می کنیم:
 
package  javalike;

public  class  Cat  implements  Runnable {  


    public  void  run( )  {
    
        System.out.println("Hello Javalike");
    }

    public  static  void  main(String  args[]) {
        Cat  cat=new  Cat();
    Thread  thCat= new  Thread(cat, "jesi");
    
    
    }
    
}

 
•    در اینجا یک شی با نام cat از کلاس Cat ایجاد کرده و درون پارامتر اول سازنده کلاس
Thread قرار داده ایم. پارامتر دوم سازنده Thread را یک مقدار از نوع String که نام Thread
ما را مشخص می کند قرار داده ایم.
•    شی thCat که از نوع کلاس  Thread می باشد ، Thread تازه متولد شده ما را تشکیل می دهد.


گام چهارم:

همان طور که گفتیم Thread یک کلاس می باشد که دارای ویژگی ها و متدهایی
می باشد.یکی از متدهای کلاس Thread بصورت زیر است:

 
Void  start(); 

 
بعد از ایجاد یک شی از نوع کلاس Thread و متولد شدن Thread جدید ، نیاز داریم
که Thread مان شروع به اجرا شدن کند. برای این کار از طریق شی ساخته شده از نوع
Thread متد start را صدا می زنیم با این کار Thread ما شروع به اجرای وظایف خود
که در متد run() برایش مشخص کرده ایم می کند.
پس متد start باعث می شود دستورات درون متد run ، Thread ما اجرا شود.
تغییرات مثال بالا را در زیر مشاهده می کنید:

 
package javalike;

public  class  Cat  implements  Runnable {

    public  void  run() {

        System.out.println("Hello Javalike");
    }

    public  static   void main(String args[]) {
        Cat   cat = new  Cat();
        Thread  thCat = new  Thread(cat, "jesi");
        thCat.start();

    }

}

اگر برنامه بالا را کامپایل و اجرا کنیم خروجی بصورت زیر خواهد بود:
 
Hello Javalike
 
خلاصه ای از کارایی که کردیم :

ما قصد داشتیم کاری کنیم که کلاس Cat یک Thread درنظر گرفته شود.برای این کار
  اینترفیس Runnable را در کلاس Cat پیاده سازی یا implements کردیم. با این کار
  باید متد run موجود در اینترفیس Runnable را در کلاس خود پیاده سازی و override
می کردیم.بعد از پیاده سازی متد run در کلاس خود رفتیم سراغ دستوری که نیاز داشتیم
هنگام اجرای Thread برامون اجرا شود! خب دستور مورد نظر خود را در متد run موجود
در کلاس Cat پیاده سازی کردیم. تا اینجا کلاس Cat را تبدیل به یک Thread کردیم اما
نیاز داشتیم که این Thread یعنی کلاس Cat را متولد کنیم! برای این کار از کلاس Cat
یک شی ایجاد کردیم و بعدش رفتیم سراغ کلاس Thread و از آن هم  یک شی ساختیم
بعدش شی کلاس Cat را به عنوان پارامتر اول سازنده کلاس Thread قرار دادیم و پارامتر
دوم سازنده کلاس Thread را یک مقدار از نوع String که نام Thread را تشکیل می داد قراردادیم.

تا اینجا مرحله تولد و ایجاد Thread را گذراندیم و نیاز داشتیم که Thread ما به مرحله
اجرایی شدن برود برای این کار با استفاده از متد start ، ترد(Thread) خود را استارت زده
و به مرحله آغاز و اجرایی شدن وارد کردیم ، در این مرحله دیگه Thread ما شروع به اجرا کردن
وظایف خود که از قبل درون متد run موجود در کلاس Cat پیاده سازی کرده بودیم را می کند.
گام سوم و چهارم را در تصویر(1) ، تصویر(2) و تصویر(3)  مشاهده می کنید:

مراحل ایجاد Thread در جاوا
تصویر(1)-مرحله ایجاد و تولد Thread جدید

مراحل ایجاد thread در جاوا
تصویر(2)- در این مرحله Thread  ما با متد start به مرحله آماده به اجرا می رسد
آموزش thread در جاوا
تصویر(4)- در این مرحله دستورات درون متد run واقع در Thread ما در حال اجرا شدن می باشد.

 
پس بصورت خلاصه برای تبدیل کلاس خود به Threadبصورت زیر عمل می کنیم:
1.    اینترفیس Runnable را در کلاس خود  implements می کنیم.
2.    متد run را در کلاس خود پیاده سازی می کنیم.
3.    از کلاس خود شی می سازیم.
4.    از کلاس Thread شی ساخته و شی ایجاد شده از کلاس خود را به عنوان پارامتر
به سازنده کلاس Thread می دهیم.
5.    با استفاده از متد start ترد(Thread) خود را به مرحله شروع و اجرا شدن می رسانیم
و با اولیتی که سیستم عامل برای Thread شما برنامه ریزی کرده ، دستورات درون
متد run واقع در Thread شما ، شروع به اجرا شدن می کنند.

نکته:در بالا مورد 5 به اولیت سیستم عامل برای اجرای Thread اشاره کردیم!
این را بدانید که حتی بعد از استفاده از متد start اجرا شدن یا با تاخیر اجرا شدن و... Thread ما
بستگی به اولیتی است که سیستم عامل برای Thread های ما درنظر و برنامه ریزی کرده است می باشد.
ما در جاوا خواندیم که هنگام اجرای برنامه ، خط به خط کدهای برنامه خوانده و اجرا می شود!
اما در Thread ها اینگونه نیست! اجرا شدن Thread ها هنگام اجرای برنامه بستگی به
اولیت بندی داره که سیستم عامل برای Thread های ما انجام داده است.مثلا اگر سه
Thread داشته باشیم به نام های t1،t2 و t3 و ترتیب start خوردن این سه
Thread در برنامه بصورت زیر باشد:

 
t1.start();
t2.start();
t3.start();

 
در اولین نگاه طبق قانون خط به خط اجرا شدن دستورات درون برنامه ،
ابتدا باید دستورات Thread شماره یک و بعد دستورات Thread شماره دو
و در نهایت دستورات Thread شماره سه اجرا شود، اما اینگونه نیست!!!
ترتیب اجرای دستورات Thread ها را سیستم عامل مشخص می کند و
یعنی امکان دارد با وجود start خوردن Thread شماره یک در ابتدا ، اول
دستورات Thread شماره سه اجرا شود!!!! و بعدش دستورات Thread شماره یک
و بعد Thread شماره دو.پس ترتیب اجرای Thread ها در دست ما نیست و
سیستم عامل بر اساس اولیت Thread ها ، آنها را اجرا می کند.
برای درک بیشتر این موضوع به مثال زیر توجه کنید:

مثال:
package  javalike ;

class  A  implements  Runnable {

    public  void  run() {

        System.out.println("Number1");
    }
}

class  B  implements  Runnable {

    public  void  run() {

        System.out.println("Number2");
    }
}

class  C  implements  Runnable {

    public  void  run() {

        System.out.println("Number3");
    }
}

public  class  Test {

    public  static  void  main(String[] args) {
        A  a  = new  A();
        B  b = new  B();
        C  c = new  C();
        Thread  t1 = new  Thread(a, "number1");
        Thread  t2 = new  Thread(b, "number2");
        Thread  t3 = new  Thread(c, "number3");
        t1.start();
        t2.start();
        t3.start();
    }
}
 
خروجی: بعد از کامپایل و اجرای برنامه خروجی بصورت زیر می باشد:
 
Number3
Number1
Number2
•    در این مثال ما سه کلاس با نام های A,B,C داریم که اینترفیس Runnable را
implements کرده اند. در واقع میشه گفت سه Thread با نام های A,B,C داریم.
•    در کلاس Test از سه کلاس مذکور شی ساخته و همچنین سه بار از کلاس Thread
شی ایجاد کرده و شی کلاس های A,B,C را به سازنده کلاس Thread های ساخته شده داده ایم.
•    حال به ترتیب Thread های t1 ،t2 و t3 را با متد start ، استارت زده ایم! اما
همان طور که در مورد تعیین اولیت اجرای Thread ها توسط سیستم عامل
صحبت کردیم ، ابتدا به جای اجرای دستورات ترد(Thread) t1 ، دستورات ترد(Thread)
، t3 اجرا می شود بعدش t1 و در پایان دستورات ترد(Thread) ، t2 اجرا می شود.
پس نتیجه می گیریم ترتیب و حتی زمان اجرای Thread ها را سیستم عامل مشخص
میکند. سیستم عامل دیگه دوست داره زورش میرسه :-) بدن یک انسان رو در نظر
بگیر مثلا فرض کن فردی دوست داشته باشه ترتیب اجرای بخش های بدنش به این
صورت باشه که اول صحبت کنه بعدش قلبش کار کنه ! مگه میشه؟! نمیشه! :-)
جناب سیستم عامل هم حتما ی چیزایی میدونه که اولیت ها رو جابه جا میکنه :-)

•    حال اگر دوباره برنامه مثال بالا را اجرا کنیم با خروجی متفاوتی روبرو می شویم:

 
Number1
Number2
Number3
و دوباره برنامه رو اجرا می کنیم:
Number1
Number3
Number2
•    همان طور که مشاهده می کنید با هر بار اجرا کردن برنامه فوق خروجی متفاوتی داریم،
دلیلش اینه که از Thread استفاده کردیم ، و برای اولیت و زمان اجرا Thread ها
سیستم عامل تصمیم می گیرد.

ادامه این جلسه آموزشی را در لینک زیر بصورت پی دی اف شده مرتب دانلود کنید.

 
 این جلسه آموزشی را می توانید بصورت  کتاب الکترونیکی (PDF شده) در لینک زیر دریافت کنید.
این جلسه آموزشی را بصورت کامل و مرتب شده در لینک زیر دانلود کنید:(در صورت خرابی لینک گزارش دهید)

آموزش آسان و ساده زبان برنامه نویسی جاوا

لینک دانلود
نشر این مطلب با ذکر منبع (لینک سایت) بلامانع است.
برای با خبر شدن از جدیدترین مطالب آموزشی جاوا عضو کانال تلگرام ما شوید.
نظرات کاربران
*نام و نام خانوادگی
* پست الکترونیک
* متن پیام

بستن
*نام و نام خانوادگی
* پست الکترونیک
* متن پیام

1 نظر
محمد
سه شنبه شانزدهم خرداد ۹۶
پاسخ
()
()
محمد
سلام چطور یک آرایه رو با اطلاعاتش تو فایل ذخیره کنیم بعد به قسمت مورد نظر خود مثلاa[5] دست رسی داشته باشیم. بطور مثال بشه a[5] رو مساوی صفر قرار بدیم و بشه رو اعداد ذخیره تو ارایه که در فایل قرار دادیم اعمال ریاضی انجام بدیم. لطفا مثالی در این مورد قرار بدین. با تشکر از سایت خوبتون.
پاسخ مدیر سایت
سلام. درخواست شما انجام شد، مثال سری هفتم کار با فایل در جاوا را مشاهده کنید.
پاسخ مدیر سایت
طراحی سایتطراحی سایتسایت سازسایت سازفروشگاه سازفروشگاه ساز