Scribd Logo
Upload

Welcome to Scribd!

  • 12 views

    Java Banking Codes

    Uploaded by

    zoyaar winifred
    The document contains code for two different implementations of a thread-safe bank account class in Java. The first implementation uses a ReentrantLock to synchronize access to the account balance when depositing or withdrawing funds. The second implementation uses the synchronized keyword on the deposit and withdraw methods to achieve thread-safety without an explicit lock. Both implementations create multiple thread objects to simulate concurrent transactions and ensure their completion before printing the final balance.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd

    Java Banking Codes

    Uploaded by

    zoyaar winifred
    12 views3 pages
    The document contains code for two different implementations of a thread-safe bank account class in Java. The first implementation uses a ReentrantLock to synchronize access to the account balance when depositing or withdrawing funds. The second implementation uses the synchronized keyword on the deposit and withdraw methods to achieve thread-safety without an explicit lock. Both implementations create multiple thread objects to simulate concurrent transactions and ensure their completion before printing the final balance.

    Original Title

    java banking codes

    Copyright

    © © All Rights Reserved

    Available Formats

    TXT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document contains code for two different implementations of a thread-safe bank account class in Java. The first implementation uses a ReentrantLock to synchronize access to the account balance when depositing or withdrawing funds. The second implementation uses the synchronized keyword on the deposit and withdraw methods to achieve thread-safety without an explicit lock. Both implementations create multiple thread objects to simulate concurrent transactions and ensure their completion before printing the final balance.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    12 views3 pages

    Java Banking Codes

    Uploaded by

    zoyaar winifred
    The document contains code for two different implementations of a thread-safe bank account class in Java. The first implementation uses a ReentrantLock to synchronize access to the account balance when depositing or withdrawing funds. The second implementation uses the synchronized keyword on the deposit and withdraw methods to achieve thread-safety without an explicit lock. Both implementations create multiple thread objects to simulate concurrent transactions and ensure their completion before printing the final balance.

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    of 3

    import java.util.concurrent.locks.

    ReentrantLock;

    class BankAccount {
    private double balance;
    private final ReentrantLock lock = new ReentrantLock();

    public BankAccount(double initialBalance) {


    this.balance = initialBalance;
    }

    public double getBalance() {


    return balance;
    }

    public void deposit(double amount) {


    lock.lock();
    try {
    balance += amount;
    System.out.println("Deposited: $" + amount);
    } finally {
    lock.unlock();
    }
    }

    public void withdraw(double amount) {


    lock.lock();
    try {
    if (balance >= amount) {
    balance -= amount;
    System.out.println("Withdrawn: $" + amount);
    } else {
    System.out.println("Insufficient balance to withdraw: $" + amount);
    }
    } finally {
    lock.unlock();
    }
    }
    }

    public class BankingSystem {


    public static void main(String[] args) {
    BankAccount account = new BankAccount(1000.0);

    // Create two threads for simultaneous transactions


    Thread thread1 = new Thread(() -> {
    account.deposit(200.0);
    account.withdraw(300.0);
    });

    Thread thread2 = new Thread(() -> {


    account.deposit(100.0);
    account.withdraw(150.0);
    });

    // Start the threads


    thread1.start();
    thread2.start();

    // Wait for both threads to finish


    try {
    thread1.join();
    thread2.join();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }

    // Print the final balance


    System.out.println("Final Balance: $" + account.getBalance());
    }
    }

    ////////////////////second codes////////////////////////////

    class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {


    this.balance = initialBalance;
    }

    public synchronized void deposit(double amount) {


    balance += amount;
    System.out.println("Deposited: " + amount + ", New Balance: " + balance);
    }

    public synchronized void withdraw(double amount) {


    if (balance >= amount) {
    balance -= amount;
    System.out.println("Withdrawn: " + amount + ", New Balance: " +
    balance);
    } else {
    System.out.println("Insufficient balance for withdrawal.");
    }
    }
    }

    class TransactionThread extends Thread {


    private BankAccount account;
    private boolean isDeposit;
    private double amount;

    public TransactionThread(BankAccount account, boolean isDeposit, double amount)


    {
    this.account = account;
    this.isDeposit = isDeposit;
    this.amount = amount;
    }

    public void run() {


    if (isDeposit) {
    account.deposit(amount);
    } else {
    account.withdraw(amount);
    }
    }
    }

    public class BankingSystem {


    public static void main(String[] args) {
    BankAccount account = new BankAccount(1000.0);

    TransactionThread depositThread1 = new TransactionThread(account, true,


    200.0);
    TransactionThread withdrawThread1 = new TransactionThread(account, false,
    300.0);
    TransactionThread depositThread2 = new TransactionThread(account, true,
    100.0);
    TransactionThread withdrawThread2 = new TransactionThread(account, false,
    150.0);

    depositThread1.start();
    withdrawThread1.start();
    depositThread2.start();
    withdrawThread2.start();

    try {
    depositThread1.join();
    withdrawThread1.join();
    depositThread2.join();
    withdrawThread2.join();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }

    System.out.println("Final Balance: " + account.getBalance());


    }
    }

    You might also like