# Unit 4

### **Unit 4: Distributed Transaction Processing - Complete Notes**

***

#### **1. Transactions**

**Definition:**

* A **transaction** is a sequence of operations performed as a single logical unit of work.
* It ensures that a system remains in a consistent state, even in the event of failures.

**ACID Properties:**

1. **Atomicity:**
   * All operations in a transaction are completed successfully, or none are.
   * Example: Money transfer between two accounts (both debit and credit must succeed).
2. **Consistency:**
   * A transaction brings the system from one valid state to another.
   * Example: Ensuring account balances are never negative.
3. **Isolation:**
   * Transactions are executed independently without interference.
   * Example: Two users transferring money from the same account simultaneously.
4. **Durability:**
   * Once a transaction is committed, its effects are permanent.
   * Example: After a successful transaction, the changes are saved even if the system crashes.

***

#### **Mind Map for Transactions:**

```
Transactions  
├── Definition  
│   └── Sequence of operations as a single unit  
├── ACID Properties  
│   ├── Atomicity (Example: Money transfer)  
│   ├── Consistency (Example: Valid account balances)  
│   ├── Isolation (Example: Concurrent transactions)  
│   └── Durability (Example: Permanent changes after commit)
```

***

#### **2. Nested Transactions**

**Definition:**

* A **nested transaction** is a transaction that contains other transactions (subtransactions).
* It allows for modular and hierarchical transaction management.

**How It Works:**

1. **Parent and Child Transactions:**
   * A parent transaction can have multiple child transactions.
   * Example: Booking a flight (parent) and reserving a seat (child).
2. **Commit and Rollback:**
   * If a child transaction fails, only that part is rolled back, not the entire parent transaction.
   * Example: If seat reservation fails, the flight booking can still proceed.

**Advantages:**

1. **Modularity:**
   * Breaks down complex transactions into smaller, manageable parts.
2. **Partial Rollback:**
   * Only the failed subtransaction is rolled back, reducing the impact of failures.

***

#### **Mind Map for Nested Transactions:**

```
Nested Transactions  
├── Definition  
│   └── Transactions within transactions  
├── How It Works  
│   ├── Parent and Child Transactions (Example: Flight booking)  
│   └── Commit and Rollback (Example: Seat reservation)  
└── Advantages  
    ├── Modularity  
    └── Partial Rollback
```

***

#### **3. Locks**

**Definition:**

* **Locks** are mechanisms used to control access to shared resources in a transaction.
* They ensure that only one transaction can access a resource at a time.

**Types of Locks:**

1. **Shared Lock (Read Lock):**
   * Multiple transactions can read a resource simultaneously.
   * Example: Multiple users reading a file.
2. **Exclusive Lock (Write Lock):**
   * Only one transaction can write to a resource at a time.
   * Example: A single user editing a file.

**Challenges:**

1. **Deadlocks:**
   * Two transactions waiting for each other to release locks.
   * Example: Transaction A locks Resource 1 and waits for Resource 2, while Transaction B locks Resource 2 and waits for Resource 1.
2. **Performance Overhead:**
   * Lock management can introduce latency.
   * Example: Delays in accessing heavily locked resources.

***

#### **Mind Map for Locks:**

```
Locks  
├── Definition  
│   └── Control access to shared resources  
├── Types  
│   ├── Shared Lock (Example: Reading a file)  
│   └── Exclusive Lock (Example: Editing a file)  
└── Challenges  
    ├── Deadlocks (Example: Circular waiting)  
    └── Performance Overhead (Example: Latency)
```

***

#### **4. Optimistic Concurrency Control**

**Definition:**

* **Optimistic Concurrency Control (OCC)** assumes that conflicts are rare and allows transactions to proceed without locking resources.
* Conflicts are detected and resolved at the end of the transaction.

**How It Works:**

1. **Read Phase:**
   * Transactions read data without locking.
2. **Validation Phase:**
   * Before committing, the system checks for conflicts.
3. **Write Phase:**
   * If no conflicts are found, the transaction is committed; otherwise, it is rolled back.

**Advantages:**

1. **High Concurrency:**
   * Transactions can proceed without waiting for locks.
   * Example: Collaborative editing tools like Google Docs.
2. **Low Overhead:**
   * No need to manage locks, reducing system overhead.

**Disadvantages:**

1. **Rollback Overhead:**
   * If conflicts are frequent, rollbacks can degrade performance.
   * Example: High-contention systems like stock trading platforms.

***

#### **Mind Map for Optimistic Concurrency Control:**

```
Optimistic Concurrency Control (OCC)  
├── Definition  
│   └── Assumes conflicts are rare  
├── How It Works  
│   ├── Read Phase  
│   ├── Validation Phase  
│   └── Write Phase  
├── Advantages  
│   ├── High Concurrency (Example: Google Docs)  
│   └── Low Overhead  
└── Disadvantages  
    └── Rollback Overhead (Example: Stock trading platforms)
```

***

#### **5. Timestamp Ordering**

**Definition:**

* **Timestamp Ordering** assigns a unique timestamp to each transaction and ensures that transactions are executed in timestamp order.

**How It Works:**

1. **Timestamp Assignment:**
   * Each transaction is assigned a timestamp when it starts.
2. **Conflict Resolution:**
   * If a transaction tries to access data modified by a newer transaction, it is rolled back.
   * Example: Transaction A (timestamp 1) tries to read data updated by Transaction B (timestamp 2).

**Advantages:**

1. **No Deadlocks:**
   * Timestamps ensure a strict order, preventing deadlocks.
2. **Simple Implementation:**
   * Easy to implement compared to locking mechanisms.

**Disadvantages:**

1. **Starvation:**
   * Older transactions may be repeatedly rolled back.
   * Example: A low-priority transaction constantly delayed by high-priority transactions.

***

#### **Mind Map for Timestamp Ordering:**

```
Timestamp Ordering  
├── Definition  
│   └── Transactions executed in timestamp order  
├── How It Works  
│   ├── Timestamp Assignment  
│   └── Conflict Resolution (Example: Rollback)  
├── Advantages  
│   ├── No Deadlocks  
│   └── Simple Implementation  
└── Disadvantages  
    └── Starvation (Example: Low-priority transactions)
```

***

#### **6. Flat vs. Nested Distributed Transactions**

**Flat Transactions:**

* A single-level transaction with no subtransactions.
* **Example:** Transferring money between two accounts.

**Nested Transactions:**

* A transaction containing subtransactions.
* **Example:** Booking a flight (parent) and reserving a seat (child).

**Comparison:**

| **Feature**    | **Flat Transactions**          | **Nested Transactions**                |
| -------------- | ------------------------------ | -------------------------------------- |
| **Structure**  | Single-level                   | Hierarchical (parent-child)            |
| **Complexity** | Simple                         | Complex                                |
| **Rollback**   | Entire transaction rolled back | Only failed subtransaction rolled back |
| **Use Case**   | Simple operations              | Complex, modular operations            |

***

#### **Mind Map for Flat vs. Nested Transactions:**

```
Flat vs. Nested Transactions  
├── Flat Transactions  
│   ├── Single-level  
│   └── Example: Money transfer  
├── Nested Transactions  
│   ├── Hierarchical  
│   └── Example: Flight booking  
└── Comparison  
    ├── Structure, Complexity, Rollback, Use Case
```

***

#### **7. Atomic Commit Protocols**

**Definition:**

* **Atomic Commit Protocols** ensure that a distributed transaction is either fully committed or fully rolled back across all nodes.

**Types:**

1. **Two-Phase Commit (2PC):**
   * A coordinator ensures all participants agree to commit or abort.
   * Example: Distributed databases like MySQL Cluster.
2. **Three-Phase Commit (3PC):**
   * Adds a pre-commit phase to reduce blocking in case of failures.
   * Example: High-availability systems like Google Spanner.

***

#### **Mind Map for Atomic Commit Protocols:**

```
Atomic Commit Protocols  
├── Two-Phase Commit (2PC)  
│   └── Example: MySQL Cluster  
└── Three-Phase Commit (3PC)  
    └── Example: Google Spanner
```

***

#### **8. Concurrency Control in Distributed Transactions**

**Definition:**

* **Concurrency Control** ensures that multiple transactions can execute simultaneously without causing inconsistencies.

**Techniques:**

1. **Lock-Based Protocols:**
   * Use locks to control access to resources.
   * Example: Shared and exclusive locks.
2. **Timestamp Ordering:**
   * Use timestamps to order transactions.
   * Example: Conflict resolution using timestamps.
3. **Optimistic Concurrency Control:**
   * Assume conflicts are rare and resolve them at commit time.
   * Example: Collaborative editing tools.

***

#### **Mind Map for Concurrency Control:**

```
Concurrency Control  
├── Lock-Based Protocols (Example: Shared/Exclusive locks)  
├── Timestamp Ordering (Example: Conflict resolution)  
└── Optimistic Concurrency Control (Example: Collaborative editing)
```

***

#### **9. Distributed Deadlocks**

**Definition:**

* **Distributed Deadlocks** occur when transactions in a distributed system are waiting for resources held by each other.

**Detection and Prevention:**

1. **Detection Algorithms:**
   * Detect deadlocks by analyzing wait-for graphs.
   * Example: Chandy-Misra-Haas algorithm.
2. **Prevention Techniques:**
   * Avoid deadlocks by resource allocation strategies.
   * Example: Timeout-based resource allocation.

***

#### **Mind Map for Distributed Deadlocks:**

```
Distributed Deadlocks  
├── Detection (Example: Chandy-Misra-Haas algorithm)  
└── Prevention (Example: Timeout-based allocation)
```

***

#### **10. Transaction Recovery**

**Definition:**

* **Transaction Recovery** ensures that a system can recover from failures and maintain data consistency.

**Techniques:**

1. **Log-Based Recovery:**
   * Maintain a log of all transactions to replay or undo operations.
   * Example: Database systems like Oracle.
2. **Checkpointing:**
   * Periodically save the system state to reduce recovery time.
   * Example: File systems like NTFS.

***

#### **Mind Map for Transaction Recovery:**

```
Transaction Recovery  
├── Log-Based Recovery (Example: Oracle databases)  
└── Checkpointing (Example: NTFS file system)
```

***

#### **11. Overview of Replication and Distributed Multimedia Systems**

**Replication:**

* **Definition:** Creating multiple copies of data across nodes for fault tolerance and performance.
* **Example:** Replicating databases in a distributed system.

**Distributed Multimedia Systems:**

* **Definition:** Systems that handle multimedia data (e.g., video, audio) across distributed nodes.
* **Example:** Streaming platforms like Netflix or YouTube.

***

#### **Mind Map for Replication and Multimedia Systems:**

```
Replication and Multimedia Systems  
├── Replication  
│   └── Example: Distributed databases  
└── Distributed Multimedia Systems  
    └── Example: Netflix, YouTube
```

***

#### **Summary of Unit 4: Distributed Transaction Processing**

* **Transactions** ensure ACID properties (Atomicity, Consistency, Isolation, Durability).
* **Nested Transactions** allow modular and hierarchical transaction management.
* **Locks** and **Optimistic Concurrency Control** manage access to shared resources.
* **Timestamp Ordering** ensures transactions are executed in a strict order.
* **Atomic Commit Protocols** (2PC, 3PC) ensure distributed transactions are committed or rolled back atomically.
* **Concurrency Control** and **Deadlock Handling** maintain system consistency.
* **Transaction Recovery** ensures system resilience to failures.
* **Replication** and **Distributed Multimedia Systems** handle data redundancy and multimedia processing.

***

#### **Final Mind Map for Unit 4:**

```
Unit 4: Distributed Transaction Processing  
├── Transactions  
│   ├── ACID Properties (Atomicity, Consistency, Isolation, Durability)  
├── Nested Transactions  
│   ├── Parent and Child Transactions  
│   └── Partial Rollback  
├── Locks  
│   ├── Shared Lock, Exclusive Lock  
│   └── Deadlocks, Performance Overhead  
├── Optimistic Concurrency Control  
│   ├── Read, Validation, Write Phases  
│   └── High Concurrency, Rollback Overhead  
├── Timestamp Ordering  
│   ├── Timestamp Assignment, Conflict Resolution  
│   └── No Deadlocks, Starvation  
├── Flat vs. Nested Transactions  
│   ├── Structure, Complexity, Rollback, Use Case  
├── Atomic Commit Protocols  
│   ├── Two-Phase Commit (2PC), Three-Phase Commit (3PC)  
├── Concurrency Control  
│   ├── Lock-Based, Timestamp Ordering, Optimistic Control  
├── Distributed Deadlocks  
│   ├── Detection (Chandy-Misra-Haas), Prevention (Timeout-based)  
├── Transaction Recovery  
│   ├── Log-Based Recovery, Checkpointing  
└── Replication and Multimedia Systems  
    ├── Replication (Distributed Databases)  
    └── Distributed Multimedia Systems (Netflix, YouTube)
```