İşlem Performansıyla İlgili Hususlar

Multi-document transactions in MongoDB provide powerful ACID guarantees but come with measurable performance overhead. They involve additional network round-trips for session management, hold locks that block concurrent writers, consume oplog space, and require coordination across replica set members for the majority write concern. Understanding this overhead helps you design systems that use transactions only where necessary.

MongoDB transactions use document-level locking with optimistic concurrency control. When a transaction reads a document, it takes a snapshot but does not lock it. At commit time, MongoDB checks if any other writer modified those documents—if so, the transaction aborts with a write conflict. Frequent conflicts indicate that multiple transactions are competing for the same hot documents, causing retries and degraded throughput.

Transactions read from a consistent snapshot taken at transaction start time. As other writers commit during your transaction's lifetime, MongoDB must maintain old versions of modified documents (through the WiredTiger MVCC mechanism) so your transaction can still see the snapshot. Long-running transactions cause WiredTiger to hold more version history in memory and on disk, potentially triggering cache pressure that slows down the entire cluster.

MongoDB aborts transactions that exceed 60 seconds (configurable, but rarely should be increased). A transaction that runs for minutes holds snapshot data and prevents the oplog from being truncated. This is why long-running operations like batch processing, complex aggregations, or waiting for external API responses must never be inside a transaction. Keep transactions to milliseconds, not seconds.

Each write in a transaction is recorded in the oplog. MongoDB limits the total oplog space a single transaction can consume to approximately 16 MB. If your transaction involves a large number of documents or large documents, it can exceed this limit and abort with a TransactionTooLarge error. If you need to process large batches, break them into smaller transactions of a few hundred documents each.

The best performance optimization for transactions is to use fewer of them. MongoDB's single-document atomicity means that operations on one document are always ACID-compliant. Design your schema so that operations that must be atomic touch as few documents as possible. The most effective approach is embedding related data that is always updated together into a single document.

Use explain('executionStats') and the database profiler to measure the actual overhead of your transactions. Transactions appear in the slow query log and system.profile collection with their transaction field populated. Track metrics like average transaction duration, write conflict rate, and number of retries per transaction type. These metrics reveal whether transaction overhead is impacting your application's latency budget.

When you need to atomically check and modify a single document, findOneAndUpdate provides ACID atomicity without a transaction. It atomically finds a document matching a filter, applies an update, and returns either the old or new document in a single server-side operation. This is the preferred pattern for patterns like test-and-set, atomic counters, and claiming queue items.

Before MongoDB 4.0 introduced native transactions, developers implemented two-phase commit manually to achieve multi-document atomicity. In this pattern, a central 'transaction document' tracks the state of the operation (pending, applied, done, rollback). While native transactions are preferred today, understanding two-phase commit reveals why transaction overhead exists and helps in scenarios where transactions cannot be used (e.g., sharded clusters in older MongoDB versions).

Transactions default to readConcern: 'snapshot' which provides full isolation but may need to wait for the majority of replica set members to confirm they have received the latest data. readConcern: 'local' is faster but may read data that gets rolled back in a failover. For most application transactions, 'snapshot' is correct. Only use 'local' if you have carefully considered the consistency implications.

Five rules for high-performance transaction usage: (1) Keep transactions short—milliseconds not seconds. (2) Never perform I/O outside the database inside a transaction. (3) Minimize the number of documents touched per transaction to reduce conflict surface area. (4) Use single-document operations or embedding whenever possible to avoid transactions entirely. (5) Monitor write conflict rates and redesign hot documents if conflicts are frequent.

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

In this lesson you learned: transactions add overhead through snapshot isolation, lock contention, and oplog space consumption, keep transactions short (milliseconds) and never perform slow I/O inside them, and the best optimization is often to redesign schemas so that single-document atomicity eliminates the need for multi-document transactions. Next up we explore change streams for real-time event feeds from MongoDB collections.