Concurrency Control

<h2 id="concurrency-control-in-geode" class="position-relative d-flex align-items-center group"> Concurrency Control in Geode <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="concurrency-control-in-geode" aria-haspopup="dialog" aria-label="Share link: Concurrency Control in Geode"> Share link </button> </h2><div id="headingShareModal" class="heading-share-modal" role="dialog" aria-modal="true" aria-labelledby="headingShareTitle" hidden> <div class="hsm-dialog" role="document"> <div class="hsm-header"> <h2 id="headingShareTitle" class="h6 mb-0 fw-bold">Share this section</h2> <button type="button" class="hsm-close" aria-label="Close"> </button> </div> <div class="hsm-body"> <label for="headingShareInput" class="form-label small text-muted mb-1 text-uppercase fw-bold" style="font-size: 0.7rem; letter-spacing: 0.5px;">Permalink</label> <div class="input-group mb-4 hsm-url-group"> <input id="headingShareInput" type="text" class="form-control font-monospace" readonly aria-readonly="true" style="font-size: 0.85rem;" /> <button class="btn btn-primary hsm-copy" type="button" aria-label="Copy" title="Copy"> </button> </div> <div class="small fw-bold mb-2 text-muted text-uppercase" style="font-size: 0.7rem; letter-spacing: 0.5px;">Share via</div> <div class="hsm-share-grid"> <a id="share-twitter" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> Twitter </a> <a id="share-linkedin" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> LinkedIn </a> <a id="share-facebook" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> Facebook </a> </div> </div> </div> </div> <style> .heading-share-modal { position: fixed; inset: 0; display: flex; justify-content: center; align-items: center; background: rgba(0, 0, 0, 0.6); z-index: 1050; padding: 1rem; backdrop-filter: blur(4px); -webkit-backdrop-filter: blur(4px); } .heading-share-modal[hidden] { display: none !important; } .hsm-dialog { max-width: 420px; width: 100%; background: var(--bs-body-bg, #fff); color: var(--bs-body-color, #212529); border: 1px solid var(--bs-border-color, rgba(0,0,0,0.1)); border-radius: 1rem; box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25); overflow: hidden; animation: hsm-fade-in 0.2s ease-out; } @keyframes hsm-fade-in { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } } [data-bs-theme="dark"] .hsm-dialog { background: #1e293b; border-color: rgba(255,255,255,0.1); color: #f8f9fa; } .hsm-header { display: flex; justify-content: space-between; align-items: center; padding: 1rem 1.5rem; border-bottom: 1px solid var(--bs-border-color, rgba(0,0,0,0.1)); background: rgba(0,0,0,0.02); } [data-bs-theme="dark"] .hsm-header { background: rgba(255,255,255,0.02); border-color: rgba(255,255,255,0.1); } .hsm-close { background: transparent; border: none; color: inherit; opacity: 0.5; padding: 0.25rem 0.5rem; border-radius: 0.25rem; font-size: 1.2rem; line-height: 1; transition: opacity 0.2s; } .hsm-close:hover { opacity: 1; } .hsm-body { padding: 1.5rem; } .hsm-url-group { display: flex !important; align-items: stretch; } .hsm-url-group .form-control { flex: 1; min-width: 0; margin: 0; background: var(--bs-secondary-bg, #f8f9fa); border-color: var(--bs-border-color, #dee2e6); border-top-right-radius: 0; border-bottom-right-radius: 0; height: 42px; } .hsm-url-group .btn { flex: 0 0 auto; margin: 0; margin-left: -1px; border-top-left-radius: 0; border-bottom-left-radius: 0; height: 42px; display: flex; align-items: center; justify-content: center; padding: 0 1.25rem; z-index: 2; } [data-bs-theme="dark"] .hsm-url-group .form-control { background: #0f172a; border-color: #334155; color: #e2e8f0; } .hsm-share-grid { display: flex; flex-direction: column; gap: 0.5rem; } .hsm-share-grid .btn { display: flex; align-items: center; justify-content: center; font-size: 0.9rem; padding: 0.6rem; border-color: var(--bs-border-color); width: 100%; } [data-bs-theme="dark"] .hsm-share-grid .btn { color: #e2e8f0; border-color: #475569; } [data-bs-theme="dark"] .hsm-share-grid .btn:hover { background: #334155; border-color: #cbd5e1; } </style> <script> (function(){ const modal = document.getElementById('headingShareModal'); if(!modal) return; const input = modal.querySelector('#headingShareInput'); const copyBtn = modal.querySelector('.hsm-copy'); const twitter = modal.querySelector('#share-twitter'); const linkedin = modal.querySelector('#share-linkedin'); const facebook = modal.querySelector('#share-facebook'); const closeBtn = modal.querySelector('.hsm-close'); let lastFocus=null; let trapBound=false; function buildUrl(id){ return window.location.origin + window.location.pathname + '#' + id; } function isOpen(){ return !modal.hasAttribute('hidden'); } function hydrate(id){ const url=buildUrl(id); input.value=url; const enc=encodeURIComponent(url); const text=encodeURIComponent(document.title); if(twitter) twitter.href=`https://twitter.com/intent/tweet?url=${enc}&text=${text}`; if(linkedin) linkedin.href=`https://www.linkedin.com/sharing/share-offsite/?url=${enc}`; if(facebook) facebook.href=`https://www.facebook.com/sharer/sharer.php?u=${enc}`; } function openModal(id){ lastFocus=document.activeElement; hydrate(id); if(!isOpen()){ modal.removeAttribute('hidden'); } requestAnimationFrame(()=>{ input.focus(); }); trapFocus(); } function closeModal(){ if(!isOpen()) return; modal.setAttribute('hidden',''); if(lastFocus && typeof lastFocus.focus==='function') lastFocus.focus(); } function copyCurrent(){ try{ navigator.clipboard.writeText(input.value).then(()=>feedback(true),()=>fallback()); } catch(e){ fallback(); } } function fallback(){ input.select(); try{ document.execCommand('copy'); feedback(true);}catch(e){ feedback(false);} } function feedback(ok){ if(!copyBtn) return; const icon=copyBtn.querySelector('i'); if(!icon) return; const prev=copyBtn.getAttribute('data-prev')||icon.className; if(!copyBtn.getAttribute('data-prev')) copyBtn.setAttribute('data-prev',prev); icon.className= ok ? 'fa-duotone fa-clipboard-check':'fa-duotone fa-circle-exclamation'; setTimeout(()=>{ icon.className=prev; },1800); } function handleShareClick(e){ e.preventDefault(); const btn=e.currentTarget; const id=btn.getAttribute('data-share-target'); if(id) openModal(id); } function bindShareButtons(){ document.querySelectorAll('.h-share').forEach(btn=>{ if(!btn.dataset.hShareBound){ btn.addEventListener('click', handleShareClick); btn.dataset.hShareBound='1'; } }); } bindShareButtons(); if(document.readyState==='loading'){ document.addEventListener('DOMContentLoaded', bindShareButtons); } else { requestAnimationFrame(bindShareButtons); } document.addEventListener('click', function(e){ const shareBtn=e.target.closest && e.target.closest('.h-share'); if(shareBtn && !shareBtn.dataset.hShareBound){ handleShareClick.call(shareBtn, e); } }, true); document.addEventListener('click', e=>{ if(e.target===modal) closeModal(); if(e.target.closest && e.target.closest('.hsm-close')){ e.preventDefault(); closeModal(); } if(copyBtn && (e.target===copyBtn || (e.target.closest && e.target.closest('.hsm-copy')))) { e.preventDefault(); copyCurrent(); } }); document.addEventListener('keydown', e=>{ if(e.key==='Escape' && isOpen()) closeModal(); }); function trapFocus(){ if(trapBound) return; trapBound=true; modal.addEventListener('keydown', f=>{ if(f.key==='Tab' && isOpen()){ const focusable=[...modal.querySelectorAll('a[href],button,input,textarea,select,[tabindex]:not([tabindex="-1"])')].filter(el=>!el.hasAttribute('disabled')); if(!focusable.length) return; const first=focusable[0]; const last=focusable[focusable.length-1]; if(f.shiftKey && document.activeElement===first){ f.preventDefault(); last.focus(); } else if(!f.shiftKey && document.activeElement===last){ f.preventDefault(); first.focus(); } } }); } if(closeBtn) closeBtn.addEventListener('click', e=>{ e.preventDefault(); closeModal(); }); })(); </script>Concurrency control manages simultaneous access to database resources, ensuring data consistency while maximizing throughput. Geode implements sophisticated concurrency mechanisms based on Multi-Version Concurrency Control (MVCC) and Serializable Snapshot Isolation (SSI), enabling high-performance concurrent operations without compromising ACID guarantees. <h3 id="introduction-to-database-concurrency" class="position-relative d-flex align-items-center group"> Introduction to Database Concurrency <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="introduction-to-database-concurrency" aria-haspopup="dialog" aria-label="Share link: Introduction to Database Concurrency"> Share link </button> </h3>When multiple clients access a database simultaneously, conflicts can arise: <ul> <li>Read-Write Conflicts: One transaction reads data while another modifies it</li> <li>Write-Write Conflicts: Two transactions modify the same data concurrently</li> <li>Phantom Reads: Query results change due to concurrent inserts/deletes</li> <li>Lost Updates: One transaction’s changes overwrite another’s</li> </ul> Traditional locking approaches (pessimistic concurrency) prevent conflicts by blocking operations, but reduce throughput. Modern databases like Geode use optimistic approaches that allow conflicts but detect and resolve them, providing both consistency and performance. <h3 id="geodes-concurrency-architecture" class="position-relative d-flex align-items-center group"> Geode&rsquo;s Concurrency Architecture <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="geodes-concurrency-architecture" aria-haspopup="dialog" aria-label="Share link: Geodes Concurrency Architecture"> Share link </button> </h3> <h4 id="multi-version-concurrency-control-mvcc" class="position-relative d-flex align-items-center group"> Multi-Version Concurrency Control (MVCC) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="multi-version-concurrency-control-mvcc" aria-haspopup="dialog" aria-label="Share link: Multi-Version Concurrency Control (MVCC)"> Share link </button> </h4>MVCC maintains multiple versions of data, allowing readers and writers to proceed without blocking each other: How it works: <ol> <li>Each transaction sees a consistent snapshot of the database</li> <li>Writes create new versions rather than modifying existing data</li> <li>Readers access appropriate versions based on transaction start time</li> <li>Old versions are garbage collected when no longer needed</li> </ol> Benefits: <ul> <li>Readers never block writers (and vice versa)</li> <li>Consistent reads without locks</li> <li>High throughput for read-heavy workloads</li> <li>Point-in-time queries possible</li> </ul> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Transaction 1 starts BEGIN TRANSACTION; MATCH (u:User {id: 123}) RETURN u.balance; -- Returns $100 -- Transaction 2 (concurrent) modifies the same user -- Transaction 1 still sees $100 (snapshot isolation) -- Transaction 1 continues with consistent view MATCH (u:User {id: 123}) SET u.last_accessed = timestamp(); COMMIT; </code></pre></div> <h4 id="serializable-snapshot-isolation-ssi" class="position-relative d-flex align-items-center group"> Serializable Snapshot Isolation (SSI) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="serializable-snapshot-isolation-ssi" aria-haspopup="dialog" aria-label="Share link: Serializable Snapshot Isolation (SSI)"> Share link </button> </h4>SSI prevents anomalies that can occur with basic snapshot isolation: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Example: Preventing write skew -- Two users try to book the last seat -- Transaction 1 BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; MATCH (seat:Seat {id: 42}) WHERE NOT EXISTS { MATCH (seat)<-[:BOOKED]-() } CREATE (user1:User {id: 1})-[:BOOKED]->(seat); COMMIT; -- Succeeds -- Transaction 2 (concurrent) BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; MATCH (seat:Seat {id: 42}) WHERE NOT EXISTS { MATCH (seat)<-[:BOOKED]-() } CREATE (user2:User {id: 2})-[:BOOKED]->(seat); COMMIT; -- Fails with serialization error </code></pre></div>SSI detection mechanisms: <ul> <li>Read-Write conflict detection: Tracks dependencies between transactions</li> <li>Write-Write conflict detection: Identifies concurrent modifications</li> <li>Automatic retry: Failed transactions can be retried automatically</li> </ul> <h3 id="isolation-levels" class="position-relative d-flex align-items-center group"> Isolation Levels <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="isolation-levels" aria-haspopup="dialog" aria-label="Share link: Isolation Levels"> Share link </button> </h3>Geode supports multiple isolation levels, trading off between consistency and performance: <h4 id="read-uncommitted-rarely-used" class="position-relative d-flex align-items-center group"> Read Uncommitted (Rarely Used) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="read-uncommitted-rarely-used" aria-haspopup="dialog" aria-label="Share link: Read Uncommitted (Rarely Used)"> Share link </button> </h4>Behavior: Can see uncommitted changes from other transactions Use case: Approximate queries where accuracy isn’t critical <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; -- May see intermediate states MATCH (p:Product) RETURN avg(p.price); COMMIT; </code></pre></div> <h4 id="read-committed-default-for-many-operations" class="position-relative d-flex align-items-center group"> Read Committed (Default for Many Operations) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="read-committed-default-for-many-operations" aria-haspopup="dialog" aria-label="Share link: Read Committed (Default for Many Operations)"> Share link </button> </h4>Behavior: Sees only committed data, but may observe changes during transaction Use case: Most OLTP workloads <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED; MATCH (u:User {id: $id}) RETURN u; -- Sees committed state at query time -- Another transaction commits changes to same user MATCH (u:User {id: $id}) RETURN u; -- May see different data COMMIT; </code></pre></div> <h4 id="repeatable-read" class="position-relative d-flex align-items-center group"> Repeatable Read <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="repeatable-read" aria-haspopup="dialog" aria-label="Share link: Repeatable Read"> Share link </button> </h4>Behavior: Consistent snapshot throughout transaction Use case: Reports, analytics requiring consistent view <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; MATCH (u:User {id: $id}) RETURN u; -- Snapshot at transaction start -- Other transactions modify data MATCH (u:User {id: $id}) RETURN u; -- Same result as first query COMMIT; </code></pre></div> <h4 id="serializable-strongest" class="position-relative d-flex align-items-center group"> Serializable (Strongest) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="serializable-strongest" aria-haspopup="dialog" aria-label="Share link: Serializable (Strongest)"> Share link </button> </h4>Behavior: Transactions appear to execute serially Use case: Critical operations requiring absolute consistency <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; -- All operations see consistent snapshot -- Write conflicts detected and transaction may abort COMMIT; </code></pre></div> <h3 id="concurrency-patterns-and-best-practices" class="position-relative d-flex align-items-center group"> Concurrency Patterns and Best Practices <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="concurrency-patterns-and-best-practices" aria-haspopup="dialog" aria-label="Share link: Concurrency Patterns and Best Practices"> Share link </button> </h3> <h4 id="pattern-1-optimistic-locking-with-version-numbers" class="position-relative d-flex align-items-center group"> Pattern 1: Optimistic Locking with Version Numbers <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="pattern-1-optimistic-locking-with-version-numbers" aria-haspopup="dialog" aria-label="Share link: Pattern 1: Optimistic Locking with Version Numbers"> Share link </button> </h4>Detect concurrent modifications using version fields: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Read with version MATCH (account:Account {id: $account_id}) RETURN account.balance, account.version; -- Returns: balance=100, version=5 -- Update with version check MATCH (account:Account {id: $account_id}) WHERE account.version = $expected_version -- Check version hasn't changed SET account.balance = $new_balance, account.version = $expected_version + 1 RETURN account; -- Fails if another transaction modified account (version changed) </code></pre></div>Python implementation: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from geode_client import Client, ConcurrentModificationError async def update_account_balance(account_id, amount): client = Client(host="localhost", port=3141) async with client.connection() as conn: while True: # Retry loop # Read current state result, _ = await conn.query(""" MATCH (a:Account {id: $id}) RETURN a.balance AS balance, a.version AS version """, {"id": account_id}) current_balance = result.bindings[0]['balance'] current_version = result.bindings[0]['version'] # Attempt update with version check try: await conn.execute(""" MATCH (a:Account {id: $id}) WHERE a.version = $version SET a.balance = $new_balance, a.version = $version + 1 """, { "id": account_id, "version": current_version, "new_balance": current_balance + amount }) break # Success except ConcurrentModificationError: # Another transaction modified it, retry await asyncio.sleep(0.01) # Brief backoff </code></pre></div> <h4 id="pattern-2-atomic-operations" class="position-relative d-flex align-items-center group"> Pattern 2: Atomic Operations <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="pattern-2-atomic-operations" aria-haspopup="dialog" aria-label="Share link: Pattern 2: Atomic Operations"> Share link </button> </h4>Use atomic modifications to avoid read-modify-write races: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- WRONG: Read-modify-write (not atomic) MATCH (counter:Counter {name: 'page_views'}) WITH counter.value AS current MATCH (counter:Counter {name: 'page_views'}) SET counter.value = current + 1; -- Race condition! -- RIGHT: Atomic increment MATCH (counter:Counter {name: 'page_views'}) SET counter.value = counter.value + 1; -- Atomic operation </code></pre></div> <h4 id="pattern-3-batch-processing-with-transactions" class="position-relative d-flex align-items-center group"> Pattern 3: Batch Processing with Transactions <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="pattern-3-batch-processing-with-transactions" aria-haspopup="dialog" aria-label="Share link: Pattern 3: Batch Processing with Transactions"> Share link </button> </h4>Group operations to reduce transaction overhead: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">async def process_orders_batch(orders): client = Client(host="localhost", port=3141) async with client.connection() as conn: # Isolation is configured server-side await conn.begin() try: for order in orders: await conn.execute( """ MATCH (p:Product {id: $product_id}) WHERE p.stock >= $quantity SET p.stock = p.stock - $quantity CREATE (order:Order { id: $order_id, product_id: $product_id, quantity: $quantity, timestamp: timestamp() }) """, { "product_id": order.product_id, "quantity": order.quantity, "order_id": order.id, }, ) await conn.commit() except Exception: await conn.rollback() raise </code></pre></div> <h4 id="pattern-4-pessimistic-locking-when-necessary" class="position-relative d-flex align-items-center group"> Pattern 4: Pessimistic Locking When Necessary <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="pattern-4-pessimistic-locking-when-necessary" aria-haspopup="dialog" aria-label="Share link: Pattern 4: Pessimistic Locking When Necessary"> Share link </button> </h4>For critical sections requiring exclusive access: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Explicit locking (use sparingly) BEGIN TRANSACTION; MATCH (resource:Resource {id: $id}) SET resource.locked = true; -- Application-level lock -- Perform critical operations MATCH (resource:Resource {id: $id}) WHERE resource.locked = true SET resource.state = 'processing'; -- Release lock MATCH (resource:Resource {id: $id}) SET resource.locked = false; COMMIT; </code></pre></div> <h3 id="handling-deadlocks" class="position-relative d-flex align-items-center group"> Handling Deadlocks <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="handling-deadlocks" aria-haspopup="dialog" aria-label="Share link: Handling Deadlocks"> Share link </button> </h3>Deadlocks occur when transactions wait for each other circularly: Example scenario: <ul> <li>Transaction A locks Node 1, waits for Node 2</li> <li>Transaction B locks Node 2, waits for Node 1</li> <li>Neither can proceed (deadlock)</li> </ul> Geode’s deadlock prevention: <ol> <li>Timeout-based detection: Transactions timeout after configurable period</li> <li>Automatic rollback: One transaction is chosen as victim and rolled back</li> <li>Retry hints: Client receives error indicating retry-able failure</li> </ol> <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from geode_client import QueryError async def transfer_funds_with_retry(from_account, to_account, amount, max_retries=3): for attempt in range(max_retries): try: client = Client(host="localhost", port=3141) async with client.connection() as conn: # Isolation is configured server-side await conn.begin() try: # Debit from account await conn.execute( """ MATCH (a:Account {id: $id}) WHERE a.balance >= $amount SET a.balance = a.balance - $amount """, {"id": from_account, "amount": amount}, ) # Credit to account await conn.execute( """ MATCH (a:Account {id: $id}) SET a.balance = a.balance + $amount """, {"id": to_account, "amount": amount}, ) await conn.commit() except QueryError: await conn.rollback() raise return # Success except QueryError as exc: if "DEADLOCK" not in str(exc): raise if attempt == max_retries - 1: raise # Final attempt failed await asyncio.sleep(0.1 * (attempt + 1)) # Exponential backoff </code></pre></div>Deadlock avoidance strategies: <ol> <li>Consistent ordering: Always access resources in same order</li> <li>Short transactions: Minimize lock hold time</li> <li>Coarse-grained locking: Lock at higher level to reduce conflicts</li> <li>Retry logic: Implement exponential backoff</li> </ol> <h3 id="connection-pool-management" class="position-relative d-flex align-items-center group"> Connection Pool Management <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="connection-pool-management" aria-haspopup="dialog" aria-label="Share link: Connection Pool Management"> Share link </button> </h3>Connection pooling critical for concurrent access patterns: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from geode_client import ConnectionPool # Configure pool for high concurrency pool = ConnectionPool( host="localhost", port=3141, min_connections=10, # Always maintain 10 connections max_connections=100, # Scale up to 100 under load max_idle_time=300, # Close idle connections after 5 minutes connection_timeout=10, # Fail fast if pool exhausted retry_on_timeout=True # Retry if connection temporarily unavailable ) # Concurrent query execution async def concurrent_queries(user_ids): tasks = [] for user_id in user_ids: tasks.append(query_user(user_id)) # Execute concurrently (pool manages connection allocation) results = await asyncio.gather(*tasks) return results async def query_user(user_id): async with pool.acquire() as client: result, _ = await client.query(""" MATCH (u:User {id: $id}) RETURN u """, {"id": user_id}) return result.bindings[0] </code></pre></div> <h3 id="performance-considerations" class="position-relative d-flex align-items-center group"> Performance Considerations <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="performance-considerations" aria-haspopup="dialog" aria-label="Share link: Performance Considerations"> Share link </button> </h3> <h4 id="read-heavy-workloads" class="position-relative d-flex align-items-center group"> Read-Heavy Workloads <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="read-heavy-workloads" aria-haspopup="dialog" aria-label="Share link: Read-Heavy Workloads"> Share link </button> </h4>MVCC excels for read-heavy patterns: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Efficient concurrent reads (no locking) async def analytics_query(): client = Client(host="localhost", port=3141) async with client.connection() as conn: # Large analytical query doesn't block writes result, _ = await conn.query(""" MATCH (u:User)-[:PURCHASED]->(p:Product) RETURN p.category, count(u) AS buyers ORDER BY buyers DESC """) return result.bindings # Concurrent writes continue unblocked async def record_purchase(user_id, product_id): client = Client(host="localhost", port=3141) async with client.connection() as conn: await conn.execute(""" MATCH (u:User {id: $user_id}), (p:Product {id: $product_id}) CREATE (u)-[:PURCHASED {timestamp: timestamp()}]->(p) """, {"user_id": user_id, "product_id": product_id}) </code></pre></div> <h4 id="write-heavy-workloads" class="position-relative d-flex align-items-center group"> Write-Heavy Workloads <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="write-heavy-workloads" aria-haspopup="dialog" aria-label="Share link: Write-Heavy Workloads"> Share link </button> </h4>For write-heavy scenarios, minimize contention: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># GOOD: Partition writes to reduce conflicts async def record_page_view(page_id, user_id): # Use time-based partitioning partition_key = f"{page_id}_{datetime.now().hour}" client = Client(host="localhost", port=3141) async with client.connection() as conn: await conn.execute(""" MERGE (counter:PageViewCounter {key: $key}) ON CREATE SET counter.views = 1 ON MATCH SET counter.views = counter.views + 1 """, {"key": partition_key}) # BAD: Single hot counter (high contention) async def record_page_view_bad(page_id): client = Client(host="localhost", port=3141) async with client.connection() as conn: await conn.execute(""" MATCH (page:Page {id: $id}) SET page.view_count = page.view_count + 1 """, {"id": page_id}) </code></pre></div> <h3 id="troubleshooting-concurrency-issues" class="position-relative d-flex align-items-center group"> Troubleshooting Concurrency Issues <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="troubleshooting-concurrency-issues" aria-haspopup="dialog" aria-label="Share link: Troubleshooting Concurrency Issues"> Share link </button> </h3> <h4 id="symptom-high-transaction-abort-rate" class="position-relative d-flex align-items-center group"> Symptom: High Transaction Abort Rate <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="symptom-high-transaction-abort-rate" aria-haspopup="dialog" aria-label="Share link: Symptom: High Transaction Abort Rate"> Share link </button> </h4>Diagnosis: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Check transaction statistics SHOW STATUS LIKE 'transaction_%'; -- Look for: transaction_aborts, transaction_conflicts </code></pre></div>Solutions: <ol> <li>Lower isolation level if consistency requirements permit</li> <li>Reduce transaction scope (fewer operations per transaction)</li> <li>Implement retry logic with exponential backoff</li> <li>Redesign schema to reduce hot spots</li> </ol> <h4 id="symptom-slow-query-performance-under-load" class="position-relative d-flex align-items-center group"> Symptom: Slow Query Performance Under Load <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="symptom-slow-query-performance-under-load" aria-haspopup="dialog" aria-label="Share link: Symptom: Slow Query Performance Under Load"> Share link </button> </h4>Diagnosis: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Monitor connection pool metrics print(f"Active connections: {pool.active_connections}") print(f"Idle connections: {pool.idle_connections}") print(f"Wait time: {pool.average_wait_time}ms") </code></pre></div>Solutions: <ol> <li>Increase connection pool size</li> <li>Optimize queries to reduce execution time</li> <li>Add read replicas for read-heavy workloads</li> <li>Implement caching for frequently accessed data</li> </ol> <h4 id="symptom-deadlock-errors" class="position-relative d-flex align-items-center group"> Symptom: Deadlock Errors <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="symptom-deadlock-errors" aria-haspopup="dialog" aria-label="Share link: Symptom: Deadlock Errors"> Share link </button> </h4>Diagnosis: Check error logs for deadlock cycles Solutions: <ol> <li>Ensure consistent resource access ordering</li> <li>Break long transactions into smaller ones</li> <li>Add retry logic with backoff</li> <li>Consider application-level coordination</li> </ol> <h3 id="related-topics" class="position-relative d-flex align-items-center group"> Related Topics <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="related-topics" aria-haspopup="dialog" aria-label="Share link: Related Topics"> Share link </button> </h3><ul> <li><a href="/tags/mvcc/" >MVCC</a> : Multi-Version Concurrency Control details</li> <li><a href="/tags/ssi/" >SSI</a> : Serializable Snapshot Isolation deep dive</li> <li><a href="/tags/transactions/" >Transactions</a> : Transaction management</li> <li><a href="/tags/isolation/" >Isolation</a> : Isolation levels explained</li> <li><a href="/tags/performance/" >Performance</a> : Performance optimization</li> <li><a href="/tags/connections/" >Connections</a> : Connection management</li> </ul> <h3 id="advanced-concurrency-techniques" class="position-relative d-flex align-items-center group"> Advanced Concurrency Techniques <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="advanced-concurrency-techniques" aria-haspopup="dialog" aria-label="Share link: Advanced Concurrency Techniques"> Share link </button> </h3> <h4 id="lock-free-data-structures" class="position-relative d-flex align-items-center group"> Lock-Free Data Structures <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="lock-free-data-structures" aria-haspopup="dialog" aria-label="Share link: Lock-Free Data Structures"> Share link </button> </h4>Geode uses lock-free algorithms internally for maximum concurrency: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-fallback" data-lang="fallback">Compare-and-Swap (CAS) Operations: 1. Read current value 2. Compute new value 3. Atomically update if value unchanged 4. Retry if value changed (optimistic) Example: Lock-free counter increment do { old_value = counter.read() new_value = old_value + 1 } while (!counter.compare_and_swap(old_value, new_value)) </code></pre></div>Benefits: <ul> <li>No thread blocking</li> <li>Progress guarantee (wait-free or lock-free)</li> <li>Better CPU cache utilization</li> <li>Higher throughput under contention</li> </ul> <h4 id="multi-version-read-consistency" class="position-relative d-flex align-items-center group"> Multi-Version Read Consistency <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="multi-version-read-consistency" aria-haspopup="dialog" aria-label="Share link: Multi-Version Read Consistency"> Share link </button> </h4>MVCC provides snapshot isolation by maintaining version chains: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-fallback" data-lang="fallback">Node ID: 123 Version Chain: [v5] name='Alice' age=35 txn=550 valid_from=LSN_550 valid_to=∞ [v4] name='Alice' age=34 txn=510 valid_from=LSN_510 valid_to=LSN_550 [v3] name='Alice' age=33 txn=480 valid_from=LSN_480 valid_to=LSN_510 [v2] name='Alice' age=32 txn=450 valid_from=LSN_450 valid_to=LSN_480 [v1] name='Alice' age=30 txn=420 valid_from=LSN_420 valid_to=LSN_450 Transaction at LSN_500 sees version v3 (age=33) Transaction at LSN_540 sees version v4 (age=34) </code></pre></div>Garbage collection removes old versions when no transactions need them. <h4 id="write-skew-prevention" class="position-relative d-flex align-items-center group"> Write Skew Prevention <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="write-skew-prevention" aria-haspopup="dialog" aria-label="Share link: Write Skew Prevention"> Share link </button> </h4>Serializable isolation prevents write skew anomalies: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Classic write skew example: on-call doctors async def assign_on_call_shift(client, doctor_id): async with client.connection() as conn: # Isolation is configured server-side await conn.begin() try: # Check if at least one doctor will remain on call result, _ = await conn.query( """ MATCH (d:Doctor {on_call: true}) WHERE d.id != $doctor_id RETURN COUNT(d) AS on_call_count """, {"doctor_id": doctor_id}, ) on_call_count = result.rows[0]["on_call_count"].as_int if result.rows else 0 if on_call_count >= 1: # Safe to go off call await conn.execute( """ MATCH (d:Doctor {id: $doctor_id}) SET d.on_call = false """, {"doctor_id": doctor_id}, ) await conn.commit() else: await conn.rollback() raise Exception("Cannot go off call - no other doctors available") except Exception: await conn.rollback() raise # Without SERIALIZABLE, two doctors could simultaneously check and both go off call # With SERIALIZABLE, one transaction aborts with serialization error </code></pre></div> <h4 id="timestamp-ordering" class="position-relative d-flex align-items-center group"> Timestamp Ordering <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="timestamp-ordering" aria-haspopup="dialog" aria-label="Share link: Timestamp Ordering"> Share link </button> </h4>Geode uses hybrid logical clocks for timestamp ordering: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-fallback" data-lang="fallback">Hybrid Logical Clock (HLC): physical_time: System wall clock (64-bit microseconds) logical_counter: Incrementing counter for same physical time Transaction Ordering: T1: HLC = (1706097600000000, 0) T2: HLC = (1706097600000000, 1) # Same physical time, later logical T3: HLC = (1706097600000001, 0) # Later physical time Total Order: T1 < T2 < T3 </code></pre></div>This provides: <ul> <li>Global transaction ordering</li> <li>Causality tracking</li> <li>Clock skew tolerance</li> </ul> <h3 id="real-world-concurrency-patterns" class="position-relative d-flex align-items-center group"> Real-World Concurrency Patterns <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-world-concurrency-patterns" aria-haspopup="dialog" aria-label="Share link: Real-World Concurrency Patterns"> Share link </button> </h3> <h4 id="high-frequency-trading-system" class="position-relative d-flex align-items-center group"> High-Frequency Trading System <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="high-frequency-trading-system" aria-haspopup="dialog" aria-label="Share link: High-Frequency Trading System"> Share link </button> </h4><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Process market data updates with high concurrency from geode_client import ConnectionPool, QueryError import asyncio import random pool = ConnectionPool( host="localhost", port=3141, min_size=50, max_size=200, ) async def update_order_book(symbol, price, quantity): """Update order book with optimistic concurrency""" max_retries = 10 for attempt in range(max_retries): try: async with pool.acquire() as conn: # Isolation is configured server-side await conn.begin() try: # Read current order book version result, _ = await conn.query( """ MATCH (book:OrderBook {symbol: $symbol}) RETURN book.version AS version, book.bids AS bids, book.asks AS asks """, {"symbol": symbol}, ) current = result.rows[0] if result.rows else None if not current: await conn.rollback() return # Update order book (business logic) updated_bids, updated_asks = merge_order( current["bids"].as_array, current["asks"].as_array, price, quantity, ) # Write with version check await conn.execute( """ MATCH (book:OrderBook {symbol: $symbol}) WHERE book.version = $version SET book.bids = $bids, book.asks = $asks, book.version = $version + 1, book.last_update = timestamp() """, { "symbol": symbol, "version": current["version"].as_int, "bids": updated_bids, "asks": updated_asks, }, ) await conn.commit() return # Success except Exception: await conn.rollback() raise except QueryError as exc: if "SERIALIZATION" not in str(exc): raise if attempt == max_retries - 1: raise # Exponential backoff with jitter await asyncio.sleep(0.001 * (2 ** attempt) * (0.5 + random.random())) # Run hundreds of concurrent updates async def main(): tasks = [] for _ in range(1000): symbol = random.choice(['AAPL', 'GOOGL', 'MSFT']) price = random.uniform(100, 200) quantity = random.randint(1, 100) tasks.append(update_order_book(symbol, price, quantity)) await asyncio.gather(*tasks) # All updates complete with correct concurrency control </code></pre></div> <h4 id="social-media-feed-generation" class="position-relative d-flex align-items-center group"> Social Media Feed Generation <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="social-media-feed-generation" aria-haspopup="dialog" aria-label="Share link: Social Media Feed Generation"> Share link </button> </h4><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Generate personalized feeds with concurrent reads async def generate_user_feed(user_id, limit=50): """Generate feed by reading from multiple sources concurrently""" async with pool.acquire() as conn: # Isolation is configured server-side await conn.begin() try: # Posts from followed users following_posts, _ = await conn.query( """ MATCH (u:User {id: $user_id})-[:FOLLOWS]->(f:User) MATCH (f)-[:POSTED]->(p:Post) WHERE p.created_at > datetime().minusDays(7) RETURN p ORDER BY p.created_at DESC LIMIT 30 """, {"user_id": user_id}, ) # Trending posts trending, _ = await conn.query( """ MATCH (p:Post) WHERE p.created_at > datetime().minusHours(24) RETURN p ORDER BY p.engagement_score DESC LIMIT 10 """ ) # Targeted ads ads, _ = await conn.query( """ MATCH (u:User {id: $user_id})-[:INTERESTED_IN]->(i:Interest) MATCH (a:Ad)-[:TARGETS]->(i) WHERE NOT (u)-[:DISMISSED]->(a) RETURN a LIMIT 5 """, {"user_id": user_id}, ) await conn.commit() except Exception: await conn.rollback() raise # Merge and rank results (all from consistent snapshot) feed = merge_feed_items( following_posts.rows, trending.rows, ads.rows, ) return feed[:limit] </code></pre></div> <h4 id="inventory-management-with-reservations" class="position-relative d-flex align-items-center group"> Inventory Management with Reservations <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="inventory-management-with-reservations" aria-haspopup="dialog" aria-label="Share link: Inventory Management with Reservations"> Share link </button> </h4><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Handle concurrent product reservations async def reserve_inventory(product_id, quantity, order_id): """Reserve inventory with pessimistic locking for critical section""" async with pool.acquire() as conn: # Isolation is configured server-side await conn.begin() try: # Lock product row for update result, _ = await conn.query( """ MATCH (p:Product {id: $product_id}) WHERE p.available_quantity >= $quantity RETURN p.available_quantity AS available """, {"product_id": product_id, "quantity": quantity}, ) if not result.rows: raise InsufficientInventoryError("Not enough inventory") # Create reservation await conn.execute( """ MATCH (p:Product {id: $product_id}) SET p.available_quantity = p.available_quantity - $quantity CREATE (r:Reservation { id: $order_id, product_id: $product_id, quantity: $quantity, reserved_at: timestamp(), expires_at: timestamp().plusMinutes(15) }) CREATE (p)-[:HAS_RESERVATION]->(r) """, { "product_id": product_id, "quantity": quantity, "order_id": order_id, }, ) await conn.commit() except Exception: await conn.rollback() raise # Background task to release expired reservations async def release_expired_reservations(): """Periodic cleanup of expired reservations""" while True: async with pool.acquire() as conn: await conn.execute( """ MATCH (p:Product)-[rel:HAS_RESERVATION]->(r:Reservation) WHERE r.expires_at < timestamp() SET p.available_quantity = p.available_quantity + r.quantity DELETE rel, r """ ) await asyncio.sleep(60) # Check every minute </code></pre></div> <h3 id="concurrency-benchmarking" class="position-relative d-flex align-items-center group"> Concurrency Benchmarking <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="concurrency-benchmarking" aria-haspopup="dialog" aria-label="Share link: Concurrency Benchmarking"> Share link </button> </h3> <h4 id="load-testing-framework" class="position-relative d-flex align-items-center group"> Load Testing Framework <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="load-testing-framework" aria-haspopup="dialog" aria-label="Share link: Load Testing Framework"> Share link </button> </h4><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">import asyncio import time from statistics import mean, stdev class ConcurrencyBenchmark: def __init__(self, pool, test_duration=60): self.pool = pool self.test_duration = test_duration self.latencies = [] self.errors = 0 self.successes = 0 async def worker(self, worker_id): """Individual worker executing queries""" start_time = time.time() while time.time() - start_time < self.test_duration: query_start = time.time() try: async with self.pool.acquire() as client: # Execute test query await client.execute(""" MATCH (u:User) WHERE u.id = $id RETURN u """, {"id": worker_id % 10000}) latency = (time.time() - query_start) * 1000 # ms self.latencies.append(latency) self.successes += 1 except Exception as e: self.errors += 1 async def run(self, concurrency_level): """Run benchmark with specified concurrency""" print(f"Running benchmark: {concurrency_level} concurrent workers") workers = [self.worker(i) for i in range(concurrency_level)] await asyncio.gather(*workers) # Calculate statistics total_queries = self.successes + self.errors qps = total_queries / self.test_duration avg_latency = mean(self.latencies) p95_latency = sorted(self.latencies)[int(len(self.latencies) * 0.95)] p99_latency = sorted(self.latencies)[int(len(self.latencies) * 0.99)] print(f""" Benchmark Results: Total Queries: {total_queries} Successes: {self.successes} Errors: {self.errors} QPS: {qps:.2f} Avg Latency: {avg_latency:.2f}ms P95 Latency: {p95_latency:.2f}ms P99 Latency: {p99_latency:.2f}ms """) # Run benchmarks at various concurrency levels async def main(): pool = ConnectionPool("localhost", 3141, max_connections=500) for concurrency in [10, 50, 100, 200, 500]: benchmark = ConcurrencyBenchmark(pool) await benchmark.run(concurrency) </code></pre></div> <h4 id="results-interpretation" class="position-relative d-flex align-items-center group"> Results Interpretation <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="results-interpretation" aria-haspopup="dialog" aria-label="Share link: Results Interpretation"> Share link </button> </h4>Use the benchmark output to identify scaling behavior: <ul> <li>Look for near-linear scaling as concurrency increases until saturation.</li> <li>Expect throughput to plateau once CPU or I/O becomes the bottleneck.</li> <li>Track p95/p99 latency; rising tail latency signals saturation.</li> <li>Tune pool sizes and worker counts based on your hardware and workload.</li> </ul> <h3 id="further-reading" class="position-relative d-flex align-items-center group"> Further Reading <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="further-reading" aria-haspopup="dialog" aria-label="Share link: Further Reading"> Share link </button> </h3><ul> <li>Concurrency Control Guide: <code>/docs/core-concepts/concurrency-control/</code></li> <li>Transaction Isolation: <code>/docs/transactions/isolation-levels/</code></li> <li>MVCC Implementation: <code>/docs/architecture/mvcc/</code></li> <li>Deadlock Prevention: <code>/docs/troubleshooting/deadlocks/</code></li> <li>Connection Pooling: <code>/docs/client-libraries/connection-pooling/</code></li> <li>Lock-Free Programming: <a href="http://www.1024cores.net/home/lock-free-algorithms" aria-label="1024cores.net – opens in new window" target="_blank" rel="noopener noreferrer" >1024cores.net ↗ </a> </li> <li>Transaction Processing: <a href="http://jimgray.azurewebsites.net/papers/thetransactionconcept.pdf" aria-label="Gray &amp; Reuter – opens in new window" target="_blank" rel="noopener noreferrer" >Gray & Reuter ↗ </a> </li> </ul>

Popular

Related Articles

Transaction Management Guide

Transactions