ძირითადი განსხვავება - ძილი და ლოდინი ჯავაში
ძილი და ლოდინი არის ორი მეთოდი, რომელიც გამოიყენება Java-ში მრავალძახიანობისთვის. ძილის მეთოდი ეკუთვნის Thread კლასს, ხოლო ლოდინის მეთოდი არის Object კლასიდან. ჯავაში ძილისა და ლოდინის მთავარი განსხვავება ისაა, რომ ძილი გამოიყენება მიმდინარე ძაფის შესრულების შესაჩერებლად მილიწამების მითითებულ რაოდენობაზე, ხოლო ლოდინის მეთოდი გამოიყენება იმისთვის, რომ მიმდინარე ძაფმა დაელოდოს, სანამ სხვა ძაფი გამოიძახებს შეტყობინებას ან notifyAll მეთოდი ობიექტისთვის.
ძაფი არის დამუშავების ყველაზე პატარა ერთეული ოპერაციულ სისტემაში. ეს არის პროგრამის ფარგლებში კონტროლის ერთი თანმიმდევრული ნაკადი.ძაფები მსუბუქია. Multithreading არის რამდენიმე ძაფების ერთდროულად გაშვების მექანიზმი. პროგრამირების ენები, როგორიცაა ჯავა, მხარს უჭერს მრავალნაკადს. Multithreading-ს აქვს უპირატესობები, რადგან ის საშუალებას გაძლევთ გაუშვათ რამდენიმე თემა ერთდროულად და ძაფები ერთმანეთისგან დამოუკიდებელია. ჯავაში არის მეთოდები, რომლებიც შეიძლება გამოყენებულ იქნას მულტირედინგისთვის. მათგან ორს სძინავს და ელოდება.
რა არის ძილი ჯავაში?
ოპერაციულ სისტემაში მრავალი პროცესი მუშაობს. პროცესი არის პროგრამა, რომელიც შესრულებულია. თითოეულ პროცესს შეიძლება ჰქონდეს რამდენიმე ძაფები და ამ ძაფებს შორის ხდება კონტექსტის გადართვა. ჯავაში თემის შექმნის ორი გზა არსებობს. ეს არის თემის კლასის გაფართოებით ან Runnable ინტერფეისის დანერგვით. Thread კლასს აქვს კონსტრუქტორები და მეთოდები ძაფზე ოპერაციების შესაქმნელად და შესასრულებლად. Thread კლასი აფართოებს Object კლასს და ახორციელებს Runnable ინტერფეისს. Runnable ინტერფეისი უნდა განხორციელდეს ნებისმიერი კლასის მიერ, რომლის ინსტანციებიც განკუთვნილია thread-ის მიერ შესრულებისთვის.როდესაც თემა შესრულდება, კოდი, რომელიც უნდა შესრულდეს, იწერება გაშვების მეთოდის შიგნით. თემა, რომელიც უნდა გაუშვას, ირჩევს ძაფების განრიგის მიერ. მხოლოდ ერთი თემა გადის ერთ პროცესში.
ძაფი გადის რამდენიმე ფაზას. Thread კლასის ობიექტის შექმნის შემდეგ, პროგრამისტს შეუძლია გამოიძახოს დაწყების მეთოდი. ამ მეთოდის გამოძახებამდე ნათქვამია, რომ ძაფი ახალ მდგომარეობაშია. ძაფების განმგეგმავი ირჩევს ძაფს გასაშვებად. თუ თემა ჯერ არ არის შერჩეული ძაფების განრიგის მიერ, მაგრამ თუ დაწყების მეთოდი გამოძახებულია, მაშინ ძაფი გაშვებად მდგომარეობაშია. მას შემდეგ, რაც ძაფების დამგეგმავი შეარჩევს შესასრულებლად ძაფს, ის გადადის გაშვებულ მდგომარეობაში. თუ თემა ცოცხალია, მაგრამ ამჟამად არ ექვემდებარება გაშვებას, მაშინ ის არ არის გაშვებული ან დაბლოკილი. გაშვების მეთოდის დასრულების შემდეგ, ძაფი მიდის შეწყვეტილ მდგომარეობაში. ეს არის ძაფის სასიცოცხლო ციკლის ძირითადი ფაზები.
არის thread-ის კლასში სხვადასხვა მეთოდი სხვადასხვა ამოცანების შესასრულებლად.ძილის მეთოდი გამოიყენება მეთოდის დასაძინებლად გარკვეული დროის განმავლობაში. ძილის მეთოდის სინტაქსი არის საჯარო void sleep (ხანგრძლივი მილიწამები) ისვრის InterruptedException. ეს იწვევს ამჟამინდელი შემსრულებელი ძაფის შესრულების დროებით შეჩერებას მილიწამების განსაზღვრული რაოდენობით. თუ სხვა თემა წყვეტს მიმდინარე თემას, ამ გამონაკლისის ჩაგდებისას მიმდინარე ნაკადის შეწყვეტის სტატუსი წაიშლება.
სურათი 01: ჯავის პროგრამა ძილის მეთოდით
ზემოხსენებული პროგრამის მიხედვით, გაშვების მეთოდი შეიცავს კოდს, რომელიც უნდა შესრულდეს. მთავარ პროგრამაში იქმნება ExampleThread1-ის ორი ობიექტი და მათზე გამოძახებულია დაწყების მეთოდები. ეს საშუალებას მისცემს კოდის გაშვებას გაშვების მეთოდის შიგნით. მხოლოდ ერთი ძაფი მუშაობს ერთდროულად. ძაფით.ძილი (1000); საშუალებას მისცემს პირველ ძაფს შეწყვიტოს შესრულება 1000 მილიწამით. როდესაც ძაფს სძინავს, ძაფების დამგეგმავი აირჩევს მეორე თემას.
რა არის ლოდინი ჯავაში?
რამდენიმე თემა შეიძლება წვდომა ჰქონდეს გაზიარებულ რესურსზე. ამან შეიძლება გამოიწვიოს არასწორი გამომავალი. ძაფების სინქრონიზაცია შეიძლება გამოყენებულ იქნას მხოლოდ ერთი ნაკადის შესაქმნელად საზიარო რესურსზე წვდომისთვის. დაუშვით სიტუაცია შემდეგნაირად. თუ არსებობს ორი თემა, როგორც t1 და t2, t1 დაიწყებს მნიშვნელობების შენახვას ტექსტურ ფაილში, სახელად Text1.txt. ეს მნიშვნელობები გამოყენებული იქნება სხვა გაანგარიშებისთვის, როდესაც t1 დაბრუნდება. თუ t2 იწყება t1-ის დაბრუნებამდე, t2-ს შეუძლია შეცვალოს t1-ით შენახული მნიშვნელობები. ამან შეიძლება გამოიწვიოს t1 არასწორი გამომავალი. სინქრონიზაციის დახმარებით, როდესაც t1 იწყებს Text1.txt ფაილის გამოყენებას, ეს ფაილი შეიძლება დაიბლოკოს, ამიტომ მასზე წვდომა მხოლოდ t1-ით არის შესაძლებელი. t2 ვერ შეცვლის მას, სანამ t1 არ გაათავისუფლებს საკეტს ამ ტექსტურ ფაილზე წვდომისთვის. როდესაც დავალება დასრულდება, t1-ს შეუძლია გაათავისუფლოს საკეტი. საკეტი ასევე ცნობილია როგორც მონიტორი.
ძაფების სინქრონიზაცია მიიღწევა ძაფთაშორისი კომუნიკაციით. კრიტიკული განყოფილება არის კოდის სეგმენტი, რომელიც წვდება საერთო რესურსებს. ძაფთაშორისი კომუნიკაციის დროს ძაფები შეჩერებულია, რომელიც მუშაობს მის კრიტიკულ განყოფილებაში და სხვა ძაფს ეძლევა უფლება შევიდეს იმავე კრიტიკულ განყოფილებაში შესასრულებლად. ის განხორციელებულია ლოდინის, შეტყობინების და NotifyAll მეთოდების გამოყენებით. ისინი მიეკუთვნებიან Object კლასს. მოლოდინის მეთოდი გამოიყენება იმისთვის, რომ მიმდინარე ძაფმა გაათავისუფლოს დაბლოკვა და დაელოდოს სანამ სხვა თემა გამოიძახებს notify ან NotifyAll მეთოდს ობიექტისთვის. შეტყობინების მეთოდი გამოიყენება ერთი ძაფის გასაღვიძებლად, რომელიც ელოდება დაბლოკვას. NotifyAll აღვიძებს ყველა თემას, რომელიც ელოდება დაბლოკვას.
სურათი 02: კალკულატორის კლასი
სურათი 03: ძირითადი მეთოდი
კალკულატორის კლასი აფართოებს თემას. სინქრონიზებული ბლოკი არის გაშვების მეთოდის შიგნით. for loop და notify მეთოდი არის სინქრონიზებული ბლოკის შიგნით. ძირითადი მეთოდის შიგნით, შექმნილი ძაფის მაგალითი და დაწყების მეთოდი გამოიძახება ამ ინსტანციაზე. ძირითადი მეთოდი დაელოდება სანამ თემა არ გასცემს შეტყობინებას. პროგრამის შესრულებისას მთავარი მეთოდი ელოდება გაშვების მეთოდის მთელ შესრულებას და ელოდება შეტყობინებების მეთოდს. შეტყობინების მეთოდის გამოძახების შემდეგ, მთავარი მეთოდი წყვეტს ლოდინს და იწყებს დანარჩენი კოდის შესრულებას. Main ელოდება კალკულატორის თემის დასრულებას. საბოლოოდ, ჯამის შედეგი იბეჭდება.
თუ არ არის სინქრონიზებული ბლოკი და თუ მთავარ მეთოდს აქვს ქვემოთ მოცემული კოდი, ის გამომავალს მისცემს ნულს, რადგან ის არ ელოდება სხვა თემის დასრულებას.
კალკულატორი t1=ახალი კალკულატორი ();
t1. დაწყება ();
System.out.println (t1.sum);
რა მსგავსებაა ძილსა და ლოდინს შორის ჯავაში?
როგორც ძილი, ასევე ლოდინი არის მეთოდები, რომლებიც შეიძლება გამოყენებულ იქნას Java-ში მრავალძაფის განხორციელებისას
რა განსხვავებაა ძილსა და ლოდინს შორის ჯავაში?
ძილი vs ლოდინი ჯავაში |
|
| ძილის მეთოდი იწვევს მიმდინარე ძაფის შესრულების შეჩერებას მილიწამების მითითებულ რაოდენობაზე, სისტემური ტაიმერების და გრაფიკების სიზუსტისა და სიზუსტის გათვალისწინებით. | ლოდინის მეთოდი იწვევს მიმდინარე ძაფს ლოდინს, სანამ სხვა თემა გამოიძახებს notify ან NotifyAll მეთოდს ობიექტისთვის. |
| ასოციაცია საკეტთან | |
| ძილის მეთოდი არ ათავისუფლებს ობიექტს დაბლოკვას სინქრონიზაციის დროს. | ლოდინის მეთოდი ათავისუფლებს დაბლოკვას სინქრონიზაციის დროს. |
| აღსრულების მეთოდი | |
| ძილის მეთოდი შესრულებულია მიმდინარე თემაში. | მოლოდინის მეთოდი გამოძახებულია ობიექტზე. |
| ასოცირებული კლასი | |
| ძილი არის Thread კლასის მეთოდი. | ლოდინი არის Object კლასის მეთოდი. |
| დასრულება | |
| ძილის პროცესი სრულდება მითითებული დროის დასრულების შემდეგ. | ლოდინის მეთოდი წყდება notify-ის გამოძახებით ან NotifyAll მეთოდები. |
შეჯამება – ძილი vs ლოდინი ჯავაში
ოპერაციულ სისტემაზე მუშაობს მრავალი პროცესი. თითოეულ პროცესს შეიძლება ჰქონდეს რამდენიმე ძაფი. ძაფი არის დამუშავების ყველაზე პატარა ერთეული ოპერაციულ სისტემაში. ჯავის პროგრამირების ენა მხარს უჭერს მრავალთრეადინგს. ის საშუალებას გაძლევთ გაუშვათ რამდენიმე თემა ერთდროულად. ძილი და ლოდინი არის ორი მეთოდი, რომელიც შეიძლება გამოყენებულ იქნას მრავალ ძაფების განხორციელებისას. Java-ში ძილისა და ლოდინის განსხვავება არის ის, რომ ძილი გამოიყენება მიმდინარე ძაფის შესრულების შესაჩერებლად მილიწამების მითითებულ რაოდენობაზე, ხოლო ლოდინის მეთოდი გამოიყენება იმისათვის, რომ მიმდინარე ძაფმა დაელოდოს სანამ სხვა თემა გამოიძახებს notify ან notifyAll-ს. მეთოდი ობიექტისთვის.
