Page History

#include <stdlib.h><mutex>
#include <threads.h><thread>
  
typedefclass structBankAccount {
  int balance;
public:
  mtx_t balance_mutex;
} bank_account;

typedef struct {
  bank_account *fromstd::mutex balanceMutex;
  BankAccount() = delete;
  bank_account *to;
  int amount;
} transaction;

void create_bank_account(bank_account **ba,
                         int initial_amount) {
  bank_account *nba = (bank_account *)malloc(
    sizeof(bank_account)
  );
  if (nba == NULL) {
    /* Handle error */
  }

  nba->balance = initial_amount;
  if (thrd_success
      != mtx_init(&nba->balance_mutex, mtx_plain)) {
    /* Handle error */
  }

  *ba = nba;
}

int deposit(void *ptr) {
  transaction *args = (transaction *)ptr;

  if (thrd_success != mtx_lock(&args->from->balance_mutex)) {
    /* Handle error */
  }

  /*explicit BankAccount(int initialAmount) : balance(initialAmount) {}
  int get_balance() const { return balance; }
  void set_balance(int amount) { balance = amount; }
};
 
int deposit(BankAccount *from, BankAccount *to, int amount) {
  std::lock_guard<std::mutex> from_lock(from->balanceMutex);
 
  // Not enough balance to transfer */.
  if (args->from->balancefrom->get_balance() < args->amountamount) {
    if (thrd_success
        != mtx_unlock(&args->from->balance_mutex)) {
      /* Handle error */
    }
    return -1; /*/ Indicate error */
  }
  if (thrd_success != mtxstd::lock_guard<std::mutex> to_lock(&args->to->balance_mutex)) {
    /* Handle error */
  }

  args->from->balance -= args->amountto->balanceMutex);
 
  from->set_balance(from->get_balance() - amount);
  args->to->balance += args->amount;

  if (thrd_success
      != mtx_unlock(&args->from->balance_mutex)) {
    /* Handle error */
  }

  if (thrd_success
      != mtx_unlock(&args->to->balance_mutex)) {
    /* Handle error */
  }

  free(ptr);to->set_balance(to->get_balance() + amount);
 
  return 0;
}
 
intvoid main(void) {
  thrd_t thr1, thr2;
  transaction *arg1;
  transaction *arg2;
  bank_accountf(BankAccount *ba1;
, BankAccount bank_account *ba2;

  create_bank_account(&ba1, 1000);
  create_bank_account(&ba2, 1000);

  arg1 = (transaction *)malloc(sizeof(transaction));
  if (arg1 == NULL) {
    /* Handle error */
 Perform }
  arg2 = (transaction *)malloc(sizeof(transaction));the deposits.
  ifstd::thread thr1(arg2 == NULL) {
    /* Handle error */
  }
  arg1->from = ba1;
  arg1->to = ba2;
  arg1->amount = 100;

  arg2->from = ba2;
  arg2->to = ba1;
  arg2->amount = 100;

  /* Perform the deposits */
  if (thrd_success
     != thrd_create(&thr1, deposit, (void *)arg1)) {
    /* Handle error */
  }
  if (thrd_success
      != thrd_create(&thr2, deposit, (void *)arg2)) {
    /* Handle error */
  }
  return 0;
} 

deposit, ba1, ba2, 100);
  std::thread thr2(deposit, ba2, ba1, 100);
  thr1.join();
  thr2.join();
}

#include <stdlib.h><atomic>
#include <mutex>
#include <threads.h><thread>
  
typedefclass structBankAccount {
  int balance;
  mtx_t balance_mutex;
 static std::atomic<unsigned int> globalId;
  /* Should not change after initialization */
  const unsigned int id;
} bank_account  int balance;
public:
typedef struct {  std::mutex balanceMutex;
  bank_account *fromBankAccount() = delete;
  bank_account *to;
  int amount;
} transaction;

explicit BankAccount(int initialAmount) : id(globalId++), balance(initialAmount) {}
  unsigned int globalget_id = 1;

void create_bank_account(bank_account **ba,() const { return id; }
  int get_balance() const { return balance; }
  void set_balance(int amount) { balance = amount; }
};

std::atomic<unsigned int> BankAccount::globalId(1);
 
int deposit(BankAccount *from, BankAccount *to, int initial_amount) {
  bank_accountstd::mutex *nbafirst;
 = (bank_account *)malloc(
    sizeof(bank_account)
  );
  if (nba == NULL std::mutex *second;
 
  if (from->get_id() == to->get_id()) {
    return -1; /*/ HandleIndicate error */
  }
 
  nba->balance = initial_amount;
  if (thrd_success
      != mtx_init(&nba->balance_mutex, mtx_plain// Ensure proper ordering for locking.
  if (from->get_id() < to->get_id()) {
    /*first Handle error */= &from->balanceMutex;
  }

  nba->idsecond = global_id++&to->balanceMutex;
  *ba = nba;
}

int deposit(void *ptr) else {
  transaction  *argsfirst = (transaction *)ptr&to->balanceMutex;
  int  resultsecond = &from-1>balanceMutex;
  mtx_t *first}
  std::lock_guard<std::mutex> firstLock(*first);
  mtx_t std::lock_guard<std::mutex> secondLock(*second);
 
  // Check for enough balance to transfer.
  if (args->from->id == args->to->id) {from->get_balance() >= amount) {
    from->set_balance(from->get_balance() - amount);
    return -1; /* Indicate error */
  }

  /* Ensure proper ordering for locking */
  if (args->from->id < args->to->id) {
    first = &args->from->balance_mutex;
    second = &args->to->balance_mutex;
  } else {
    first = &args->to->balance_mutex;
    second = &args->from->balance_mutex;
  }
  if (thrd_success != mtx_lock(first)) {
    /* Handle error */
  }
  if (thrd_success != mtx_lock(second)) {
    /* Handle error */
  }

  /* Not enough balance to transfer */
  if (args->from->balance >= args->amountto->set_balance(to->get_balance() + amount);
    return 0;
  }
  return -1;
}
 
void f(BankAccount *ba1, BankAccount *ba2) {
  // Perform the deposits.
  std::thread thr1(deposit, ba1, ba2, 100);
  std::thread thr2(deposit, ba2, ba1, 100);
  thr1.join();
  thr2.join();
}