मुझे सी # .Net

Question

ठीक में थ्रेड-सुरक्षित स्थिर चर बनाने की आवश्यकता है, ठीक है, यह सवाल से थोड़ा अधिक जटिल है।

class A 
{ 
    static int needsToBeThreadSafe = 0; 

    public static void M1() 
    { 
    needsToBeThreadSafe = RandomNumber(); 
    } 

    public static void M2() 
    { 
    print(needsToBeThreadSafe); 
    } 
} 

अब मैं अपेक्षा करते हैं कि एम 1() और M2() के बीच कॉल 'needsToBeThreadSafe' रहता है सुरक्षित थ्रेड।

Answer 1

क्या आप के बारे में पूछने की कोशिश कर रहा हो सकता है [ThreadStatic] विशेषता है। आप प्रत्येक थ्रेड वर्ग A का उपयोग करता है needsToBeThreadSafe का अपना अलग महत्व हो करना चाहते हैं तो आप बस [ThreadStatic] विशेषता के साथ उस क्षेत्र को सजाने के लिए की जरूरत है।

अधिक जानकारी के लिए MSDN documentation for ThreadStaticAttribute देखें।

static int needsToBeThreadSafe = 0; 
static System.Threading.ReaderWriterLockSlim rwl = new System.Threading.ReaderWriterLockSlim(); 

public static void M1() 
{ 
    try 
    { 
     rwl.EnterWriteLock(); 
     needsToBeThreadSafe = RandomNumber(); 
    } 
    finally 
    { 
     rwl.ExitWriteLock(); 
    } 

} 

public static void M2() 
{ 
    try 
    { 
     rwl.EnterReadLock(); 
     print(needsToBeThreadSafe); 
    } 
    finally 
    { 
     rwl.ExitReadLock(); 
    } 
} 

Answer 2

class A 
{ 
    static int needsToBeThreadSafe = 0; 
    static object statObjLocker = new object(); 

    public static void M1() 
    { 
     lock(statObjLocker) 
     { 
      needsToBeThreadSafe = RandomNumber(); 
     } 
    } 

    public static void M2() 
    { 
     lock(statObjLocker) 
     { 
      print(needsToBeThreadSafe); 
     } 
    } 
} 

Answer 3

आपके पास दो विकल्प: अपने प्रस्तुत कोड के लिए सबसे आसान दी volatile कीवर्ड है। needsToBeThreadSafe को static volatile int के रूप में घोषित करें और यह गारंटी देगा कि उस चर के संदर्भ में कोई भी थ्रेड "नवीनतम" प्रतिलिपि प्राप्त करेगा, और चर को आपके कोड में कैश नहीं किया जाएगा।

कहा जा रहा है, यदि आप अधिक आम तौर पर यह सुनिश्चित करें कि M1() और M2() निष्पादित "atomically" चाहते हैं (या एक दूसरे के लिए कम से कम विशेष रूप से), तो आप एक lock उपयोग करना चाहते हैं। साफ वाक्य रचना एक "लॉक ब्लॉक", इस तरह से है:

private static object locker = new Object(); 

//.. 

public static void M1() 
{ 
    lock(locker) 
    { 
     //..method body here 
    } 
} 

public static void M2() 
{ 
    lock(locker) 
    { 
     //..method body here 
    } 
} 

के रूप में जो दृष्टिकोण लेने के लिए, कि आप पर निर्भर है करने के लिए और कोड द्वारा निर्धारित किया जाना चाहिए। यदि आपको केवल यह सुनिश्चित करना है कि एक सदस्य असाइनमेंट सभी धागे के लिए प्रचारित हो जाता है और कैश नहीं किया जाता है, तो volatile कीवर्ड सरल है और यह काम ठीक होगा। यदि यह उससे परे है, तो आप lock के साथ जाना चाह सकते हैं।

Answer 4

ध्वनि जैसा आपको Volatile सदस्य की आवश्यकता है।

static volatile int needsToBeThreadSafe = 0; 

Answer 5

तुम भी ReaderWriterLockSlim उपयोग कर सकते हैं, कि और अधिक कुशल कई पढ़ता है और कम लेखन के लिए है।

class A 
{ 
    static volatile int needsToBeThreadSafe = 0; 

} 

लेकिन अगर आप:

लेकिन एक और अधिक minimalist दृष्टिकोण वहां मौजूद है, अपने नमूना कोड केवल needsToBeThreadSafe और के बाद से int परमाणु है आप केवल अस्थिर का उपयोग कर संकलक द्वारा कैशिंग को रोकने के लिए की जरूरत का उपयोग कर एक बयान से पता चलता जरूरतों की आवश्यकता है कई बयानों पर 'थ्रेडसेफ' होने के लिए, लॉक का उपयोग करें, लॉक का उपयोग करें।

Answer 6

साथ मैं lock() का उपयोग कर जवाब के साथ सहमत हैं कि सबसे सुरक्षित तरीका है शुरू करने के लिए:

Answer 7

कैसे के बारे में: आप

public static void M1() 
{ 
    Interlocked.Exchange(ref needsToBeThreadSafe, RandomNumber()); 
} 

public static void M2() 
{ 
    print(Interlocked.Read(ref needsToBeThreadSafe)); 
}