यहां तक कि एक भी सीपीयू एक ढीले अर्थ में "एक ही समय में कई चीजें" कर सकता है, लेकिन वे वास्तव में समानांतर में नहीं हैं। आप एक कोर पर चलाने के लिए 100 धागे शुरू कर सकते हैं और उन्हें समय स्लाइस मिलेगा, जिनमें से प्रत्येक कुछ निर्देश चला सकता है, इस प्रकार इंप्रेशन बना रहा है कि वे सभी एक ही समय में निष्पादित कर रहे हैं।
मैं एक बहुत पोस्ट में कहा है के रूप में: करने के लिए एम:
- उपयोगकर्ता धागे धागे अनुप्रयोगों द्वारा शुरू कर रहे हैं और एन मैप की जाती हैं: multithreading on dual core machine?
अवधि धागे आम तौर पर तीन अमूर्त परतों को शामिल किया गया :
- कर्नेल धागे, जो धागे ऑपरेटिंग सिस्टम द्वारा प्रबंधित कर रहे हैं, मैप किया न: एम:
- हार्डवेयर धागे, जो वास्तविक भौतिक संसाधन उपलब्ध हैं।
जावा धागे उपयोगकर्ता धागे हैं। हार्डवेयर सीपीयू के रूप में आपके सीपीयू गिनती में 4 कोर। चूंकि मानचित्रण परतों में एन: एम है, आप देख सकते हैं कि आपके पास कई छोटे थ्रेड हार्डवेयर थ्रेड के लिए मैप किए जा सकते हैं।
अब, यह कहा है, वहाँ आम तौर पर अपने स्वयं के अजीब समस्याओं के साथ प्रत्येक थ्रेड गतिविधियों के दो वर्गों, कर रहे हैं:
- आई/ओ धागे: इन धागे पढ़ने/लिखने पर इंतजार कर रहे अपने समय के सबसे खर्च एक धारा से संचालन और इस दौरान अवरुद्ध हैं (वे निष्पादन के लिए निर्धारित नहीं हैं जब तक कि उन्हें उठाने के लिए कोई घटना न हो)। सीपीयू पर प्रकाश है और उनमें से कई एक ही कोर पर भी एक साथ चल सकते हैं।
- कम्प्यूटेशनल धागे: ये थ्रेड बहुत अधिक संख्या में क्रंचिंग करते हैं और अधिकतम CPU का उपयोग करते हैं। आम तौर पर अधिक से अधिक शुरू करने (उपलब्ध कोर की संख्या 2x) क्योंकि सीपीयू कार्यात्मक इकाइयों की एक सीमित संख्या है इस तरह के धागे, प्रदर्शन में कमी करने जा रहा है: ALUs, FPUs, आदि
धागे की द्वितीय श्रेणी से ऊपर की सुविधा देता है आप वास्तव में लाभ प्राप्त करते हैं या अपने क्वाड-कोर CPU पर एक बहुप्रचारित जावा प्रोग्राम चलाते हैं।
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
class ThreadTask implements Runnable {
private int total = 0;
public ThreadTask(int total) {
this.total = total;
}
@Override
public void run() {
int value = 0;
for(int i = 0; i < total; i++) {
value = i * i;
}
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
int total = 1000000000;
long start = System.currentTimeMillis();
long value = 0;
for(int i = 0; i < total; i++) {
value = i * i;
}
long stop = System.currentTimeMillis();
System.out.println((stop - start) + " ms");
ExecutorService exec = Executors.newFixedThreadPool(4);
start = System.currentTimeMillis();
for(int i = 0; i < 4; i++) {
exec.submit(new ThreadTask(total/4));
}
exec.shutdown();
exec.awaitTermination(10, TimeUnit.SECONDS);
stop = System.currentTimeMillis();
System.out.println((stop - start) + " ms");
}
}
अगर यह बहुत तेजी से चल रहा है total का मूल्य समायोजित करने के लिए स्वतंत्र महसूस: यहाँ एक प्रोग्राम है जो 4 धागे के साथ एक थ्रेड पूल का उपयोग कर समानांतर में 1.000.000.000 संख्या पहले क्रमिक रूप से और की बराबरी कार्यान्वित तो की एक सरल उदाहरण है । अब मैं इंटेल एटम के साथ नेटबुक पर काम कर रहा हूं, इसलिए यह वास्तव में तेज़ नहीं है।
आगे निकल गया और इसमें मल्टीथ्रेडिंग टैग जोड़ा - यह सिर्फ जावा-केंद्रित प्रश्न नहीं है। उम्मीद है कि आपको कुछ बेहतरीन जवाब मिलेंगे। – Makoto
आपके द्वारा पढ़ा गया आलेख शायद बहु-कोर प्रोसेसर से पहले समय से था, इसलिए कहता है कि केवल बहु-प्रोसेसर कंप्यूटर इसका उपयोग कर सकता है। – Hurda