Հիմնական տարբերություն – քուն ընդդեմ սպասելու Java-ում
Sleep-ը և սպասելը Java-ում բազմաթելերի համար օգտագործվող երկու մեթոդներ են: Քնի մեթոդը պատկանում է Thread դասին, մինչդեռ սպասման մեթոդը Object դասից է: Java-ում քնի և սպասման հիմնական տարբերությունն այն է, որ քունն օգտագործվում է ընթացիկ շղթայի կատարումը կասեցնելու համար նշված թվով միլիվայրկյաններով, մինչդեռ սպասման մեթոդն օգտագործվում է ընթացիկ շարանը սպասելու համար, մինչև մեկ այլ շարանը կանչի ծանուցումը կամ notifyAll մեթոդը օբյեկտի համար:
Թելը օպերացիոն համակարգում մշակման ամենափոքր միավորն է: Դա ծրագրի ներսում հսկողության մեկ հաջորդական հոսք է:Թելերը թեթև են: Multithreading-ը մի քանի թելեր միաժամանակ գործարկելու մեխանիզմն է: Ծրագրավորման լեզուները, ինչպիսիք են Java-ն, աջակցում են բազմաթելային: Multithreading-ն ունի առավելություններ, քանի որ այն թույլ է տալիս միաժամանակ մի քանի թելեր վարել, և թելերը միմյանցից անկախ են: Java-ում կան մեթոդներ, որոնք կարող են օգտագործվել բազմաթելերի համար: Նրանցից երկուսը քնում են և սպասում:
Ի՞նչ է քունը Java-ում:
Օպերացիոն համակարգում գործում են բազմաթիվ գործընթացներ: Գործընթացը կատարվող ծրագիր է: Յուրաքանչյուր պրոցես կարող է ունենալ մի քանի թելեր, և այդ թելերի միջև տեղի է ունենում համատեքստի փոխարկում: Java-ում թեմա ստեղծելու երկու եղանակ կա. Դա ընդլայնելով thread դասը կամ Runnable ինտերֆեյսի ներդրմամբ: Thread դասը ունի կոնստրուկտորներ և մեթոդներ՝ թելի վրա գործողություններ ստեղծելու և իրականացնելու համար: Thread դասը ընդլայնում է Object դասը և իրականացնում Runnable ինտերֆեյսը: Runnable ինտերֆեյսը պետք է իրականացվի ցանկացած դասի կողմից, որի օրինակները նախատեսված են շղթայով գործարկվելու համար:Երբ շարանը գործարկվում է, կոդը, որը պետք է կատարվի, գրվում է գործարկման մեթոդի ներսում: Այն շարանը, որը պետք է գործարկվի, ընտրվում է շղթաների ժամանակացույցի կողմից: Մեկ գործընթացում աշխատում է միայն մեկ շարանը:
Թելը անցնում է մի քանի փուլով: Thread դասի օբյեկտ ստեղծելուց հետո ծրագրավորողը կարող է կանչել մեկնարկի մեթոդը։ Մինչ այդ մեթոդը կիրառելը, ասվում է, որ շարանը նոր վիճակում է: Թելերի ժամանակացույցն ընտրում է գործարկման շարանը: Եթե շարանը դեռ ընտրված չէ շղթաների ժամանակացույցի կողմից, բայց եթե գործարկման մեթոդը կանչված է, ապա շարանը գտնվում է գործարկման վիճակում: Այն բանից հետո, երբ շարանը ժամանակացույցն ընտրում է գործարկվող շարանը, այն անցնում է գործարկման վիճակին: Եթե շարանը կենդանի է, բայց ներկայումս չի կարող գործարկվել, ապա այն անգործունակ կամ արգելափակված վիճակում է: Գործարկման մեթոդի ավարտից հետո շարանը գնում է ավարտված վիճակի: Սրանք թելերի կյանքի ցիկլի հիմնական փուլերն են։
Թելերի դասում կան տարբեր մեթոդներ՝ տարբեր առաջադրանքներ կատարելու համար:Քնի մեթոդը օգտագործվում է մեթոդը որոշակի ժամանակով քնելու համար: Քնի մեթոդի շարահյուսությունը հանրային դատարկ քունն է (երկար միլիվայրկյաններով) InterruptedException-ը: Դա հանգեցնում է նրան, որ ներկայումս կատարվող շարանը ժամանակավորապես դադարեցնում է կատարումը որոշակի միլիվայրկյանների համար: Եթե մեկ այլ շարանը ընդհատում է ընթացիկ շարանը, ապա ընթացիկ շղթայի ընդհատված կարգավիճակը ջնջվում է, երբ այս բացառությունը նետվում է:
Նկար 01. Java ծրագիր քնի մեթոդով
Ըստ վերոնշյալ ծրագրի՝ գործարկման մեթոդը պարունակում է կոդ, որը պետք է կատարվի։ Հիմնական ծրագրում ստեղծվում է ExampleThread1-ի երկու օբյեկտ, որոնց վրա կանչվում են մեկնարկային մեթոդները։ Դա թույլ կտա գործարկել կոդը գործարկման մեթոդի ներսում: Միաժամանակ աշխատում է միայն մեկ շարանը: Թելով:քնել (1000); թույլ կտա առաջին շարանը դադարեցնել կատարումը 1000 միլիվայրկյանով: Երբ շարանը քնած է, շղթաների ժամանակացույցը վերցնում է մյուս շարանը:
Ի՞նչ է սպասել Java-ում:
Բազմաթիվ շղթաներ կարող են մուտք գործել ընդհանուր ռեսուրս: Դա կարող է առաջացնել սխալ արդյունք: Թեմաների համաժամացումը կարող է օգտագործվել միայն մեկ շղթա ստեղծելու համար՝ ընդհանուր ռեսուրս մուտք գործելու համար: Ենթադրենք իրավիճակը հետևյալ կերպ. Եթե կան երկու շղթաներ, ինչպիսիք են t1 և t2, t1-ը սկսում է արժեքները պահել Text1.txt կոչվող տեքստային ֆայլում: Այդ արժեքները կօգտագործվեն որոշ այլ հաշվարկների համար, երբ t1 վերադառնա: Եթե t2-ը սկսվում է t1-ի վերադարձից առաջ, t2-ը կարող է փոխել t1-ով պահպանված արժեքները: Սա կարող է հանգեցնել t1-ի սխալ արդյունքի: Համաժամացման օգնությամբ, երբ t1-ը սկսում է օգտագործել Text1.txt ֆայլը, այդ ֆայլը կարող է կողպվել, ուստի այն հասանելի է միայն t1-ով։ T2-ը չի կարող փոխել այն, մինչև t1-ը չարձակի կողպեքը՝ այդ տեքստային ֆայլը մուտք գործելու համար: Երբ առաջադրանքն ավարտված է, t1-ը կարող է ազատել կողպեքը: Կողպեքը հայտնի է նաև որպես մոնիտոր:
Թելերի համաժամացմանը կարելի է հասնել միջթելային հաղորդակցության միջոցով: Կրիտիկական բաժինը ծածկագրի հատված է, որը մուտք է գործում ընդհանուր ռեսուրսներ: Թելերի միջև հաղորդակցության մեջ շարանը դադարեցվում է, որն աշխատում է իր կրիտիկական հատվածում, և մեկ այլ շարանը թույլատրվում է մուտք գործել նույն կրիտիկական հատվածում, որը պետք է կատարվի: Այն իրականացվում է սպասման, ծանուցման և ծանուցման բոլոր մեթոդների միջոցով: Նրանք պատկանում են Object դասին։ Սպասման մեթոդն օգտագործվում է, որպեսզի ընթացիկ շարանը բաց թողնի կողպեքը և սպասի, մինչև մեկ այլ շարանը կանչի օբյեկտի համար notify կամ notifyAll մեթոդը: Ծանուցման մեթոդն օգտագործվում է մեկ շարանը արթնացնելու համար, որը սպասում է կողպեքին: «NotifyAll»-ը արթնացնում է կողպեքի վրա սպասող բոլոր շղթաները:
Նկար 02. Հաշվիչի դաս
Նկար 03. Հիմնական մեթոդ
Հաշվիչ դասը ընդլայնում է շարանը: Համաժամեցված բլոկը գտնվում է գործարկման մեթոդի ներսում: For loop and notify մեթոդը գտնվում է համաժամացված բլոկի ներսում: Հիմնական մեթոդի ներսում ստեղծվում է թելի օրինակ և մեկնարկային մեթոդը կոչվում է այդ օրինակի վրա: Հիմնական մեթոդը կսպասի մինչև շարանը ծանուցում տա: Ծրագիրը կատարելիս հիմնական մեթոդը սպասում է մինչև գործարկման մեթոդի ամբողջ կատարումը և սպասում է ծանուցման մեթոդին: Երբ ծանուցման մեթոդը կանչվի, հիմնական մեթոդը դադարում է սպասել և սկսում է գործարկել մնացած կոդը: Main-ը սպասում է մինչև Հաշվիչի շարանը ավարտվի: Վերջում տպագրվում է գումարի արդյունքը։
Եթե չկա համաժամեցված բլոկ, և եթե հիմնական մեթոդն ունի ստորև բերված կոդ, այն արդյունքը կտա որպես զրո, քանի որ այն չի սպասում մյուս թեմայի ավարտին:
Calculator t1=նոր Հաշվիչ ();
t1. սկիզբ ();
System.out.println (t1.sum);
Ի՞նչ նմանություն կա քնելու և սպասելու միջև Java-ում:
Եվ քնելը և սպասելը մեթոդներ են, որոնք կարող են օգտագործվել Java-ում բազմալեզու կիրառման ժամանակ
Ո՞րն է տարբերությունը քնելու և սպասելու միջև Java-ում:
քուն ընդդեմ սպասելու Java-ում |
|
| Քնի մեթոդը ստիպում է ընթացիկ շարանը կասեցնել աշխատանքը նշված թվով միլիվայրկյաններով՝ հաշվի առնելով համակարգի ժամանակաչափերի և ժամանակացույցերի ճշգրտությունը և ճշգրտությունը: | Սպասման մեթոդը ստիպում է ընթացիկ շարանը սպասել, մինչև մեկ այլ շարանը կանչի օբյեկտի համար notify կամ notifyAll մեթոդը: |
| Կապակցում կողպեքի հետ | |
| Քնի մեթոդը չի ազատում օբյեկտի կողպումը համաժամացման ընթացքում: | Սպասման մեթոդն անջատում է կողպումը համաժամացման ընթացքում: |
| Կատարման մեթոդ | |
| Քնի մեթոդն իրականացվում է ընթացիկ շղթայի վրա: | Սպասման մեթոդը կանչվում է օբյեկտի վրա: |
| հարակից դասարան | |
| Քունը Thread դասի մեթոդ է: | Սպասումը Object դասի մեթոդ է: |
| Ավարտում | |
| Քնի գործընթացը ավարտվում է նշված ժամանակահատվածի ավարտից հետո: | Սպասման եղանակն ընդհատվում է՝ զանգահարելով ծանուցել կամ ծանուցելԲոլոր մեթոդները: |
Ամփոփում – քնել ընդդեմ սպասել Java-ում
Օպերացիոն համակարգում գործում են բազմաթիվ գործընթացներ: Յուրաքանչյուր գործընթաց կարող է ունենալ մի քանի թելեր: Թելը օպերացիոն համակարգում մշակման ամենափոքր միավորն է: Java ծրագրավորման լեզուն աջակցում է բազմաթելային: Այն թույլ է տալիս միաժամանակ մի քանի թելեր վարել: Քունը և սպասելը երկու մեթոդ են, որոնք կարող են օգտագործվել բազմաշերտություն իրականացնելիս: Java-ում քնի և սպասման միջև տարբերությունն այն է, որ քունն օգտագործվում է ընթացիկ շղթայի կատարումը կասեցնելու համար նշված թվով միլիվայրկյաններով, մինչդեռ սպասման մեթոդն օգտագործվում է ընթացիկ շարանը սպասելու համար, մինչև մեկ այլ շարանը կանչի notify կամ notifyAll: մեթոդ օբյեկտի համար։
