.NET

Question

में एरलांग-स्टाइल लाइट-वेट प्रक्रियाएं .NET में एरलांग-स्टाइल लाइट-वेट प्रक्रियाओं को लागू करने का कोई तरीका है?

मुझे कुछ परियोजनाएं मिलीं जो एरलांग मैसेजिंग मॉडल (अभिनेता मॉडल) को लागू करती हैं। उदाहरण के लिए, Axum। लेकिन मुझे हल्के वजन की प्रक्रिया कार्यान्वयन के बारे में कुछ भी नहीं मिला। मेरा मतलब है कई प्रक्रियाएं जो एक ओएस-थ्रेड या ओएस-प्रोसेस के संदर्भ में चलती हैं।

Answer 1

मुझे लगता है कि एफ # मेलबॉक्स प्रोसेसर वह है जो आप एलेक्सी की तलाश में हैं। मेलबॉक्स प्रोसेसर का उपयोग करके आप हजारों एजेंटों को एक .NET प्रक्रिया में परिभाषित कर सकते हैं जैसे कि आप एरलांग में हजारों हल्के वजन को बढ़ा सकते हैं।

यह MSDN post डॉन सिमे द्वारा एक महान परिचय है।

यदि आप एक एरलंग पृष्ठभूमि से .NET पर आ रहे हैं, तो ध्यान रखें कि आप ओटीपी उपहारों (पर्यवेक्षकों, स्थान पारदर्शिता, मैनेशिया, ...) के बहुत सारे गायब होने जा रहे हैं।

Answer 2

इसका कोई मतलब नहीं है। "एक एकल ओएस थ्रेड या ओएस प्रक्रिया के संदर्भ में चलने वाली एकाधिक प्रक्रिया" तर्कसंगत रूप से अनिवार्य है। यह मूल रूप से एक तार्किक अनुप्रयोग स्तर की बात है - जिसे आप आसानी से .NET में repro कर सकते हैं। लेकिन ओएस स्तर पर "प्रक्रिया के भीतर प्रक्रिया" जैसी कोई चीज नहीं है।

Answer 3

सीएलआर होस्ट किया जा सकता है और होस्ट के लिए अपने स्वयं के कार्य अमूर्तता को लागू करने के लिए तंत्र का खुलासा कर सकता है। सैद्धांतिक रूप से, वे धागे, फाइबर, एलडब्ल्यूपी हो सकते हैं - जब तक मेजबान necessaryinterfaces लागू करता है।

इसे प्राप्त करना कुछ मुश्किल है। एसएसएल सर्वर फाइबर मोड में सीएलआर होस्ट करने के लिए एमएस ने इसका मौका लिया।

आखिरी पल में, कुछ तनाव कीड़े थीं, इसलिए उन्होंने Joe Duffy और Dino Vhieland (जो series about writing a custom CLR host that implements its own task abstraction - with fibers - on his blog चलाया) के अनुसार प्लग खींच लिया।
अभी कुछ नलसाजी गायब हैं - ICLRTask::SwitchOut() - और यहां तक ​​कि यदि कोई उस के आसपास हो जाता है, तो भी वही बग जो तनाव परीक्षण पुनरावृत्ति पर एमएस को मारता है, शायद साहसी आत्मा को भी परेशान करेगा।

मान लीजिए कि सभी समस्याओं को किसी तरह से ठीक किया गया है और पूरे रनटाइम फाइबर, एलडब्लूपी, जो कुछ भी चलाने के लिए तैयार हैं। पी/इनवॉक की समस्या अभी भी है जो संभावित रूप से अवरुद्ध संचालन में कॉल कर सकती है। कर्नेल समर्थन के बिना इस प्रकार का शेड्यूल करना मुश्किल है।

यह विंडोज 7 और विंडोज 2008 सर्वर आर 2 के 64 बिट संस्करणों में संबोधित किया गया है। अब User-Mode Scheduling है जो कर्नेल में कॉल ब्लॉक अगर कर्नेल-मोड - शेड्यूलर के विपरीत - उपयोगकर्ता-मोड पर नियंत्रण प्राप्त कर सकता है। साथ ही, ये उपयोगकर्ता-मोड शेड्यूल किए गए थ्रेड अपने स्वयं के टीएलएस के साथ वास्तविक धागे हैं। ये बहुत अच्छे सुधार हैं और फाइबर मोड के कई सिरदर्द दूर हो जाते हैं।

अभी में UMS is utilizedavailable for C++ and is part of the C Runtime Library (CRT) है।
उत्तरार्द्ध का अर्थ है कि आप इसे Visual Studio 2010 के साथ बॉक्स से बाहर उपयोग कर सकते हैं।

Answer 4

क्या आपने retlang पर एक नज़र डाली है? मैंने केवल इसके बारे में पढ़ा है, लेकिन मैंने इसके साथ कुछ भी नहीं किया है, फिर भी ...

Answer 5

एरलांग प्रक्रिया समानांतर तरीके से चलने की विधि की तरह है, लेकिन erlang चर केवल एक बार बाध्य किया जा सकता है, इसलिए यह थ्रेड सुरक्षित है जो सी # में नहीं है।

इसलिए आपको सी #, थ्रेड सुरक्षित और समांतर में दो चीजों की आवश्यकता है।

सी # में सिस्टम है। थ्रेडिंग टास्क, आप वीएम में कई कार्य चला सकते हैं। सी # वीएम इन कार्यों को विभिन्न कामकाजी धागे में शेड्यूलर करेगा।

लेकिन कार्य धागा सुरक्षित नहीं है, आपको अभिनेता नामक एक वर्ग बनाने की जरूरत है, और अभिनेता में राज्य को निजी रखना है।

अभिनेता के पास एक सिस्टम है। थ्रेडिंग। सिंक्रनाइज़ेशन कॉन्टेक्स्ट, और इस तरह के कई async तरीके।

class Actor { 
    public SynchronizationContext _context; 

    private int value1; 
    private Dictionary<> xxx; 
    private List<> xxx; 


    public async Task Method1() { 
     await _context; 

     doSomething(); 
    } 

} 

अन्य अभिनेता इस अभिनेता में async विधि कॉल करते हैं, यह भी कार्य बना होगा, और काम वीएम द्वारा अनुसूचित होगा।

आपको एक प्रतीक्षा करने योग्य और थ्रेड सुरक्षित सिंक्रनाइज़ेशन कॉन्टेक्स्ट को भी लागू करने की आवश्यकता है।

यह एक धागा सुरक्षित संदर्भ है।

public class ActorSynchronizationContext : SynchronizationContext 
{ 
    private readonly SynchronizationContext _subContext; 
    private readonly ConcurrentQueue<Action> _pending = new ConcurrentQueue<Action>(); 
    private int _pendingCount; 

    public ActorSynchronizationContext(SynchronizationContext context = null) 
    { 
     this._subContext = context ?? new SynchronizationContext(); 
    } 

    public override void Post(SendOrPostCallback d, object state) 
    { 
     if (d == null) { 
      throw new ArgumentNullException("SendOrPostCallback"); 
     } 
     _pending.Enqueue(() => d(state)); 
     if (Interlocked.Increment(ref _pendingCount) == 1) 
     { 
      try 
      { 
       _subContext.Post(Consume, null); 
      } 
      catch (Exception exp) 
      { 
       LogHelper.LogUnhandleException(exp.ToString()); 
      } 
     } 
    } 

    private void Consume(object state) 
    { 
     var surroundContext = Current; 
     SetSynchronizationContext(this); 
     do 
     { 
      Action a; 
      _pending.TryDequeue(out a); 
      try 
      { 
       a.Invoke(); 
      } 
      catch (Exception exp) 
      { 
       //Debug.LogError(exp.ToString()); 
       LogHelper.LogUnhandleException(exp.ToString()); 
      } 
     } while (Interlocked.Decrement(ref _pendingCount) > 0); 
     SetSynchronizationContext(surroundContext); 
    } 

    public override void Send(SendOrPostCallback d, object state) 
    { 
     throw new NotSupportedException(); 
    } 
    public override SynchronizationContext CreateCopy() 
    { 
     return this; 
    } 
} 

तो आप कार्य के साथ एक अभिनेता के वर्ग हो और सुरक्षित थ्रेड SynchroniztionContext

public static class SynchroniztionContextExtensions 
{ 
    public static SynchronizationContextAwaiter GetAwaiter (this SynchronizationContext context) 
    { 
     if(context == null) throw new ArgumentNullException("context"); 
     return new SynchronizationContextAwaiter(context); 
    } 
} 

Awaiter SynchronizationContext

public sealed class SynchronizationContextAwaiter : INotifyCompletion 
{ 
    private readonly SynchronizationContext _context; 
    public SynchronizationContextAwaiter(SynchronizationContext context) 
    { 
     if(context == null) throw new ArgumentNullException("context"); 
     _context = context; 
    } 
    public bool IsCompleted { 
     get 
     { 
      //已经在当前上下文里面了，就不需要再次切换上下文 
      return SynchronizationContext.Current == _context; 
     } 
    } 

    /// <summary> 
    /// 将Action 任务调度到 _context 控制的线程里面去执行 
    /// 
    /// var temp = e.GetAwaiter(); 
    /// </summary> 
    /// <param name="action">Action.</param> 
    public void OnCompleted(Action action) { 
     _context.Post(x=>action(), null); 
    } 
    public void GetResult(){} 
} 

के लिए awaitable बनाने के जो erlang में प्रक्रिया की तरह।