Two accounts, two locks, one deadlock

A banking system has two accounts, each with its own mutex. Two threads attempt transfers in opposite directions.

void transfer(Account *from, Account *to, int amount) {
    pthread_mutex_lock(&from->lock);
    pthread_mutex_lock(&to->lock);

    from->balance -= amount;
    to->balance   += amount;

    pthread_mutex_unlock(&to->lock);
    pthread_mutex_unlock(&from->lock);
}

/* Thread A */
transfer(&account1, &account2, 100);

/* Thread B (runs concurrently) */
transfer(&account2, &account1, 50);

1. The interleaving. Thread A acquires account1->lock, then is preempted. Thread B acquires account2->lock. Thread A now waits for account2->lock while holding account1->lock. Thread B waits for account1->lock while holding account2->lock. Circular wait. Deadlock.
2. Check the four conditions. Mutual exclusion — yes, both locks are exclusive. Hold-and-wait — yes, each thread holds one lock while requesting another. No-preemption — yes, neither thread releases voluntarily. Circular wait — yes.
3. Fix by breaking circular wait. Impose a global ordering on locks. Lock the lower-numbered account first, regardless of which is "from" and which is "to".

void transfer(Account *a, Account *b, int amount) {
    Account *first  = (a->id < b->id) ? a : b;
    Account *second = (a->id < b->id) ? b : a;

    pthread_mutex_lock(&first->lock);
    pthread_mutex_lock(&second->lock);
    /* ... */
}

With a consistent global ordering, circular wait is impossible. Thread B now also locks account1 first, so the two threads contend on the same lock rather than forming a cycle. One proceeds, the other waits its turn.