Saya memiliki halaman web yang menampilkan sejumlah besar data dari server. Komunikasi dilakukan melalui ajax.

Setiap kali pengguna berinteraksi dan mengubah data ini (Katakanlah pengguna A mengganti nama sesuatu), ia memberitahu server untuk melakukan tindakan dan server mengembalikan data baru yang diubah.

Jika pengguna B mengakses halaman pada saat yang sama dan membuat objek data baru, ia akan kembali memberi tahu server melalui ajax dan server akan kembali dengan objek baru untuk pengguna tersebut.

Di halaman A kami memiliki data dengan objek yang diubah namanya. Dan di halaman B kami memiliki data dengan objek baru. Di server, data memiliki objek yang diganti namanya dan objek baru.

Apa sajakah pilihan saya untuk menjaga halaman tetap sinkron dengan server ketika beberapa pengguna menggunakannya secara bersamaan?

Opsi seperti mengunci seluruh halaman atau membuang seluruh status kepada pengguna pada setiap perubahan agak dihindari.

Jika membantu, dalam contoh khusus ini, halaman web memanggil metode web statis yang menjalankan prosedur tersimpan di database. Prosedur tersimpan akan mengembalikan data apa pun yang telah diubah dan tidak lebih. Metode web statis kemudian meneruskan kembali prosedur tersimpan ke klien.

Bounty Edit:

Bagaimana Anda mendesain aplikasi web multi-pengguna yang menggunakan Ajax untuk berkomunikasi dengan server tetapi menghindari masalah dengan konkurensi?

Yaitu akses bersamaan ke fungsionalitas dan data di database tanpa risiko data atau korupsi negara

Gambaran:

• Intro
• Arsitektur server
• Arsitektur klien
• Perbarui kasus
• Kasus komit
• Kasus konflik
• Performa & skalabilitas

Hai Raynos,

Saya tidak akan membahas produk tertentu di sini. Apa yang disebutkan orang lain adalah toolset yang bagus untuk dilihat (mungkin tambahkan node.js ke daftar itu).

Dari sudut pandang arsitektur, Anda tampaknya memiliki masalah yang sama dengan yang dapat dilihat pada perangkat lunak kontrol versi. Satu pengguna memeriksa perubahan ke objek, pengguna lain ingin mengubah objek yang sama dengan cara lain => konflik. Anda harus mengintegrasikan perubahan pengguna ke objek sementara pada saat yang sama dapat mengirimkan pembaruan tepat waktu dan efisien, mendeteksi dan menyelesaikan konflik seperti di atas.

Jika saya berada di posisi Anda, saya akan mengembangkan sesuatu seperti ini:

1. Sisi Server:

• Tentukan tingkat yang masuk akal di mana Anda akan mendefinisikan apa yang saya sebut "artefak atom" (halaman? Objek di halaman? Nilai di dalam objek?). Ini akan tergantung pada server web Anda, perangkat keras database & cache, # pengguna, # objek, dll. Bukan keputusan yang mudah untuk dibuat.

• Untuk setiap artefak atom memiliki:

  • ID unik untuk seluruh aplikasi
  • versi-id yang bertambah
  • mekanisme penguncian untuk akses tulis (mutex mungkin)
  • sejarah kecil atau "changelog" di dalam ringbuffer (memori bersama bekerja dengan baik untuk mereka). Sepasang kunci-nilai mungkin juga OK meskipun kurang dapat diperpanjang. lihat http://en.wikipedia.org/wiki/Circular_buffer

• Komponen server atau pseudo-server yang mampu mengirimkan log perubahan yang relevan ke pengguna yang terhubung secara efisien. Observer-Pattern adalah teman Anda untuk ini.

2. Sisi Klien:

• Klien javascript yang dapat memiliki Koneksi HTTP yang berjalan lama ke server tersebut di atas, atau menggunakan polling ringan.

• Komponen pembaru artefak javascript yang menyegarkan konten situs saat klien javascript yang terhubung memberi tahu tentang perubahan dalam riwayat artefak yang dipantau. (sekali lagi pola pengamat mungkin merupakan pilihan yang baik)

• Komponen pembuat artefak javascript yang mungkin meminta untuk mengubah artefak atom, mencoba memperoleh kunci mutex. Ini akan mendeteksi jika status artefak telah diubah oleh pengguna lain hanya beberapa detik sebelumnya (latan dari klien javascript dan faktor proses komit dalam) dengan membandingkan artefak-versi-id sisi klien yang diketahui dan artefak-versi-id di sisi server saat ini.

• Pemecah konflik javascript yang memungkinkan manusia mengambil keputusan yang-ubah-adalah-hak. Anda mungkin tidak ingin hanya memberi tahu pengguna "Seseorang lebih cepat dari Anda. Saya menghapus kembalian Anda. Menangislah.". Banyak opsi dari perbedaan yang agak teknis atau solusi yang lebih ramah pengguna tampaknya memungkinkan.

Jadi bagaimana itu akan bergulir ...

Kasus 1: diagram jenis urutan untuk memperbarui:

• Browser merender halaman
• javascript "melihat" artefak yang masing-masing memiliki setidaknya satu bidang nilai, unik- dan versi-id
• klien javascript memulai, meminta untuk "melihat" riwayat artefak yang ditemukan mulai dari versi yang ditemukan (perubahan lama tidak menarik)
• Proses server mencatat permintaan dan terus menerus memeriksa dan / atau mengirimkan riwayat
• Entri riwayat mungkin berisi pemberitahuan sederhana "artefak x telah berubah, klien mohon meminta data" yang memungkinkan klien untuk melakukan polling secara independen atau kumpulan data lengkap "artefak x telah berubah ke nilai foo"
• javascript artifact-updater melakukan apa yang dapat dilakukannya untuk mengambil nilai baru segera setelah diketahui telah diperbarui. Ini mengeksekusi permintaan ajax baru atau diberi makan oleh klien javascript.
• Halaman DOM-konten diperbarui, pengguna diberi tahu secara opsional. Pengamatan sejarah terus berlanjut.

Kasus 2: Sekarang untuk melakukan:

• artifact-committer mengetahui nilai baru yang diinginkan dari input pengguna dan mengirimkan permintaan perubahan ke server
• Serveride mutex diperoleh
• Server menerima "Hai, saya tahu status artefak x dari versi 123, izinkan saya menyetelnya ke nilai foo pls."
• Jika versi Server sisi dari artefak x sama (tidak boleh kurang) dari 123 nilai baru diterima, ID versi baru 124 dibuat.
• Status-informasi baru "diperbarui ke versi 124" dan opsional nilai baru foo diletakkan di awal ringbuffer x artefak (changelog / sejarah)
• Serveride mutex dirilis
• meminta pembuat artefak dengan senang hati menerima konfirmasi-komit bersama dengan id baru.
• Sementara itu, komponen server di sisi server terus melakukan polling / mendorong ringbuffers ke klien yang terhubung. Semua klien yang mengamati buffer artefak x akan mendapatkan informasi dan nilai status baru dalam latensi biasa (Lihat kasus 1.)

Kasus 3: untuk konflik:

• pelaku artefak mengetahui nilai baru yang diinginkan dari input pengguna dan mengirimkan permintaan perubahan ke server
• Sementara itu, pengguna lain berhasil memperbarui artefak yang sama (lihat kasus 2.) tetapi karena berbagai latensi, hal ini belum diketahui oleh pengguna kami yang lain.
• Jadi mutex di sisi server diperoleh (atau menunggu hingga pengguna "lebih cepat" melakukan perubahannya)
• Server menerima "Hai, saya tahu status artefak x dari versi 123, izinkan saya menyetelnya ke nilai foo."
• Di sisi server, versi artefak x sekarang sudah 124. Klien yang meminta tidak dapat mengetahui nilai yang akan ditimpanya.
• Jelas Server harus menolak permintaan perubahan (tidak termasuk dalam prioritas timpaan campur tangan dewa), melepaskan mutex dan cukup baik untuk mengirim kembali versi-id baru dan nilai baru langsung ke klien.
• dihadapkan dengan permintaan komit yang ditolak dan nilai yang belum diketahui oleh pengguna yang meminta perubahan, pembuat artefak javascript mengacu pada penyelesaian konflik yang menampilkan dan menjelaskan masalah kepada pengguna.
• Pengguna, yang diberi beberapa opsi oleh JS pemecah konflik cerdas, diizinkan mencoba lagi untuk mengubah nilainya.
• Setelah pengguna memilih nilai yang dianggapnya benar, proses dimulai dari kasus 2 (atau kasus 3 jika orang lain lebih cepat, lagi)

Beberapa kata tentang Kinerja & Skalabilitas

Polling HTTP vs. "mendorong" HTTP

• Polling membuat permintaan, satu per detik, 5 per detik, apa pun yang Anda anggap sebagai latensi yang dapat diterima. Ini bisa menjadi kejam bagi infrastruktur Anda jika Anda tidak mengkonfigurasi (Apache?) Dan (php?) Anda dengan cukup baik untuk menjadi pemula yang "ringan". Sangat diinginkan untuk mengoptimalkan permintaan polling di sisi server sehingga berjalan untuk waktu yang jauh lebih sedikit daripada panjang interval polling. Membagi runtime itu menjadi dua mungkin berarti menurunkan seluruh beban sistem Anda hingga 50%,
• Mendorong melalui HTTP (dengan asumsi webworkers terlalu jauh untuk mendukung mereka) akan mengharuskan Anda memiliki satu proses apache / lighthttpd yang tersedia untuk setiap pengguna sepanjang waktu . Memori penduduk yang dicadangkan untuk masing-masing proses ini dan total memori sistem Anda akan menjadi satu batas penskalaan yang pasti akan Anda temui. Mengurangi jejak memori koneksi akan diperlukan, serta membatasi jumlah CPU berkelanjutan dan pekerjaan I / O yang dilakukan di masing-masing ini (Anda ingin banyak waktu tidur / idle)

penskalaan backend

• Lupakan database dan sistem file, Anda akan memerlukan semacam backend berbasis memori bersama untuk polling yang sering (jika klien tidak melakukan polling secara langsung maka setiap proses server yang berjalan akan)
• jika Anda menggunakan memcache, Anda dapat menskalakan lebih baik, tetapi masih mahal
• Mutex untuk komit harus berfungsi secara global meskipun Anda ingin memiliki beberapa server frontend untuk memuat keseimbangan.

penskalaan frontend

• terlepas dari apakah Anda sedang melakukan polling atau menerima "dorongan", coba dapatkan informasi untuk semua artefak yang diamati dalam satu langkah.

tweak "kreatif"

• Jika klien melakukan polling dan banyak pengguna cenderung menonton artefak yang sama, Anda dapat mencoba memublikasikan histori artefak tersebut sebagai file statis, mengizinkan apache untuk menyimpan cache, namun menyegarkannya di sisi server saat artefak berubah. Ini mengeluarkan PHP / memcache dari permainan beberapa untuk meminta. Lighthttpd sangat efisien dalam menyajikan file statis.
• menggunakan jaringan pengiriman konten seperti cotendo.com untuk mendorong riwayat artefak di sana. Push-latency akan lebih besar tetapi skalabilitas adalah impian
• tulis server nyata (tidak menggunakan HTTP) yang terhubung dengan pengguna menggunakan java atau flash (?). Anda harus berurusan dengan melayani banyak pengguna dalam satu utas server. Bersepeda melalui soket terbuka, melakukan (atau mendelegasikan) pekerjaan yang diperlukan. Dapat menskalakan melalui proses forking atau memulai lebih banyak server. Mutex harus tetap unik secara global.
• Bergantung pada skenario pemuatan, kelompokkan server frontend dan backend menurut rentang id artefak. Ini akan memungkinkan penggunaan memori persisten yang lebih baik (tidak ada database yang memiliki semua data) dan memungkinkan untuk menskalakan mutexing. Javascript Anda harus memelihara koneksi ke beberapa server pada saat yang bersamaan.

Baiklah saya harap ini bisa menjadi awal untuk ide Anda sendiri. Saya yakin ada lebih banyak kemungkinan. Saya lebih dari menyambut kritik atau peningkatan apapun untuk posting ini, wiki diaktifkan.

Christoph Strasen

Saya tahu ini adalah pertanyaan lama, tetapi saya pikir saya hanya akan setuju.

OT (transformasi operasional) sepertinya cocok untuk kebutuhan Anda untuk pengeditan multi-pengguna secara bersamaan dan konsisten. Ini adalah teknik yang digunakan di Google Docs (dan juga digunakan di Google Wave):

Ada perpustakaan berbasis JS untuk menggunakan Transformasi Operasional - ShareJS ( http://sharejs.org/ ), yang ditulis oleh anggota dari tim Google Wave.

Dan jika Anda mau, ada kerangka kerja web MVC lengkap - DerbyJS ( http://derbyjs.com/ ) dibangun di atas ShareJS yang melakukan semuanya untuk Anda.

Ini menggunakan BrowserChannel untuk komunikasi antara server dan klien (dan saya yakin dukungan WebSockets harus dalam pengerjaan - itu ada di sana sebelumnya melalui Socket.IO, tetapi diambil karena masalah pengembang dengan Socket.io) Dokumen pemula adalah a sedikit jarang saat ini.

Saya akan mempertimbangkan untuk menambahkan cap yang dimodifikasi berdasarkan waktu untuk setiap dataset. Jadi, jika Anda memperbarui tabel db, Anda akan mengubah stempel waktu yang dimodifikasi. Dengan menggunakan AJAX, Anda dapat membandingkan stempel waktu klien yang dimodifikasi dengan stempel waktu sumber data - jika pengguna tertinggal, perbarui tampilan. Mirip dengan bagaimana situs ini memeriksa pertanyaan secara berkala untuk melihat apakah ada orang lain yang menjawab saat Anda mengetik jawaban.

Anda perlu menggunakan teknik push (juga dikenal sebagai Comet atau Ajax terbalik) untuk menyebarkan perubahan ke pengguna segera setelah dibuat ke db. Teknik terbaik yang saat ini tersedia untuk ini tampaknya adalah polling panjang Ajax, tetapi tidak didukung oleh setiap browser, jadi Anda perlu fallback. Untungnya sudah ada solusi yang menangani hal ini untuk Anda. Diantaranya adalah: orbited.org dan socket.io yang telah disebutkan.

Di masa depan akan ada cara yang lebih mudah untuk melakukan ini yang disebut WebSockets, tetapi belum pasti kapan standar itu akan siap untuk prime time karena ada masalah keamanan tentang keadaan standar saat ini.

Seharusnya tidak ada masalah konkurensi dalam database dengan objek baru. Tetapi ketika pengguna mengedit objek, server perlu memiliki beberapa logika yang memeriksa apakah objek tersebut telah diedit atau dihapus untuk sementara. Jika objek telah dihapus solusinya, sekali lagi, sederhana: Buang saja hasil edit.

Tetapi masalah yang paling sulit muncul, ketika banyak pengguna mengedit objek yang sama pada waktu yang sama. Jika Pengguna 1 dan 2 mulai mengedit objek pada saat yang sama, mereka berdua akan mengedit data yang sama. Katakanlah perubahan yang dibuat Pengguna 1 dikirim ke server terlebih dahulu saat Pengguna 2 masih mengedit data. Anda kemudian memiliki dua opsi: Anda dapat mencoba menggabungkan perubahan Pengguna 1 ke dalam data Pengguna 2 atau Anda dapat memberi tahu Pengguna 2 bahwa datanya sudah kedaluwarsa dan menampilkan pesan kesalahan kepadanya segera setelah datanya dikirim ke server. Yang terakhir bukanlah pilihan yang sangat ramah pengguna di sini, tetapi yang pertama sangat sulit untuk diterapkan.

Salah satu dari sedikit implementasi yang benar-benar mendapatkan hak ini untuk pertama kalinya adalah EtherPad , yang diakuisisi oleh Google. Saya yakin mereka kemudian menggunakan beberapa teknologi EtherPad di Google Docs dan Google Wave, tapi saya tidak bisa memastikannya. Google juga membuka EtherPad sumbernya, jadi mungkin itu layak untuk dilihat, tergantung pada apa yang Anda coba lakukan.

Benar-benar tidak mudah untuk melakukan hal-hal yang mengedit ini secara bersamaan, karena tidak mungkin melakukan operasi atom di web karena latensi. Mungkin artikel ini akan membantu Anda mempelajari lebih lanjut tentang topik tersebut.

Mencoba menulis semua ini sendiri adalah pekerjaan besar, dan sangat sulit untuk melakukannya dengan benar. Salah satu opsinya adalah menggunakan kerangka kerja yang dibuat untuk menjaga klien tetap sinkron dengan database, dan satu sama lain, secara realtime.

Saya telah menemukan bahwa kerangka Meteor melakukan ini dengan baik ( http://docs.meteor.com/#reactivity ).

"Meteor menganut konsep pemrograman reaktif. Ini berarti Anda dapat menulis kode Anda dalam gaya imperatif sederhana, dan hasilnya akan dihitung ulang secara otomatis setiap kali ada perubahan data yang bergantung pada kode Anda."

"Pola sederhana ini (komputasi reaktif + sumber data reaktif) memiliki penerapan yang luas. Pemrogram tidak perlu menulis panggilan berhenti berlangganan / berlangganan ulang dan memastikan panggilan tersebut dipanggil pada waktu yang tepat, menghilangkan seluruh kelas kode propagasi data yang jika tidak akan menyumbat Anda aplikasi dengan logika rawan kesalahan. "

Saya tidak percaya tidak ada yang menyebut Meteor . Ini adalah kerangka kerja baru dan belum matang yang pasti (dan hanya secara resmi mendukung satu DB), tetapi ini membutuhkan semua pekerjaan kasar dan memikirkan aplikasi multi-pengguna seperti yang dijelaskan poster. Faktanya, Anda TIDAK dapat TIDAK membangun aplikasi pembaruan langsung multi-pengguna. Berikut ringkasan singkatnya:

• Semuanya ada di node.js (JavaScript atau CoffeeScript), jadi Anda dapat membagikan hal-hal seperti validasi antara klien dan server.
• Ini menggunakan websockets, tetapi dapat kembali ke browser lama
• Ini berfokus pada pembaruan langsung ke objek lokal (yaitu UI terasa cepat), dengan perubahan yang dikirim ke server di latar belakang. Hanya pembaruan atom yang diizinkan untuk membuat pembaruan pencampuran lebih sederhana. Pembaruan yang ditolak di server dibatalkan.
• Sebagai bonus, ini menangani pemuatan ulang kode langsung untuk Anda, dan akan mempertahankan status pengguna bahkan ketika aplikasi berubah secara radikal.

Meteor cukup sederhana sehingga saya sarankan Anda setidaknya melihatnya untuk dicuri ide.

Halaman Wikipedia ini dapat membantu menambah perspektif untuk belajar tentang konkurensi dan komputasi bersamaan untuk merancang aplikasi web ajax yang menarik atau mendorong pesan peristiwa keadaan ( EDA ) dalam pola pesan . Pada dasarnya, pesan direplikasi ke pelanggan saluran yang menanggapi acara perubahan dan permintaan sinkronisasi.

• 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

Ada banyak bentuk perangkat lunak kolaboratif berbasis web secara bersamaan .

Ada sejumlah pustaka klien HTTP API untuk etherpad-lite , editor waktu nyata kolaboratif .

django-realtime-playground menerapkan aplikasi obrolan waktu nyata di Django dengan berbagai teknologi waktu nyata seperti Socket.io .

Baik AppEngine dan AppScale menerapkan API Saluran AppEngine ; yang berbeda dari Google Realtime API , yang ditunjukkan oleh googledrive / realtime-playground .

Teknik push sisi server adalah cara untuk menuju ke sini. Komet adalah (atau tadinya?) Kata buzz.

Arah tertentu yang Anda ambil sangat bergantung pada tumpukan server Anda, dan seberapa fleksibel Anda / itu. Jika Anda bisa, saya akan melihat socket.io , yang menyediakan implementasi lintas-browser websockets, yang menyediakan cara yang sangat efisien untuk memiliki komunikasi dua arah dengan server, memungkinkan server untuk mendorong pembaruan ke klien.

Secara khusus, lihat ini demonstrasi oleh perpustakaan penulis, yang menunjukkan hampir persis situasi yang Anda gambarkan.