मैं जावा के लिए काफी नया हूं और किसी दिए गए रेंज में प्राइम नंबर खोजने के लिए एक छोटा प्रोग्राम बनाना शुरू कर दिया है। अब मैंने मल्टीटास्किंग को लागू करने की कोशिश की, उदा। जाँच की जाने वाली संख्याओं को n भागों में विभाजित करना जिन्हें स्वतंत्र रूप से जाँचा जाएगा। मैं इसे यथासंभव लचीला बनाना चाहता था, इसलिए मैंने कोड में थ्रेड्स की संख्या निर्दिष्ट नहीं की, इसके बजाय मैंने एक प्रॉम्प्ट वेरिएबल का उपयोग किया। अब, कोड काम करता है, लेकिन धागे समानांतर नहीं चलते हैं।

ऐसा लगता है कि यहाँ समस्या क्या है?

           [...]     
           System.out.println("How many Threads shall be used?");
           int b1 = scan.nextInt();
           scan.close();
           for (int i = 1; i <= b1; i++) {
             long u = (q/b1)*(i-1);
             long o = (q/b1)*i;
             System.out.println("Thread "+i+" started.");
             Thread t1 = new Thread(new thread1 (u, o, i));
             t1.start();
           }


class thread1 implements Runnable{
    public thread1 (long a, long b, int c) {
//a= min. number, b = max. number, c=number of Thread
        primefinder.findPrimes(b,a, c);
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}
-1
peeaace 7 जिंदा 2022, 11:18
2
आपको अपना काम रन विधि में रखना चाहिए। मैं जो देखता हूं, आप thread1 कंस्ट्रक्टर में गणना करते हैं। कंस्ट्रक्टर में डालकर, आप सभी काम मुख्य (कॉलिंग) थ्रेड पर करते हैं, और जब t1.start को कॉल किया जाता है, तो यह कुछ भी नहीं करेगा क्योंकि रन विधि में कुछ भी परिभाषित नहीं है।
 – 
Slimu
7 जिंदा 2022, 11:24

2 जवाब

सबसे बढ़िया उत्तर

Javadoc से https://docs.oracle.com /javase/7/docs/api/java/lang/Thread.html :

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }

         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }
    

आपका तर्क रन () विधि में होना चाहिए। यह वह तरीका है जिसे किसी अन्य थ्रेड पर बुलाया और चलाया जाएगा। अपने वास्तविक कोड के साथ, आप रननेबल के कन्स्ट्रक्टर में गणना करते हैं, जिसे आपके लूप में बुलाया जाता है, और इसके लिए अनुक्रमिक होता है।

अपनी गणना को रन विधि में ले जाने से समस्या हल हो जाएगी।

संपादित करें: यदि आप अपने गणना कोड में पैरामीटर पास करने के लिए संघर्ष करते हैं, तो आप इसे सरल बना सकते थे:

Thread t1 = new Thread(() -> findPrimes(u, o, i));
t1.start();

यह बिल्कुल वही काम करता है, हुड के तहत, यह एक अज्ञात वर्ग बनाता है जो रननेबल इंटरफ़ेस को कार्यान्वित करता है जो कक्षा के क्षेत्रों में आपके चर को कैप्चर करता है।

3
Erwan Daniel 7 जिंदा 2022, 12:16
बस इतना ही, धन्यवाद! मैंने इसे वर्णित तरीके से आजमाया क्योंकि मैंने पैरामीटर को रन() विधि में पास करने का प्रबंधन नहीं किया था।
 – 
peeaace
7 जिंदा 2022, 12:02
क्या आप लैम्ब्डा अभिव्यक्ति का भी उपयोग कर सकते हैं, मैं अपने उत्तर में एक उदाहरण जोड़ता हूं
 – 
Erwan Daniel
7 जिंदा 2022, 12:12
1
जावा 7 के लिए दस्तावेज़ीकरण लेकिन जावा 8 से शुरू होने वाले कोड (अंतिम स्निपेट) का उपयोग करना... BTW पुराने नहीं जावा संस्करणों के साथ, अंतिम स्निपेट के लिए कोई अनाम वर्ग नहीं बनाया जा रहा है, यह है बूटस्ट्रैप विधियों का उपयोग करके कार्यान्वित किया गया (देखें LambdaMetafactory)
 – 
user16320675
7 जिंदा 2022, 12:47

जैसा कि सही Answer by Daniel कहता है, आपको अपने व्यावसायिक तर्क को run विधि में स्थानांतरित करने की आवश्यकता है। Runnable, या call की विधि Callable

साथ ही, आधुनिक जावा में हम शायद ही कभी सीधे Thread वर्ग को संबोधित करते हैं। इसके बजाय निष्पादक ढांचे का उपयोग करें।

ExecutorService es = Executors.newFixedThreadPool( x ) ;
for( … ) { es.submit( task ) ; }
es.shutdown() ;
es.awaitTermination( … ) ;

स्टैक ओवरफ्लो पर इसे पहले ही कई बार कवर किया जा चुका है। तो अधिक जानने के लिए खोजें।

0
Basil Bourque 7 जिंदा 2022, 18:30