क्या यह गैर-मानक जावा सिंक्रनाइज़ेशन पैटर्न काम करता है?

Question

चलो कहते हैं कि मैं दो धागे इस तरह चल रहा है दो:

• थ्रेड एक जो गणना करता है एक साझा छवि का पिक्सेल अपडेट करते समय
• थ्रेड बी समय-समय पर छवि और यह प्रतियां स्क्रीन

को पढ़ता है

थ्रेड ए जल्दी से काम करता है, प्रति सेकंड 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); 
    } 
} 

इस तरह से सही ढंग से धागा एक से डेटा स्थानांतरित बी थ्रेड के प्रभाव को प्राप्त करने में खाली तुल्यकालन ब्लॉक जोड़ने करता है? या क्या कोई और समाधान है जिसे मैं कल्पना करने में असफल रहा?

Answer 1

हाँ यह काम करता है। लेकिन यह बहुत काम करता है।

होता है से पहले ही काम करता है जब लेखक की रिहाई पाठक के अधिग्रहण से पहले होता है। आपका कार्यान्वयन मानता है कि जो कुछ भी आप लिख रहे हैं वह ThreadB से बाद में पढ़ने/अपडेट करने से पहले पूरा हो जाएगा। आपके डेटा को सिंक्रनाइज़ किए जाने पर हर समय फ़्लश करने के कारण प्रदर्शन समस्याओं का कारण बन जाएगा, हालांकि मैं कितनी हद तक निश्चित रूप से नहीं कह सकता। निश्चित रूप से, आपने अपना सिंक्रनाइज़ेशन बेहतर अनाज बनाया है, क्या आपने अभी तक इसका परीक्षण किया है?

एक बेहतर समाधान एक सिंगलटन/स्थानांतरण SPSC (एकल निर्माता/एकल उपभोक्ता) कतार का उपयोग लेखन धागा की वर्तमान स्नैपशॉट को संग्रहीत करने के लिए और जब भी आप अद्यतन का उपयोग हो सकता है।

int[] data = ... 
Queue<int[]> queue = new ... 

// Thread A 
while (true) { 
    for (1000 iterations or so) { 
     ... 
    } 
    queue.add(data); 
} 

// Thread B 
while (true) { 
    int[] snapshot = queue.take(); 
    this.repaint(); 
} 

इस का लाभ यह है कि आप busywait लिए, आप बस ब्लॉक करने के लिए कतार के लिए या अगले लिखने तक इंतजार कर सकते हैं की जरूरत नहीं है है। आप लिख सकते हैं कि आपके पास अपडेट करने का समय नहीं है। आपके लिए डेटा फ्लश की योजना बनाने के लिए आपको मनमाने ढंग से थ्रेड शेड्यूलर पर निर्भर रहने की आवश्यकता नहीं है।

याद रखें कि धागे की सुरक्षित डाटा संरचनाओं धागे के बीच डेटा पारित करने के लिए महान हैं।

संपादित करें: ओह, यह कहना भूल गया कि आपके अपडेट कैसे चलते हैं, आप अपने डेटा को यादृच्छिक लिखने से याद रखने के लिए एक सरणी प्रतिलिपि का उपयोग करना चाहेंगे जो कैश नहीं हैं।