जावा थ्रेड्स में "प्राथमिकता" को समझना - जावा, मल्टीथ्रेडिंग

मैं जावा और थ्रेड्स की दुनिया में नया हूँ..मैं बस एक उदाहरण कोड से गुजर रहा था: -

package com.alice.learnthread;

class NewThread implements Runnable{
Thread t;
long clicker=0;

private volatile boolean running=true;
NewThread(int p){
t=new Thread(this);
t.setPriority(p);
}
public void run(){
while(running){
clicker++;
}
}
public void stop(){
running=false;
}
public void start(){
t.start();
}

}

 public class TestThread {
public static void main(String[] args){
Thread r=Thread.currentThread();
r.setPriority(Thread.MAX_PRIORITY);
NewThread hi=new NewThread(Thread.NORM_PRIORITY+2);
NewThread lo=new NewThread(Thread.NORM_PRIORITY-2);
hi.start();
lo.start();
try{
r.sleep(5000);
}catch(InterruptedException e){
System.out.println("caught");
}
hi.stop();
lo.stop();
try{
hi.t.join();
lo.t.join();
}catch(InterruptedException e){
System.out.println("cau1");
}
System.out.println("hi = "+hi.clicker+" lo="+lo.clicker);
}

}

हालाँकि पुस्तक में आउटपुट के अनुसारउच्च प्राथमिकता वाले धागे में चर क्लिकर के लिए उच्च मूल्य होना चाहिए। लेकिन मेरे मामले में परिवर्तनीय क्लिकर के लिए मान उच्च प्राथमिकता वाले की तुलना में कम प्राथमिकता वाले धागे के लिए बहुत अधिक है। आउटपुट मेरे लिए नीचे की तरह है: -

hi = 2198713135 lo=2484053552

क्या इसका मतलब यह नहीं है कि कम प्राथमिकता वाला धागा मिलाउच्च प्राथमिकता एक से अधिक CPU समय ... क्या मुझे कुछ याद आ रहा है.. परिणाम ubuntu और win7 दोनों पर समान (कम प्राथमिकता वाले धागे के लिए उच्च क्लिकर मूल्य) हैं ...

उत्तर:

जवाब के लिए 2 № 1

जैसा कि सूल ने कहा, प्राथमिकता जेवीएम के लिए एक अनुबंध की तुलना में अधिक संकेत है। आपके मामले में, आपके परिणाम को कई सिद्धांतों द्वारा समझाया जा सकता है:

• दूसरा धागा तेजी से चलता है क्योंकि यह पहले एक के संकलन का लाभ लेता है और पहले एक के बाद बंद हो जाता है।
• तथ्य यह है कि जबकि लूप एक अस्थिर चर के मूल्य की जांच करता है jvm मूल्य को वास्तविक करने के लिए मजबूर करता है और इस समय के दौरान दूसरे धागे को सीपीयू दे सकता है।
• थ्रेड को रोकने के लिए स्टॉप विधियाँ बहुत समय लेती हैं।

यह कहना कुछ तथ्य है कि धागा अधिनियम अप्रत्याशित कैसे है। उदाहरण के लिए पहले कम प्राथमिकता वाले धागे को शुरू करने का प्रयास करें और मुझे यकीन है कि आपके पास एक अलग परिणाम होगा।

इसके अलावा, यह प्रयास करें:

public class TestThread
{
public static void main(String[] args){
Thread r=Thread.currentThread();
r.setPriority(Thread.MAX_PRIORITY);
NewThread hi=new NewThread(Thread.MAX_PRIORITY);
NewThread lo=new NewThread(Thread.MIN_PRIORITY);
hi.start();
lo.start();
try{
r.sleep(5000);
}catch(InterruptedException e){
System.out.println("caught");
}
hi.interrupt();
lo.interrupt();

System.out.println("hi="+hi.clicker);
System.out.println("lo="+lo.clicker);
}
}
class NewThread extends Thread{
long clicker=0;

NewThread(int p){
setPriority(p);
}
public void run(){
while(true){
clicker++;
}
}
}

मुझे यकीन है कि अस्थिर चर को हटाने और थ्रेड को रोकने के तरीके को बदलने से आपको एक अन्य परिणाम मिलेगा।

---

जवाब के लिए 3 № 2

जावा में थ्रेड प्राथमिकता इच्छित व्यवहार की गारंटी नहीं देती है। यह जेवीएम के लिए एक संकेत की तरह है। वास्तविक व्यवहार अंतर्निहित ओएस पर निर्भर करता है।

इसके अलावा, सहकारी बनाम Preemptive थ्रेडिंग के बारे में यह अच्छा सा पैरा पढ़ें: http://www.cafeaulait.org/course/week11/32.html

---

जवाब के लिए 0 № 3

धागे प्रकृति में अप्रत्याशित हैं। कम प्राथमिकता वाले धागे तब चलते हैं जब उच्च प्राथमिकता वाले धागे कुछ कारणों के कारण नहीं चल पाते हैं, और जब सभी थ्रेड्स CPU के लिए प्रतिस्पर्धा कर रहे होते हैं, तो थ्रेड प्राथमिकता प्राथमिकता नहीं होती है।

लेकिन फिर भी जब मैंने उपरोक्त कार्यक्रम को निष्पादित किया, तो मुझे आपकी पुस्तक में उल्लिखित वांछित परिणाम मिला।

hi = 1707497920 lo=1699648942

hi = 1702682202 lo=1685457297

---

जवाब के लिए 0 № 4

मैं विंडोज 7 पर पा रहा हूं कि यदि मैं थ्रेड की संख्या उस बिंदु तक बढ़ाता हूं जहां सिस्टम संसाधनों पर वास्तविक लड़ाई होती है, तथा चल रहे समय में वृद्धि, उच्च प्राथमिकताथ्रेड्स अधिक क्लिक पर परिमाण का क्रम बनाते हैं। अगर यह मामला नहीं है तो उत्सुकता होगी। मुझे लगता है कि आपका परीक्षण मामला पर्याप्त संसाधनों का उपयोग करने के लिए थ्रेड्स की संख्या में बहुत कम है, जो उन्हें संघर्ष करना है, और जेवीएम के लिए देशी थ्रेड्स को बांधने के लिए समय भी चल रहा है।

   public static void main(String[] args) {
Thread r = Thread.currentThread();
r.setPriority(Thread.MAX_PRIORITY);
List<NewThread> hiThreads = new LinkedList<NewThread>();
List<NewThread> lowThreads = new LinkedList<NewThread>();
for (int i = 0; i < 10; i++) {
NewThread hi = new NewThread(Thread.NORM_PRIORITY + 2);
NewThread lo = new NewThread(Thread.NORM_PRIORITY - 2);
hiThreads.add(hi);
lowThreads.add(lo);
hi.start();
lo.start();
}
try {
r.sleep(30000);
} catch (InterruptedException e) {
System.out.println("caught");
}
for (NewThread h : hiThreads) {
h.stop();
}
for (NewThread l : lowThreads) {
l.stop();
}
try {
for (NewThread h : hiThreads) {
h.t.join();
}
for (NewThread l : lowThreads) {
l.t.join();
}
} catch (InterruptedException e) {
System.out.println("cau1");
}
long hiClicker = 0l;
for (NewThread h : hiThreads) {
hiClicker += h.clicker;
}
long lowClicker = 0l;
for (NewThread l : lowThreads) {
lowClicker += l.clicker;
}
System.out.println("hi = " + hiClicker + " lo=" + lowClicker);
}

---

जवाब के लिए 0 № 5

मैंने यह देखने के लिए एक छोटा अनुप्रयोग लिखा कि जावा थ्रेड कैसे काम करता है:

https://github.com/vinhqdang/java-thread-example

---

जवाब के लिए 0 № 6

बस उन लोगों के लिए जो थोड़ा और अधिक स्पष्टीकरण की तलाश कर रहे हैं ... निम्नलिखित "संपूर्ण संदर्भ, जावा, हर्बर्ट शील्ड" का अंश है

एक निरपेक्ष मूल्य के रूप में, एक प्राथमिकता अर्थहीन है; यदि केवल एकमात्र थ्रेड चल रहा है तो उच्च-प्राथमिकता वाला थ्रेड किसी भी कम-प्राथमिकता वाले थ्रेड से अधिक तेज़ नहीं चलता है। इसके बजाय, एक थ्रेड की प्राथमिकता का उपयोग यह तय करने के लिए किया जाता है कि एक रनिंग थ्रेड से अगले पर कब स्विच किया जाए। इसे एक संदर्भ स्विच कहा जाता है। संदर्भ स्विच होने पर निर्धारित होने वाले नियम सरल हैं:

• एक धागा स्वेच्छा से नियंत्रण को त्याग सकता है। यह स्पष्ट रूप से किया जाता है लंबित, सो, या लंबित I / O पर अवरुद्ध। इस परिदृश्य में, अन्य सभी धागे की जांच की जाती है, और सर्वोच्च प्राथमिकता वाला धागा जो चलाने के लिए तैयार है सीपीयू दिया।
• एक थ्रेड को उच्च-प्राथमिकता के द्वारा पूर्व-निर्धारित किया जा सकता हैधागा। इस मामले में, ए कम-प्राथमिकता वाले धागे जो प्रोसेसर का उत्पादन नहीं करते हैं, बस प्रीमेप्टेड हैं -कोई फर्क नहीं पड़ता कि वह क्या कर रहा है - एक उच्च प्राथमिकता वाले धागे द्वारा। मूल रूप से, जैसे ही जैसा कि एक उच्च प्राथमिकता वाला धागा चलाना चाहता है, यह करता है। इसे प्रीमेक्टिव कहा जाता है बहु कार्यण

---