From 976bc34fd9b19cb5f706333ef1cb8eb4b85562d2 Mon Sep 17 00:00:00 2001
From: mohammadreza <mohammadrezaashrafian2@gmail.com>
Date: Sun, 14 Jun 2026 22:36:05 +0330
Subject: [PATCH] implement BankAccount.java

---
 .../java/dev/banking/model/BankAccount.java   | 103 +++++++++---------
 1 file changed, 53 insertions(+), 50 deletions(-)

diff --git a/src/main/java/dev/banking/model/BankAccount.java b/src/main/java/dev/banking/model/BankAccount.java
index 745ede2..71bde96 100644
--- a/src/main/java/dev/banking/model/BankAccount.java
+++ b/src/main/java/dev/banking/model/BankAccount.java
@@ -1,18 +1,12 @@
 package dev.banking.model;
 
+import java.util.concurrent.locks.ReentrantLock;
+
 public class BankAccount {
 
     private final int accountId;
     private long balance;
-
-    /*
-     * Students may introduce additional fields
-     * such as:
-     * - Lock / ReentrantLock
-     * - ReadWriteLock
-     * - Object monitor
-     * - etc.
-     */
+    private static ReentrantLock lock = new ReentrantLock();
 
     public BankAccount(int accountId, long initialBalance) {
         this.accountId = accountId;
@@ -23,56 +17,65 @@ public class BankAccount {
         return accountId;
     }
 
-    /*
-     * TODO:
-     * Return the current balance in a thread-safe way.
-     *
-     * Requirements:
-     * - Must be safe under concurrent reads/writes
-     * - Should not block unnecessarily if using read/write locks
-     */
     public long getBalance() {
-        throw new UnsupportedOperationException("TODO: implement thread-safe balance read");
+
+        lock.lock();
+
+        try {
+            return balance;
+        }
+        finally {
+            lock.unlock();
+        }
     }
 
-    /*
-     * TODO:
-     * Increase balance atomically.
-     *
-     * Requirements:
-     * - Must not lose updates under concurrency
-     */
     public void deposit(long amount) {
-        throw new UnsupportedOperationException("TODO: implement thread-safe deposit");
+
+        lock.lock();
+
+        try {
+            balance += amount;
+        }
+        finally {
+            lock.unlock();
+        }
     }
 
-    /*
-     * TODO:
-     * Decrease balance atomically.
-     *
-     * Requirements:
-     * - Must not cause race conditions
-     * - Negative balance handling is NOT required unless you decide
-     *   to extend the system (optional)
-     */
     public void withdraw(long amount) {
-        throw new UnsupportedOperationException("TODO: implement thread-safe withdraw");
+
+        lock.lock();
+
+        try {
+            balance -=amount;
+        }
+        finally {
+            lock.unlock();
+        }
     }
 
-    /*
-     * TODO:
-     * Transfer money between two accounts atomically.
-     *
-     * IMPORTANT REQUIREMENTS:
-     * - Must be atomic (no partial transfer)
-     * - Must be deadlock-free
-     * - Must protect both source and target accounts
-     *
-     * HINT:
-     * - Consider global lock ordering using accountId
-     * - Or tryLock with retry strategy
-     */
     public void transfer(BankAccount target, long amount) {
-        throw new UnsupportedOperationException("TODO: implement atomic deadlock-free transfer");
+
+        BankAccount first, second;
+
+        if (this.getBalance() < target.getAccountId()) {
+            first = this;
+            second = target;
+        }
+        else {
+            first = target;
+            second = this;
+        }
+
+        first.lock.lock();
+        second.lock.lock();
+
+        try {
+            first.withdraw(amount);
+            second.deposit(amount);
+        }
+        finally {
+            first.lock.unlock();
+            second.lock.unlock();
+        }
     }
 }
\ No newline at end of file