BankAccount.java

package com.javaMultithreading;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BankAccount {
	private int accountNumber;
	private double balance;
	private double overdraftLimit;
	private Lock lock = new ReentrantLock();
	private List<Transcation> history = new ArrayList<>();
	
	public BankAccount(int accountNumber, double balance, double overdraftLimit) {
		this.accountNumber = accountNumber;
		this.balance = balance;
		this.overdraftLimit = overdraftLimit;
	}
	public int getAccountNumber() {
		return accountNumber;
	}
	
	public Lock getLock() {
		return lock;
	}
	public void deposit(double amount) {
		lock.lock();
		try {
			balance +=amount;
			history.add(new Transcation("Deposit",amount));
			System.out.println(Thread.currentThread().getName()+"deposited"+amount+" to A/C"+ accountNumber);
		}finally {
			lock.unlock();
		}
	}
	public boolean withdraw(double amount) {
		lock.lock();
		try {
			if(balance- amount <-overdraftLimit) {
				System.out.println(Thread.currentThread().getName()+"withdrawal denied (overdraft limit exceeded) A/C"+accountNumber);
				return false;
			}
			balance-= amount;
			history.add(new Transcation("withdraw", amount));
			System.out.println(Thread.currentThread().getName()+"withdraw"+amount+ "from A/C"+accountNumber);
			return true;
		}
		finally {
			lock.unlock();
		}
	}
	public double getBalance() {
		lock.lock();
		try {
			return balance;
		}
		finally {
			lock.unlock();
		}
	}
	
	public void printTranscationHistory() {
		lock.lock();
		try {
			System.out.println("Transcation History for A/C"+accountNumber);
			for(Transcation t: history) {
				System.out.println(t);
			}
		}
		finally {
			lock.unlock();
		}
	}
}