थ्रेड कोड

Question

के साथ मानक सिंक्रनाइज़ेशन को प्रतिस्थापित करने के लिए समानांतर जावा "अभिनेता" कोड क्या होगा यदि मेरे पास यह सिंक्रनाइज़ कोड है जिसे मैं बिना सिंक्रनाइज़ेशन वाले कलाकारों के साथ प्रतिस्थापित करना चाहता हूं, तो कैसे?

public synchronized int incrementAndGet() { 
    i = i + 1; 
    return i; 
} 

और मैं वेब साइट में उन जहां मैं हर एक incrementing संख्या वापस जाने के लिए की जरूरत है ... का एक समूह मैं कैसे अभिनेताओं कोड जो है कोई सिंक्रनाइज़ेशन इस प्रकार कोई अवरुद्ध सिंक्रनाइज़ कर कोड के साथ कि कोड की जगह ले सकता है। जो मुझे लगता है कि यह मल्टीकोर आदि पर इसे चलाने में सक्षम होगा (क्या यह अभिनेताओं का उद्देश्य नहीं है?)।

Answer 1

एक साधारण अभिनेता अपने आंतरिक राज्य में i लपेटकर:

case object Inc 

class IncrementingActor extends Actor { 
    var i = 0 

    protected def receive = { 
     case Inc => 
      i += 1 
      sender ! i 
    } 
} 

और उपयोग को अवरुद्ध (आप किसी भी तरह incrementAndGet प्राप्त करने की आवश्यकता):

import akka.pattern.ask 

def incrementAndGet() = 
    Await.result((incrementingActor ? Inc).mapTo[Int], 1 seconds) 

इस कोड है:, धीमी गति से जटिल और गैर मुहावरेदार। AtomicInteger के बारे में क्या?

Answer 2

Concurrency कई समस्याओं और नुकसान के साथ एक विशाल डोमेन है। सभी समस्याओं को हल करने में सक्षम एक भी दृष्टिकोण नहीं है और एक वास्तविक समेकन विशेषज्ञ सर्वोत्तम परिणाम प्राप्त करने के लिए कई विधियों को गठबंधन करने में सक्षम है।

वर्तमान में जेवीएम दुनिया पर, मुझे नहीं लगता कि काउंटर में वृद्धि के लिए परमाणु पूर्णांक की तुलना में बेहतर विकल्प हैं, खासकर यदि विवाद बहुत अधिक है।

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

case object Inc 
case class Count(i) 

class IncrementingActor extends Actor { 
    var i = 0 
    protected def receive = { 
    case Inc => 
     i += 1 
     sender ! Count(i) 
    } 
} 

class FooActor(counter: ActorRef) extends Actor { 
    protected def receive = { 
    case DoSomething() => { 
     // Perform some work 
     counter ! Inc 
    } 
    case Count(i) => { 
     // Do something with the counter result 
    } 
    } 
} 

Answer 3

Synchronously एक काउंटर incrementing (incrementAndGet() के रूप में) बहुत कम लाभ है कि आप एक अभिनेता उपयोग करना चाहते हैं:

थॉमस समाधान के साथ शुरू, आप की तरह कुछ लिख सकते हैं। दृश्य से छुपा वास्तव में अभिनेता के लिए मेलबॉक्स में सिंक्रनाइज़ेशन है। इसके अलावा, AtomicInteger वर्ग मल्टीकोर आर्किटेक्चर पर ठीक काम करता है।