चलो कहते हैं कि मैं दो धागे इस तरह चल रहा है दो:क्या यह गैर-मानक जावा सिंक्रनाइज़ेशन पैटर्न काम करता है?
- थ्रेड एक जो गणना करता है एक साझा छवि का पिक्सेल अपडेट करते समय
- थ्रेड बी समय-समय पर छवि और यह प्रतियां स्क्रीन
थ्रेड ए जल्दी से काम करता है, प्रति सेकंड 1 मिलियन अपडेट कहता है, इसलिए मुझे संदेह है कि लॉक/म्यूटेक्स/मॉनिटर पर अक्सर लॉक और अनलॉक करना बुरा विचार होगा। लेकिन अगर कोई तालाब नहीं है और थ्रेड ए से थ्रेड बी के संबंध में पहले से स्थापित होने का कोई तरीका नहीं है, तो जावा मेमोरी मॉडल (जेएमएम स्पेक) थ्रेड बी द्वारा छवि के किसी भी अपडेट को देखने के लिए बिल्कुल गारंटी नहीं है।
तो मैं सोच रहा था कि न्यूनतम समाधान एक ही साझा लॉक पर समय-समय पर सिंक्रनाइज़ करने के लिए थ्रेड ए और बी के लिए होता है, लेकिन वास्तव में सिंक्रनाइज़ किए गए ब्लॉक के अंदर कोई भी काम नहीं करता - यह पैटर्न गैर-मानक बनाता है और संदिग्ध। आधा वास्तविक आधा छद्म कोड में इसे समझने के लिए:
class ComputationCanvas extends java.awt.Canvas {
private Object lock = new Object();
private int[] pixels = new int[1000000];
public ComputationCanvas() {
new Thread(this::runThreadA).start();
new Thread(this::runThreadB).start();
}
private void runThreadA() {
while (true) {
for (1000 steps) {
update pixels directly
without synchornization
}
synchronized(lock) {} // Blank
}
}
private void runThreadB() {
while (true) {
Thread.sleep(100);
synchronized(lock) {} // Blank
this.repaint();
}
}
@Override
public void paint(Graphics g) {
g.drawImage(pixels, 0, 0);
}
}
इस तरह से सही ढंग से धागा एक से डेटा स्थानांतरित बी थ्रेड के प्रभाव को प्राप्त करने में खाली तुल्यकालन ब्लॉक जोड़ने करता है? या क्या कोई और समाधान है जिसे मैं कल्पना करने में असफल रहा?
परमाणु बुलियन चाल क्यों नहीं करेगा? कुछ भी सिंक्रनाइज़ करने से सिंक्रनाइज़ेशन – efekctive
का काम अभी भी छोड़ देता है क्यों 'अस्थिर' का उपयोग नहीं करते? – shmosel
संभवतः संबंधित: http://stackoverflow.com/questions/17108541/happens-before-relationships-with-volatile-fields-and-synchronized-blocks-in-jav – flakes