Sunucudan büyük miktarda veri gösteren bir web sayfam var. İletişim ajax aracılığıyla yapılır.

Kullanıcı bu verileri her etkileşime girdiğinde ve değiştirdiğinde (Diyelim ki kullanıcı A bir şeyi yeniden adlandırır), sunucuya işlemi yapmasını söyler ve sunucu yeni değiştirilen verileri döndürür.

B kullanıcısı sayfaya aynı anda erişir ve yeni bir veri nesnesi oluşturursa, sunucuya ajax aracılığıyla tekrar söyler ve sunucu kullanıcı için yeni nesneyle geri döner.

A'nın sayfasında, yeniden adlandırılmış bir nesneye sahip verilerimiz var. Ve B'nin sayfasında yeni bir nesneyle verilere sahibiz. Sunucuda verilerin hem yeniden adlandırılmış bir nesnesi hem de yeni bir nesnesi vardır.

Sayfayı birden çok kullanıcı aynı anda kullanırken sunucuyla senkronize tutmak için seçeneklerim nelerdir?

Sayfanın tamamını kilitleme veya her değişiklikte tüm durumu kullanıcıya atma gibi seçeneklerden daha çok kaçınılır.

İşe yarayacaksa, bu belirli örnekte web sayfası, veritabanında bir saklı yordamı çalıştıran statik bir web yöntemi çağırır. Depolanan yordam, değiştirdiği verileri döndürür ve daha fazlasını döndürmez. Statik web yöntemi, daha sonra saklı yordamın dönüşünü istemciye iletir.

Ödül Düzenlemesi:

Sunucuyla iletişim kurmak için Ajax kullanan ancak eşzamanlılıkla ilgili sorunları önleyen çok kullanıcılı bir web uygulamasını nasıl tasarlarsınız?

Yani herhangi bir veri veya durum bozulması riski olmadan bir veritabanındaki işlevselliğe ve verilere eşzamanlı erişim

Genel Bakış:

• Giriş
• Sunucu mimarisi
• İstemci mimarisi
• Vakayı güncelle
• Kaydetme vakası
• Çatışma durumu
• Performans ve ölçeklenebilirlik

Merhaba Raynos,

Burada belirli bir ürünü tartışmayacağım. Başkalarının bahsettiği şey, halihazırda bakmak için iyi bir araç setidir (belki bu listeye node.js ekleyebilir).

Mimari açıdan bakıldığında, sürüm kontrol yazılımında görülebilen problemin aynısını yaşıyorsunuz. Bir kullanıcı bir nesneye bir değişikliği kontrol eder, başka bir kullanıcı aynı nesneyi başka bir şekilde değiştirmek ister => çakışma. Kullanıcıların değişikliklerini nesnelere entegre ederken aynı zamanda güncellemeleri zamanında ve verimli bir şekilde sunabilmeli, yukarıdaki gibi çatışmaları tespit edip çözmelisiniz.

Senin yerinde olsaydım, şöyle bir şey geliştirirdim:

1. Sunucu Tarafı:

• "Atomik eserler" dediğim şeyi tanımlayacağınız makul bir seviye belirleyin (sayfa? Sayfadaki nesneler? Nesnelerin içindeki değerler?). Bu, web sunucularınıza, veritabanı ve önbelleğe alma donanımınıza, kullanıcı sayısına, nesnelerin sayısına, vb. Bağlı olacaktır. Kolay bir karar verilmez.

• Her bir atomik yapı için:

  • uygulama çapında benzersiz kimlik
  • artan bir sürüm kimliği
  • yazma erişimi için bir kilitleme mekanizması (muteks olabilir)
  • bir çalma arabelleği içindeki küçük bir geçmiş veya "değişiklik günlüğü" (paylaşılan bellek bunlar için iyi çalışır). Tek bir anahtar / değer çifti de daha az genişletilebilir olsa da uygun olabilir. bkz. http://en.wikipedia.org/wiki/Circular_buffer

• Bağlı bir kullanıcıya verimli bir şekilde ilgili değişiklik günlüklerini sunabilen bir sunucu veya sahte sunucu bileşeni . Observer-Pattern bunun için arkadaşınızdır.

2. İstemci Tarafı:

• Yukarıdaki sunucuya uzun süre çalışan bir HTTP Bağlantısına sahip olabilen veya hafif sorgulama kullanan bir javascript istemcisi.

• Bağlı javascript istemcisi izlenen yapı geçmişindeki değişiklikleri bildirdiğinde site içeriğini yenileyen bir javascript yapı güncelleyici bileşeni. (yine bir gözlemci modeli iyi bir seçim olabilir)

• Muteks kilidi edinmeye çalışan bir atomik yapıyı değiştirmeyi talep edebilen bir javascript artifact-committer bileşeni. Bilinen istemci-yapı-sürüm-kimliği ile mevcut sunucu-tarafı yapay-sürüm-kimliği karşılaştırarak yapının durumunun başka bir kullanıcı tarafından birkaç saniye önce değiştirilip değiştirilmediğini (javascript istemcisinin gecikmesi ve işleme süreci faktörleri dahil) tespit eder.

• Değişimin doğru olduğu bir insan kararına izin veren bir javascript çatışma çözücü. Kullanıcıya sadece "Biri senden daha hızlıydı. Değişikliğini sildim. Git ağla." Demek istemeyebilirsin. Oldukça teknik farklılıklardan veya daha kullanıcı dostu çözümlerden birçok seçenek mümkün görünmektedir.

Peki nasıl yuvarlanır ...

Durum 1: güncelleme için sıralama türü diyagramı:

• Tarayıcı sayfayı oluşturur
• javascript, her biri en az bir değer alanına, benzersiz ve sürüm kimliğine sahip yapıları "görür"
• javascript istemcisi başlatılır ve bulunan yapıların geçmişini bulunan sürümlerinden başlayarak "izlemek" ister (eski değişiklikler ilginç değildir)
• Sunucu süreci talebi not eder ve geçmişi sürekli kontrol eder ve / veya gönderir
• Geçmiş girişleri, basit bildirimler içerebilir "yapı x değişti, istemci pls veri ister" istemcinin bağımsız olarak veya tam veri kümelerini sorgulamasına izin verir "yapı x foo değerine değiştirildi"
• javascript artifact-updater, güncellendikleri bilinir hale gelir gelmez yeni değerleri almak için elinden geleni yapar. Yeni ajax isteklerini yürütür veya javascript istemcisi tarafından beslenir.
• DOM içeriği güncellenir, kullanıcı isteğe bağlı olarak bilgilendirilir. Tarih izleme devam ediyor.

Durum 2: Şimdi taahhütte bulunmak için:

• artifact-committer, kullanıcı girdisinden istenen yeni değeri bilir ve sunucuya bir değişiklik isteği gönderir
• server tarafı mutex satın alındı
• Sunucu "Hey, yapıt x'in durumunu 123 sürümünden biliyorum, foo pls değerine ayarlayayım."
• Yapay x'in Sunucu tarafı sürümü 123'e eşitse (daha küçük olamaz), yeni değer kabul edilir, 124'lük yeni bir sürüm kimliği oluşturulur.
• Yeni durum bilgisi "sürüm 124'e güncellendi" ve isteğe bağlı olarak yeni foo değeri, yapay x'in ringbuffer'ının (değişiklik günlüğü / geçmiş) başına yerleştirilir.
• serveride mutex yayınlandı
• yapı işlemcisi talep eden kişi, yeni kimlik ile birlikte bir onaylama onayı almaktan mutluluk duyar.
• bu arada sunucu tarafı sunucu bileşeni, ringbuffers'ı bağlı istemcilere sorgulamaya / itmeye devam eder. X yapıtının arabelleğini izleyen tüm istemciler, yeni durum bilgisini ve değerini normal gecikme süreleri içinde alacaklardır (Bkz. Durum 1).

Durum 3: çatışmalar için:

• artifact committer, kullanıcı girdisinden istenen yeni değeri bilir ve sunucuya bir değişiklik isteği gönderir
• bu arada başka bir kullanıcı aynı yapıyı başarıyla güncelledi (bkz. durum 2.), ancak çeşitli gecikmeler nedeniyle bu henüz diğer kullanıcımız tarafından bilinmemektedir.
• Böylece, sunucu tarafı bir muteks edinilir (veya "daha hızlı" kullanıcı değişikliğini yapana kadar beklenir)
• Sunucu "Hey, yapı x'in durumunu 123 sürümünden biliyorum, foo değerine ayarlayayım."
• Sunucu tarafında yapay x'in sürümü zaten 124'tür. Talepte bulunan müşteri, üzerine yazacağı değeri bilemez.
• Açıktır ki, Sunucunun değişiklik talebini reddetmesi (tanrı müdahalesi üzerine yazma önceliklerini saymaz), muteksi serbest bırakması ve yeni sürüm kimliğini ve yeni değeri doğrudan istemciye geri gönderecek kadar nazik olması gerekir.
• Reddedilmiş bir commit isteği ve değişiklik isteyen kullanıcının henüz bilmediği bir değerle karşı karşıya kalan javascript artifact committer, sorunu görüntüleyen ve kullanıcıya açıklayan çakışma çözücüye başvurur.
• Akıllı çakışma çözücü JS tarafından bazı seçenekler sunulan kullanıcıya, değeri değiştirmek için başka bir girişimde bulunulmasına izin verilir.
• Kullanıcı doğru gördüğü bir değeri seçtikten sonra, süreç 2. durumdan (veya başka biri daha hızlıysa 3. durumdan) baştan başlar.

Performans ve Ölçeklenebilirlik hakkında birkaç söz

HTTP Yoklaması ve HTTP "aktarması"

• Yoklama, kabul edilebilir gecikme olarak kabul ettiğiniz her durumda saniyede bir, saniyede 5 istek oluşturur. (Apache?) Ve (php?) 'Nizi "hafif" başlangıçlar olacak kadar iyi yapılandırmazsanız, bu altyapınız için oldukça zalim olabilir. Yoklama talebinin, yoklama aralığının uzunluğundan çok daha kısa bir süre çalışması için sunucu tarafında optimize edilmesi arzu edilir. Bu çalışma süresini ikiye bölmek, tüm sistem yükünüzü% 50'ye kadar düşürmek anlamına gelebilir.
• HTTP yoluyla itme (web çalışanlarının onları destekleyemeyecek kadar uzakta olduğunu varsayarak) her kullanıcı için her zaman bir apache / lighthttpd işlemine sahip olmanızı gerektirir . Bu işlemlerin her biri için ayrılan yerleşik bellek ve sistemlerinizin toplam belleği, karşılaşacağınız çok belirli bir ölçeklendirme sınırı olacaktır. Bağlantının bellek ayak izini azaltmak ve bunların her birinde yapılan sürekli CPU ve G / Ç işlerinin miktarını sınırlamak gerekli olacaktır (çok fazla uyku / boşta kalma süresi istiyorsunuz)

arka uç ölçekleme

• Veritabanını ve dosya sistemini unutun , sık yapılan yoklamalar için bir tür paylaşılan bellek tabanlı arka uca ihtiyacınız olacak (istemci doğrudan yoklama yapmazsa, çalışan her sunucu işlemi olacaktır)
• memcache için giderseniz daha iyi ölçeklendirebilirsiniz, ancak yine de pahalıdır
• Yük dengeleme için birden fazla ön uç sunucunuz olsun isteseniz bile, taahhütler için muteks küresel olarak çalışmalıdır.

ön uç ölçekleme

• Oylama yapıyor veya "push" alıyor olsanız da, izlenen tüm eserler için tek adımda bilgi almaya çalışın.

"yaratıcı" ince ayarlar

• İstemciler yoklama yapıyorsa ve birçok kullanıcı aynı yapıları izleme eğilimindeyse, bu yapıtların geçmişini statik bir dosya olarak yayınlamayı deneyebilirsiniz, bu da apache'nin önbelleğe almasına izin verir, yine de yapılar değiştiğinde sunucu tarafında yeniler. Bu, PHP / memcache'yi bazı istekler için oyunun dışına çıkarır. Lighthttpd, statik dosyaları sunmada çok etkilidir.
• Artefakt geçmişini oraya göndermek için cotendo.com gibi bir içerik dağıtım ağı kullanın. İtme gecikmesi daha büyük olacak ancak ölçeklenebilirlik bir rüya
• kullanıcıların java veya flash (?) kullanarak bağlandıkları gerçek bir sunucu (HTTP kullanmayan) yazın. Tek bir sunucu dizisinde birçok kullanıcıya hizmet vermekle uğraşmanız gerekir. Açık soketler arasında dolaşın, gerekli işi yapın (veya yetkilendirin). Çatallama işlemleriyle veya daha fazla sunucu başlatarak ölçeklenebilir. Muteksler, küresel olarak benzersiz kalmalıdır.
• Yük senaryolarına bağlı olarak ön uç ve arka uç sunucularınızı yapay kimlik aralıklarına göre gruplayın. Bu, kalıcı belleğin daha iyi kullanımına izin verir (hiçbir veritabanı tüm verilere sahip değildir) ve mutekslemeyi ölçeklendirmeyi mümkün kılar. Javascript'iniz aynı anda birden çok sunucuya bağlantı sağlamalıdır.

Umarım bu kendi fikirleriniz için bir başlangıç ​​olabilir. Eminim daha çok olasılık vardır. Bu gönderiye yönelik herhangi bir eleştiri veya geliştirmeyi memnuniyetle karşılıyorum, wiki etkinleştirildi.

Christoph Strasen

Bunun eski bir soru olduğunu biliyorum, ama ben sadece cevap vereyim dedim.

OT (operasyonel dönüşümler) , eşzamanlı ve tutarlı çok kullanıcılı düzenleme gereksinimlerinize uygun görünüyor. Google Dokümanlar'da kullanılan bir tekniktir (ve Google Wave'de de kullanılmıştır):

Google Wave ekibinden bir üye tarafından yazılmış Operational Transforms - ShareJS ( http://sharejs.org/ ) kullanmak için JS tabanlı bir kitaplık var .

Ve isterseniz, tam bir MVC web çerçevesi var - ShareJS üzerine kurulu DerbyJS ( http://derbyjs.com/ ), her şeyi sizin için yapar.

Sunucu ve istemciler arasındaki iletişim için BrowserChannel kullanıyor (ve WebSockets desteğinin çalışmalarda olması gerektiğine inanıyorum - daha önce Socket.IO aracılığıyla oradaydı, ancak geliştiricinin Socket.io ile ilgili sorunları nedeniyle çıkarıldı) Başlangıç ​​belgeleri ancak şu anda biraz seyrek.

Her veri kümesi için zamana dayalı değiştirilmiş damga eklemeyi düşünürdüm. Dolayısıyla, db tablolarını güncelliyorsanız, değiştirilen zaman damgasını buna göre değiştirirsiniz. AJAX'ı kullanarak, istemcinin değiştirilen zaman damgasını veri kaynağının zaman damgası ile karşılaştırabilirsiniz - kullanıcı geride kalırsa ekranı güncelleyin. Bu sitenin, siz bir cevap yazarken başka birinin cevap verip vermediğini görmek için periyodik olarak bir soruyu kontrol etme şekline benzer.

Değişiklikleri db'ye yapılır yapılmaz kullanıcıya yaymak için itme tekniklerini (Comet veya ters Ajax olarak da bilinir) kullanmanız gerekir. Bunun için şu anda mevcut olan en iyi teknik, Ajax uzun yoklaması gibi görünüyor, ancak her tarayıcı tarafından desteklenmiyor, bu nedenle yedeklere ihtiyacınız var. Neyse ki bunu sizin için halleden çözümler zaten var. Bunlar arasında orbited.org ve daha önce bahsedilen socket.io vardır.

Gelecekte bunu yapmanın WebSockets adı verilen daha kolay bir yolu olacak, ancak standardın mevcut durumu hakkında güvenlik endişeleri olduğu için bu standardın ne zaman hazır olacağı henüz kesin değil.

Veritabanında yeni nesnelerle eşzamanlılık sorunu olmamalıdır. Ancak bir kullanıcı bir nesneyi düzenlediğinde, sunucunun bu arada nesnenin düzenlenip düzenlenmediğini veya silinip silinmediğini kontrol eden bir mantığa sahip olması gerekir. Nesne silinmişse, çözüm yine basittir: Sadece düzenlemeyi atın.

Ancak en zor sorun, birden çok kullanıcı aynı anda aynı nesneyi düzenlerken ortaya çıkar. Kullanıcı 1 ve 2 aynı anda bir nesneyi düzenlemeye başlarsa, ikisi de düzenlemelerini aynı veriler üzerinde yapacaklardır. Diyelim ki, Kullanıcı 1'in yaptığı değişiklikler, önce Kullanıcı 2 verileri düzenlerken sunucuya gönderildi. Daha sonra iki seçeneğiniz vardır: Kullanıcı 1'in değişikliklerini Kullanıcı 2'nin verileriyle birleştirmeyi deneyebilir veya Kullanıcı 2'ye verilerinin güncel olmadığını söyleyebilir ve verileri sunucuya gönderilir gönderilmez ona bir hata mesajı görüntüleyebilirsiniz. İkincisi burada çok kullanıcı dostu bir seçenek değil, ancak birincisinin uygulanması çok zor.

İlk defa bu hakkı elde eden birkaç uygulamadan biri, Google tarafından satın alınan EtherPad idi. Daha sonra Google Docs ve Google Wave'de EtherPad'in bazı teknolojilerini kullandıklarına inanıyorum, ancak bunu kesin olarak söyleyemem. Google ayrıca EtherPad'i de açar, bu yüzden ne yapmaya çalıştığınıza bağlı olarak belki de bu bir göz atmaya değer.

Bunu aynı anda düzenlemek gerçekten kolay değil çünkü gecikme nedeniyle web'de atomik işlemler yapmak mümkün değil. Belki bu makale konu hakkında daha fazla bilgi edinmenize yardımcı olacaktır.

Tüm bunları kendi başınıza yazmaya çalışmak büyük bir iş ve doğru yapmak çok zor. Bir seçenek, istemcileri veritabanıyla ve birbirleriyle gerçek zamanlı olarak senkronize tutmak için oluşturulmuş bir çerçeve kullanmaktır.

Meteor çerçevesinin bunu iyi yaptığını buldum ( http://docs.meteor.com/#reactivity ).

"Meteor, reaktif programlama kavramını benimsiyor. Bu, kodunuzu basit bir zorunlu stilde yazabileceğiniz ve kodunuzun bağlı olduğu veriler her değiştiğinde sonucun otomatik olarak yeniden hesaplanacağı anlamına geliyor."

"Bu basit model (reaktif hesaplama + reaktif veri kaynağı) geniş bir uygulanabilirliğe sahiptir. Programcı aboneliği iptal etme / yeniden abone olma çağrılarını yazmaktan ve bunların doğru zamanda çağrıldığından emin olmaktan kurtulur ve aksi takdirde veri yayılım kodunun tüm sınıflarını ortadan kaldırır; hataya açık mantıklı uygulama. "

Kimsenin Meteor'dan bahsetmediğine inanamıyorum . Kesinlikle yeni ve olgunlaşmamış bir çerçeve (ve yalnızca resmi olarak bir DB'yi destekliyor), ancak posterdeki gibi çok kullanıcılı bir uygulamadan tüm homurdanmayı ve düşünmeyi alıyor . Aslında, çok kullanıcılı bir canlı güncelleme uygulaması OLUŞTURAMAZSINIZ. İşte hızlı bir özet:

• Her şey node.js (JavaScript veya CoffeeScript) içindedir, böylece istemci ve sunucu arasında doğrulama gibi şeyler paylaşabilirsiniz.
• Web yuvalarını kullanır, ancak eski tarayıcılar için geri dönebilir
• Arka planda sunucuya gönderilen değişikliklerle yerel nesneye (yani kullanıcı arabirimi çabuk hissedilir) yapılan anlık güncellemelere odaklanır. Karıştırma güncellemelerini daha basit hale getirmek için yalnızca atomik güncellemelere izin verilir. Sunucuda reddedilen güncellemeler geri alınır.
• Bonus olarak, canlı kod yeniden yüklemelerini sizin için yönetir ve uygulama kökten değiştiğinde bile kullanıcı durumunu korur.

Meteor yeterince basittir ki, çalınacak fikirler için en azından ona bir göz atmanızı öneririm.

Bunlar Wikipedia sayfaları öğrenmeye için eklenti perspektifini yardımcı olabilir eşzamanlılık ve eşzamanlı bilgi işlem bir tasarlamak için ajax web uygulaması ya o çeker veya itilen durum olay ( EDA ) iletileri bir de mesajlaşma deseni . Temel olarak mesajlar, değişiklik olaylarına ve senkronizasyon taleplerine yanıt veren kanal abonelerine kopyalanır.

• https://en.wikipedia.org/wiki/Category:Concurrency_control
• https://en.wikipedia.org/wiki/Distributed_concurrency_control
• https://en.wikipedia.org/wiki/CAP_theorem
• https://en.wikipedia.org/wiki/Operational_transformation
• https://en.wikipedia.org/wiki/Fallacies_of_Distributed_Computing

Eşzamanlı web tabanlı işbirliği yazılımlarının birçok biçimi vardır .

Bir dizi vardır etherpad-lite için API istemci kütüphaneleri, HTTP , bir işbirlikçi gerçek zamanlı editörü .

django-gerçek zamanlı oyun alanı, Django'da Socket.io gibi çeşitli gerçek zamanlı teknolojilerle gerçek zamanlı bir sohbet uygulaması uygular .

Hem AppEngine hem de AppScale, AppEngine Kanal API'sini uygular ; olan farklı olan hakkında gerçek zamanlı API ile gösterilmektedir, Google Drive / gerçek zamanlı-oyun .

Sunucu tarafı itme teknikleri buraya gitmenin yoludur. Comet bir vızıltı kelimesi (veya miydi?).

Seçtiğiniz belirli yön, büyük ölçüde sunucu yığınınıza ve ne kadar esnek olduğunuza bağlıdır. Yapabiliyorsanız , sunucuyla çift yönlü iletişim kurmanın son derece basit bir yolunu sunan ve sunucunun istemcilere güncellemeleri göndermesine olanak tanıyan web soketlerinin tarayıcılar arası bir uygulamasını sağlayan socket.io'ya bir göz atacağım .

Özellikle, tarif ettiğiniz durumu neredeyse tam olarak gösteren, kütüphane yazarının bu gösterisine bakın .