Dağıtılmış bir kilitleme deseni mi arıyorsunuz?

C # 'da dağıtılmış bir sistem için özel bir özyinelemeli nesne kilitleme mekanizması \ desen bulmak gerekir. Aslında çok düğümlü bir sistemim var. Her düğümün n- sayısı durum parçaları üzerinde özel yazma izinleri vardır . Aynı durum, en az bir başka düğümde salt okunur biçimde de mevcuttur . Bazı yazma / güncellemeler tüm düğümlerde atomik olmalıdır, diğer güncellemeler sonunda arka plan çoğaltma işlemleri, kuyruklar vb.

Atomik güncellemeleri için ben verimli beni için kilitli olarak bir nesneyi işaretlemek için izin bir desen veya numuneler arıyorum yazıyor sistem eşzamanlılık yüksek seviyelerini olduğundan ... vb işlemek, o zaman dağıtabildikleri, geri alma, ben Zaman aşımına uğrayacak veya kilitler serbest bırakıldıktan sonra açılacak kilitleri biriktirebileceğimi varsayıyorum.

İşlem veya mesajlaşma parçaları bu sorunun odağı değil, ancak bazı ekstra içerikler sağladım. Bununla birlikte, isterseniz hangi mesajların gerekli olacağını düşündüğünüzü ifade etmekten çekinmeyin.

İşte tüm yeni ürünleri uygulamak dışında yeni fikirlere açık olmama rağmen öngördüğüm şeyin belirsiz bir örneği

thing.AquireLock(LockLevel.Write);

//Do work

thing.ReleaseLock();

Böyle bir şeye benzeyen uzatma yöntemleri kullanmayı düşünüyordum

public static void AquireLock(this IThing instance, TupleLockLevel lockLevel)
{ 
    //TODO: Add aquisition wait, retry, recursion count, timeout support, etc...  
    //TODO: Disallow read lock requests if the 'thing' is already write locked
    //TODO: Throw exception when aquisition fails
    instance.Lock = lockLevel;
}

public static void ReleaseLock(this IThing instance)
{
    instance.Lock = TupleLockLevel.None;
}

Birkaç ayrıntıya açıklık getirmek için ...

• Tüm iletişim ikili istek / yanıt protokolü kullanılarak TCP / IP'dir
• Kuyruklar veya veritabanları gibi aracı teknolojiler yoktur
• Merkezi ana düğüm yok. Bu durumda, kilitleme düzenlemesi, kilidin başlatıcısı ve davranışı yönetmek için bir çeşit zaman aşımı ile talebi onurlandıran ortak tarafından tanımlanır.

Herhangi birinin önerisi varmı?

Açıklamalar için teşekkürler.

Bu durumda, önerebileceğim bir yayınlama / abone olma modeli kullanmaktır. Google'ın Tombul dağıtılmış kilitleme protokolü ( Paxos uygulaması )

Ben Paxos (veya Chubby'den) kullanılabilir, ancak açık kaynak uygulaması var gibi görünüyor hiç burada .

Bu işe yaramazsa, örneğin mesajlaşma kitaplıkları açısından olağan şüphelilerden birini kullanarak kendi Paxos sürümünüzü uygulayabilirsiniz: sıfır mesaj kuyruğu kitaplığı , RabbitMQ veya ActiveMQ .

Önceki Cevap:

SO ( [A] , [B] ) ile ilgili önerilerin çoğu, makineler arası kilitleme elde etmek için bir mesaj kuyruğunun kullanımına yöneliktir.

Kişisel AcquireLockyöntem başarı önce kilitleri önceki örnekleri için kontrol kuyruğuna kilit nesnesini tanımlayan şey itmek olacaktır. Kişisel ReleaseLockyöntem kuyruğundan kilit nesnesini ortadan kaldıracaktır.

SO kullanıcı atlantis , bu yazıda , bazı ayrıntılar için Jeff Key'in gönderisini önermektedir .

Bana burada birkaç karma teknolojiniz var gibi görünüyor:

• iletişim (esasen% 100 güvenilir olarak güvendiğiniz ... ölümcül olabilen)

• kilitleme / karşılıklı dışlama

• zaman aşımları (hangi amaçla)?

Uyarı: Dağıtım sistemlerindeki zaman aşımları tehlike ve zorluklarla dolu olabilir. Kullanılırsa, çok dikkatli bir şekilde ayarlanmalı ve kullanılmalıdır, çünkü zaman aşımlarının gelişigüzel kullanımı bir sorunu çözmez, sadece felaketi ortadan kaldırır. (Zaman aşımlarının nasıl kullanılması gerektiğini görmek istiyorsanız , HDLC iletişim protokolü belgelerini okuyun ve anlayın. Bu, IDLE satırı gibi şeylerin algılanmasına izin vermek için akıllı bir bit kodlama sistemi ile birlikte uygun ve akıllı kullanıma iyi bir örnektir. .

Bir süre iletişim bağlantıları (TCP değil, başka bir şey) kullanılarak bağlanmış çok işlemcili dağıtılmış sistemlerde çalıştım. Öğrendiğim şeylerden biri, kaba bir genelleme olarak, gidilecek bazı tehlikeli çoklu programlama yerlerinin olmasıydı:

• kuyruklara güven genellikle gözyaşlarıyla sona erer (kuyruk doldurulursa, sorun yaşarsınız. SADECE asla doldurmayacak bir kuyruk boyutu hesaplayabilirsiniz, bu durumda muhtemelen kuyruksuz bir çözüm kullanabilirsiniz)

• Kilitlemeye güvenmek acı vericidir, başka bir yol olup olmadığını deneyin ve düşünün (kilitleme kullanmanız gerekiyorsa, literatüre bakın, çok işlemcili dağıtılmış kilitleme son 2-3 yıldaki birçok asedemik kağıdın konusu olmuştur)

Ben kilitleme kullanarak devam etmek zorunda, o zaman:

Zaman aşımlarını yalnızca son çare kurtarma aracı olarak kullanacağınızı varsayacağım - yani temel iletişim sisteminin arızasını tespit etmek için. Ayrıca TCP / IP iletişim sisteminizin yüksek bant genişliğine sahip olduğunu ve düşük gecikme süresi olarak düşünülebileceğini varsayacağım (ideal olarak sıfır, ancak bu asla gerçekleşmez).

Ne önerebilirim her düğüm bağlanabilir diğer düğümlerin bir bağlantı listesine sahip olmasıdır. (Düğümler bir bağlantının nereden geldiğini umursamazlar.) Bir düğümün bağlanabileceği tabloların popülasyonu, sıralamak için ayrı bir şey olarak bırakılır, bunun statik olarak ayarlanıp ayarlanmayacağını söylemediniz. Ayrıca, bağlantıların bir düğüme geleceği IP bağlantı noktası numaralarının tahsisi gibi şeyler de göz ardı edilir - yalnızca tek bir bağlantı noktasında veya birden fazla bağlantı noktasında istekleri kabul etmek için iyi nedenler olabilir. Bunun dikkatle ele alınması gerekir. Örtük kuyruk, sipariş, kaynak kullanımı, işletim sistemi türü ve yetenekleri içerecektir.

Düğümler kime bağlandıklarını öğrendikten sonra, o düğüme bir kilit isteği gönderebilir ve bu uzak düğümden gelen bir kilit yanıtından geri almaları gerekir. Atomik görünmesi için bu iki işlemi bir sargıya paketleyebilirsiniz. Bunun etkisi, bir kilit almak isteyen düğümlerin aşağıdaki gibi bir arama yapmasıdır:

if (get_lock(remote_node) == timeout) then
  {
    take some failure action - the comms network is down
  }

/* Lock is now acquired - do work here */

if (release_lock(remote_node) == timeout) then
  {
    take some failure action - the comms network is down
  }

get_lock ve release_lock çağrıları aşağıdaki gibi olmalıdır (prensipte):

send_to_remote_node(lock_request)
get_from_remote_node_or_timeout(lock_reply, time)
if (result was timeout) then
  return timeout
else
  return ok

Bir kilit basılıyken gerçekleştirilen iş birimlerinin küçük ve hızlı olması nedeniyle dağıtılmış bir kilitleme sistemi ile çok dikkatli olmanız gerekir çünkü kilit almak için beklemede olan birçok uzak düğümünüz olacaktır. Bu, etkili ancak mümkün olan en yüksek performansa sahip olmayan, dur ve bekle çok işlemcili / iletişim sistemidir.

Bir öneri tamamen farklı bir yaklaşım benimsemektir. Her RPC çağrısının alıcı tarafından işlenebilen ve kilit gereksinimlerini ortadan kaldıran bir bilgi paketi taşıdığı uzak yordam çağrısı kullanabilir misiniz?

Soruyu yeniden okurken, şeylerin iletişim tarafı ile gerçekten ilgilenmek istemiyorsunuz, sadece kilitleme sorununuzu çözmek istiyorsunuz gibi görünüyor.

Bu nedenle cevabım biraz konu dışı görünebilir, ancak altında kalan parçaları da doğru yapmadan kilitleme sorununuzu çözemeyeceğinize inanıyorum. Analoji: Kötü temeller üzerine bir ev inşa etmek onun yıkılmasına neden olur ... Sonunda.

Sorunuz NCache gibi dağıtılmış bir önbellek kullanılarak kolayca uygulanabilir. İhtiyacınız olan şey, bir nesne kullanarak bir kilit elde edebileceğiniz kötümser bir kilitleme mekanizmasıdır. Ardından görevlerinizi ve işlemlerinizi gerçekleştirin ve daha sonra diğer uygulamaların kullanması için kilidi serbest bırakın.

Aşağıdaki koda bir göz atın;

Burada belirli bir Anahtar üzerinde bir kilit elde edersiniz ve daha sonra görevleri gerçekleştirirsiniz (bir veya daha fazla işlemden itibaren) ve ardından işiniz bittiğinde kilidi serbest bırakırsınız.

// Instance of the object used to lock and unlock cache items in NCache
LockHandle lockHandle = new LockHandle();

// Specify time span of 10 sec for which the item remains locked
// NCache will auto release the lock after 10 seconds.
TimeSpan lockSpan = new TimeSpan(0, 0, 10); 

try
{
    // If item fetch is successful, lockHandle object will be populated
    // The lockHandle object will be used to unlock the cache item
    // acquireLock should be true if you want to acquire to the lock.
    // If item does not exists, account will be null
    BankAccount account = cache.Get(key, lockSpan, 
    ref lockHandle, acquireLock) as BankAccount;
    // Lock acquired otherwise it will throw LockingException exception

    if(account != null && account.IsActive)
    {
        // Withdraw money or Deposit
        account.Balance += withdrawAmount;
        // account.Balance -= depositAmount;

        // Insert the data in the cache and release the lock simultaneously 
        // LockHandle initially used to lock the item must be provided
        // releaseLock should be true to release the lock, otherwise false
        cache.Insert("Key", account, lockHandle, releaseLock); 
        //For your case you should use cache.Unlock("Key", lockHandle);
    }
    else
    {
        // Either does not exist or unable to cast
        // Explicitly release the lock in case of errors
        cache.Unlock("Key", lockHandle);
    } 
}
catch(LockingException lockException)
{
    // Lock couldn't be acquired
    // Wait and try again
}

Bağlantıdan alınmıştır: http://blogs.alachisoft.com/ncache/distributed-locking/