Why is this form of block synchronizing faster than the other?

Question

So, I just finished this assignment about synchronization, and I'm curious about the results I got, as I don't quite understand why one form is faster than the other.

There's an account class, defined as follows:

public class Account {

    /*
     * ------------
     * Data members
     * ------------
     */

    /**
     * Attribute presents an account number
     */

    private int acc;
    /**
     * Attribute that presents an customer name
     */
    private String name;
    /**
     * Attribute that presents an account balance
     */
    private double balance;

    /*
     * ------------
     * Constructors
     * ------------
     */

    /**
     * Assigns account number, name and balance.
     *
     * @param acc A unique integer that represents account number
     * @param name A string indicating human-readable customer's name
     * @param balance A double indicating account balance
     */

    public Account(int acc, String name, double balance) {
        super();
        this.acc = acc;
        this.name = name;
        this.balance = balance;
    }


    @Override
    /**
     * equals method works as == operator 
     * it checks if two accounts are identical
     */
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Account other = (Account) obj;
        if (acc != other.acc)
            return false;
        if (Double.doubleToLongBits(balance) != Double
                .doubleToLongBits(other.balance))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (acc!=other.acc)return false;
        return true;
    }

    /**
     * Accessor for account no
     * @return account no
     */
    public int getAcc() {
        return acc;
    }

    /**
     * Mutator for account no 
     * @param acc A unique int for acoount number
     */
    public void setAcc(int acc) {
        this.acc = acc;
    }

    /**
     * Accessor for a customer's name
     * @return a customer's name
     */
    public String getName() {
        return name;
    }

    /**
     * Mutator for a customer name
     * @param name A string that represents a customer name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Accessor for account balance
     * @return an account balance
     */
    public double getBalance() {
        return balance;
    }

    /**
     * Mutator for account balance
     * @param balance A double that represents an account balance
     */
    public void setBalance(double balance) {
        this.balance = balance;
    }

    /**
     * A method to print this account 
     */
    public String toString(){
        return "Account: "+acc+" \tName: "+name+" \tBalance:\t"+balance;
    }

    /**
     * A method that allows a customer to deposit money into this account
     * @param amount A double that represents a deposit amount
     */
    public void debosit(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance + amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;

    }

    /**
     * A method that allows a customer to withdraw money from this account
     * @param amount A double that represents a withdrawal amount
     */
    public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }


}

public void debosit(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance + amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;

    }

    /**
     * A method that allows a customer to withdraw money from this account
     * @param amount A double that represents a withdrawal amount
     */
    public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }

The depositor class looks like this:

public class Depositor extends Thread {
    private Account account ;
    public Depositor(Account account){
        this.account = account;
    }


    public void run(){
        synchronized(account){
        for (int i=0;i<10000000;i++)
        {
            account.debosit(10);
            }
        /*          
        try {
                sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }*/
        }

    }

}

And the withdrawer class, is similar to deposit, just running the withdraw method instead of the deposit one.

The class with the main method is as follows:

public class AccountManager {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Account [] account = new Account[10];
        Depositor [] deposit = new Depositor[10];
        Withdrawer [] withdraw = new Withdrawer[10];

        // The birth of  10 accounts
        account[0] = new Account(1234,"Mike",1000);
        account[1] = new Account(2345,"Adam",2000);
        account[2] = new Account(3456,"Linda",3000);
        account[3] = new Account(4567,"John",4000);
        account[4] = new Account(5678,"Rami",5000);
        account[5] = new Account(6789,"Lee",6000);
        account[6] = new Account(7890,"Tom",7000);
        account[7] = new Account(8901,"Lisa",8000);
        account[8] = new Account(9012,"Sam",9000);
        account[9] = new Account(4321,"Ted",10000);

        // The birth of 10 depositors 
        deposit[0] = new Depositor(account[0]);
        deposit[1] = new Depositor(account[1]);
        deposit[2] = new Depositor(account[2]);
        deposit[3] = new Depositor(account[3]);
        deposit[4] = new Depositor(account[4]);
        deposit[5] = new Depositor(account[5]);
        deposit[6] = new Depositor(account[6]);
        deposit[7] = new Depositor(account[7]);
        deposit[8] = new Depositor(account[8]);
        deposit[9] = new Depositor(account[9]);

        // The birth of  10 withdraws 
        withdraw[0] = new Withdrawer(account[0]);
        withdraw[1] = new Withdrawer(account[1]);
        withdraw[2] = new Withdrawer(account[2]);
        withdraw[3] = new Withdrawer(account[3]);
        withdraw[4] = new Withdrawer(account[4]);
        withdraw[5] = new Withdrawer(account[5]);
        withdraw[6] = new Withdrawer(account[6]);
        withdraw[7] = new Withdrawer(account[7]);
        withdraw[8] = new Withdrawer(account[8]);
        withdraw[9] = new Withdrawer(account[9]);

        System.out.println("Print initial account balances");
        // Print initial account balances
        for(int i=0;i<10;i++)
            System.out.println(account[i]);

        // Get start time in milliseconds 
        long start = System.currentTimeMillis(); 

        System.out.println("Depositor and Withdrawal threads have been created");
        /*
         * Interleave all threads
         */
        for(int i=0; i<10; i++){
            deposit[i].start();
            withdraw[i].start();
        }


        for(int i=0; i<10; i++){
            try {
                deposit[i].join();
                withdraw[i].join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        // Get elapsed time in milliseconds 
        long elapsedTimeMillis = System.currentTimeMillis()-start; 

        System.out.println("Print final account balances after all the child thread terminated...");
        // Print final account balances after all the child thread terminated...    
        for(int i=0;i<10;i++)
            System.out.println(account[i]);
        // Get elapsed time in seconds 
        float elapsedTimeSec = elapsedTimeMillis/1000F;

        System.out.println("Elapsed time in milliseconds "+elapsedTimeMillis);
        System.out.println("Elapsed time in seconds is "+elapsedTimeSec);

        //  Get elapsed time in minutes 
        float elapsedTimeMin = elapsedTimeMillis/(60*1000F); 
        // Get elapsed time in hours 
        float elapsedTimeHour = elapsedTimeMillis/(60*60*1000F); 
        // Get elapsed time in days 
        float elapsedTimeDay = elapsedTimeMillis/(24*60*60*1000F); 

    }

}

Sorry, lots of code, but finally my question:

If I use block synchronization, I can put it directly in the account class, as follows:

public void withdraw(double amount){

        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements

        double k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
            synchronized(this)
                balance = balance - amount;
        // Waste some time doing fake computations
        // do not remove or modify any of the following 3 statements
        k = 999999999;
        for(int i=0;i<100;i++)
            k = k / 2;
    }

This solution, when done on both, takes 1 second total to run. However, if I move the synchronization to the withdrawer and depositor classes, it looks like this:

public void run(){

        // Withdraw 10 CAD into instance variable account
        for (int i=0;i<10000000;i++)
        {
            synchronized(account)
                account.withdraw(10);

        }
    }

And this takes about 1/10th the time to run.

Why is this? Shouldn't they take the same amount of time?

Answer 1

Locking has an overhead. If you lock 100 times more, it should have 100 more locking overhead.

The reason you don't see a 100 fold difference, but only 10, is because the code is doing something else, but if you only had locking, you'd notice a greater difference. Unless the JIT compiler would notice the synchronized block in the loop and hoist it out, but it seems it didn't do it in your test.

Answer 2

If the synchronized block is on withdraw() method, only one thread can execute the method at a time, which means when one thread is doing the "fake calculation" other threads must wait. It looks like this:

acquire lock -> fake calc -> modify balance -> fake calc -> release lock

However, if you synchronize only on the one line changing balance in the method, while 1 thread owns the lock, other threads can do the "fake calculation" and it saves some time. It looks like this

fake calc -> acquire lock -> modify balance -> release lock -> fake calc

Notice that in the second way of synchronizing, a thread can acquire the lock right after another thread modifies the balance and releases the lock, so it doesn't have to wait for the fake calculation